diff --git a/build.sbt b/build.sbt index 62a91ecc25342b..1f26884c1703ce 100644 --- a/build.sbt +++ b/build.sbt @@ -163,7 +163,8 @@ lazy val utilDependencies = Seq( poiDocx exclude ("org.apache.logging.log4j", "log4j-api"), scratchpad - exclude ("org.apache.logging.log4j", "log4j-api") + exclude ("org.apache.logging.log4j", "log4j-api"), + pdfBox ) lazy val typedDependencyParserDependencies = Seq(junit) diff --git a/docs/en/annotator_entries/AutoGGUFVisionModel.md b/docs/en/annotator_entries/AutoGGUFVisionModel.md new file mode 100644 index 00000000000000..0d6a6c086eabc3 --- /dev/null +++ b/docs/en/annotator_entries/AutoGGUFVisionModel.md @@ -0,0 +1,202 @@ +{%- capture title -%} +AutoGGUFVisionModel +{%- endcapture -%} + +{%- capture description -%} +Multimodal annotator that uses the llama.cpp library to generate text completions with large +language models. It supports ingesting images for captioning. + +At the moment only CLIP based models are supported. + +For settable parameters, and their explanations, see HasLlamaCppInferenceProperties, +HasLlamaCppModelProperties and refer to the llama.cpp documentation of +[server.cpp](https://github.com/ggerganov/llama.cpp/tree/7d5e8777ae1d21af99d4f95be10db4870720da91/examples/server) +for more information. + +If the parameters are not set, the annotator will default to use the parameters provided by +the model. + +This annotator expects a column of annotator type AnnotationImage for the image and +Annotation for the caption. Note that the image bytes in the image annotation need to be +raw image bytes without preprocessing. We provide the helper function +ImageAssembler.loadImagesAsBytes to load the image bytes from a directory. + +Pretrained models can be loaded with `pretrained` of the companion object: + +```scala +val autoGGUFVisionModel = AutoGGUFVisionModel.pretrained() + .setInputCols("image", "document") + .setOutputCol("completions") +``` + +The default model is `"llava_v1.5_7b_Q4_0_gguf"`, if no name is provided. + +For available pretrained models please see the [Models Hub](https://sparknlp.org/models). + +For extended examples of usage, see the +[AutoGGUFVisionModelTest](https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTest.scala) +and the +[example notebook](https://github.com/JohnSnowLabs/spark-nlp/tree/master/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb). + +**Note**: To use GPU inference with this annotator, make sure to use the Spark NLP GPU package and set +the number of GPU layers with the `setNGpuLayers` method. + +When using larger models, we recommend adjusting GPU usage with `setNCtx` and `setNGpuLayers` +according to your hardware to avoid out-of-memory errors. +{%- endcapture -%} + +{%- capture input_anno -%} +IMAGE, DOCUMENT +{%- endcapture -%} + +{%- capture output_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture python_example -%} +import sparknlp +from sparknlp.base import * +from sparknlp.annotator import * +from pyspark.ml import Pipeline +from pyspark.sql.functions import lit + +documentAssembler = DocumentAssembler() \ + .setInputCol("caption") \ + .setOutputCol("caption_document") +imageAssembler = ImageAssembler() \ + .setInputCol("image") \ + .setOutputCol("image_assembler") + +imagesPath = "src/test/resources/image/" +data = ImageAssembler \ + .loadImagesAsBytes(spark, imagesPath) \ + .withColumn("caption", lit("Caption this image.")) # Add a caption to each image. + +nPredict = 40 +model = AutoGGUFVisionModel.pretrained() \ + .setInputCols(["caption_document", "image_assembler"]) \ + .setOutputCol("completions") \ + .setBatchSize(4) \ + .setNGpuLayers(99) \ + .setNCtx(4096) \ + .setMinKeep(0) \ + .setMinP(0.05) \ + .setNPredict(nPredict) \ + .setNProbs(0) \ + .setPenalizeNl(False) \ + .setRepeatLastN(256) \ + .setRepeatPenalty(1.18) \ + .setStopStrings(["", "Llama:", "User:"]) \ + .setTemperature(0.05) \ + .setTfsZ(1) \ + .setTypicalP(1) \ + .setTopK(40) \ + .setTopP(0.95) + +pipeline = Pipeline().setStages([documentAssembler, imageAssembler, model]) +pipeline.fit(data).transform(data) \ + .selectExpr("reverse(split(image.origin, '/'))[0] as image_name", "completions.result") \ + .show(truncate = False) ++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +|image_name |result | ++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +|palace.JPEG |[ The image depicts a large, ornate room with high ceilings and beautifully decorated walls. There are several chairs placed throughout the space, some of which have cushions] | +|egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the scene and appears to be sleeping while holding] | +|hippopotamus.JPEG|[ A large brown hippo is swimming in a body of water, possibly an aquarium. The hippo appears to be enjoying its time in the water and seems relaxed as it floats] | +|hen.JPEG |[ The image features a large chicken standing next to several baby chickens. In total, there are five birds in the scene: one adult and four young ones. They appear to be gathered together] | +|ostrich.JPEG |[ The image features a large, long-necked bird standing in the grass. It appears to be an ostrich or similar species with its head held high and looking around. In addition to] | +|junco.JPEG |[ A small bird with a black head and white chest is standing on the snow. It appears to be looking at something, possibly food or another animal in its vicinity. The scene takes place out] | +|bluetick.jpg |[ A dog with a red collar is sitting on the floor, looking at something. The dog appears to be staring into the distance or focusing its attention on an object in front of it.] | +|chihuahua.jpg |[ A small brown dog wearing a sweater is sitting on the floor. The dog appears to be looking at something, possibly its owner or another animal in the room. It seems comfortable and relaxed]| +|tractor.JPEG |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels and tires. The tractor appears to be parked on top of an empty field with] | +|ox.JPEG |[ A large bull with horns is standing in a grassy field.] | ++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +{%- endcapture -%} + +{%- capture scala_example -%} +import com.johnsnowlabs.nlp.ImageAssembler +import com.johnsnowlabs.nlp.annotator._ +import com.johnsnowlabs.nlp.base._ +import org.apache.spark.ml.Pipeline +import org.apache.spark.sql.DataFrame +import org.apache.spark.sql.functions.lit + +val documentAssembler = new DocumentAssembler() + .setInputCol("caption") + .setOutputCol("caption_document") + +val imageAssembler = new ImageAssembler() + .setInputCol("image") + .setOutputCol("image_assembler") + +val imagesPath = "src/test/resources/image/" +val data: DataFrame = ImageAssembler + .loadImagesAsBytes(ResourceHelper.spark, imagesPath) + .withColumn("caption", lit("Caption this image.")) // Add a caption to each image. + +val nPredict = 40 +val model = AutoGGUFVisionModel.pretrained() + .setInputCols("caption_document", "image_assembler") + .setOutputCol("completions") + .setBatchSize(4) + .setNGpuLayers(99) + .setNCtx(4096) + .setMinKeep(0) + .setMinP(0.05f) + .setNPredict(nPredict) + .setNProbs(0) + .setPenalizeNl(false) + .setRepeatLastN(256) + .setRepeatPenalty(1.18f) + .setStopStrings(Array("", "Llama:", "User:")) + .setTemperature(0.05f) + .setTfsZ(1) + .setTypicalP(1) + .setTopK(40) + .setTopP(0.95f) + +val pipeline = new Pipeline().setStages(Array(documentAssembler, imageAssembler, model)) +pipeline + .fit(data) + .transform(data) + .selectExpr("reverse(split(image.origin, '/'))[0] as image_name", "completions.result") + .show(truncate = false) ++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +|image_name |result | ++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +|palace.JPEG |[ The image depicts a large, ornate room with high ceilings and beautifully decorated walls. There are several chairs placed throughout the space, some of which have cushions] | +|egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the scene and appears to be sleeping while holding] | +|hippopotamus.JPEG|[ A large brown hippo is swimming in a body of water, possibly an aquarium. The hippo appears to be enjoying its time in the water and seems relaxed as it floats] | +|hen.JPEG |[ The image features a large chicken standing next to several baby chickens. In total, there are five birds in the scene: one adult and four young ones. They appear to be gathered together] | +|ostrich.JPEG |[ The image features a large, long-necked bird standing in the grass. It appears to be an ostrich or similar species with its head held high and looking around. In addition to] | +|junco.JPEG |[ A small bird with a black head and white chest is standing on the snow. It appears to be looking at something, possibly food or another animal in its vicinity. The scene takes place out] | +|bluetick.jpg |[ A dog with a red collar is sitting on the floor, looking at something. The dog appears to be staring into the distance or focusing its attention on an object in front of it.] | +|chihuahua.jpg |[ A small brown dog wearing a sweater is sitting on the floor. The dog appears to be looking at something, possibly its owner or another animal in the room. It seems comfortable and relaxed]| +|tractor.JPEG |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels and tires. The tractor appears to be parked on top of an empty field with] | +|ox.JPEG |[ A large bull with horns is standing in a grassy field.] | ++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +{%- endcapture -%} + +{%- capture api_link -%} +[AutoGGUFVisionModel](/api/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel) +{%- endcapture -%} + +{%- capture python_api_link -%} +[AutoGGUFVisionModel](/api/python/reference/autosummary/sparknlp/annotator/seq2seq/auto_gguf_vision_model/index.html) +{%- endcapture -%} + +{%- capture source_link -%} +[AutoGGUFVisionModel](https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel.scala) +{%- endcapture -%} + +{% include templates/anno_template.md +title=title +description=description +input_anno=input_anno +output_anno=output_anno +python_example=python_example +scala_example=scala_example +api_link=api_link +python_api_link=python_api_link +source_link=source_link +%} \ No newline at end of file diff --git a/docs/en/annotators.md b/docs/en/annotators.md index c5c21707b80f8e..541d151533c3ce 100644 --- a/docs/en/annotators.md +++ b/docs/en/annotators.md @@ -47,6 +47,7 @@ There are two types of Annotators: |---|---|---| {% include templates/anno_table_entry.md path="" name="AutoGGUFEmbeddings" summary="Annotator that uses the llama.cpp library to generate text embeddings with large language models."%} {% include templates/anno_table_entry.md path="" name="AutoGGUFModel" summary="Annotator that uses the llama.cpp library to generate text completions with large language models."%} +{% include templates/anno_table_entry.md path="" name="AutoGGUFVisionModel" summary="Multimodal annotator that uses the llama.cpp library to generate text completions with large language models."%} {% include templates/anno_table_entry.md path="" name="BGEEmbeddings" summary="Sentence embeddings using BGE."%} {% include templates/anno_table_entry.md path="" name="BigTextMatcher" summary="Annotator to match exact phrases (by token) provided in a file against a Document."%} {% include templates/anno_table_entry.md path="" name="Chunk2Doc" summary="Converts a `CHUNK` type column back into `DOCUMENT`. Useful when trying to re-tokenize or do further analysis on a `CHUNK` result."%} diff --git a/docs/en/transformer_entries/CoHereTransformer.md b/docs/en/transformer_entries/CoHereTransformer.md new file mode 100644 index 00000000000000..23ad849e7c829a --- /dev/null +++ b/docs/en/transformer_entries/CoHereTransformer.md @@ -0,0 +1,110 @@ + + +{%- capture title -%} +CoHereTransformer +{%- endcapture -%} + +{%- capture description -%} +Text Generation using Cohere Command-R. + +C4AI Command-R is a research release of a 35 billion parameter highly performant generative model. +Command-R is a large language model with open weights optimized for a variety of use cases including reasoning, +summarization, and question answering. Command-R has the capability for multilingual generation evaluated +in 10 languages and highly performant RAG capabilities. + +Pretrained models can be loaded with `pretrained` of the companion object: + +```scala +val CoHere = CoHereTransformer.pretrained() + .setInputCols("document") + .setOutputCol("generation") +``` +{%- capture input_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture output_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture python_example -%} +import sparknlp +from sparknlp.base import * +from sparknlp.annotator import * +from pyspark.ml import Pipeline + +documentAssembler = DocumentAssembler() + .setInputCol("text") + .setOutputCol("documents") +CoHere = CoHereTransformer.pretrained("c4ai_command_r_v01_int4","en") + .setInputCols(["documents"]) + .setMaxOutputLength(60) + .setOutputCol("generation") +pipeline = Pipeline().setStages([documentAssembler, CoHere]) +data = spark.createDataFrame([ + ( + 1, + "<|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>" + ) + ]).toDF("id", "text") +result = pipeline.fit(data).transform(data) +result.select("generation.result").show(truncate=False) +{%- endcapture -%} + +{%- capture scala_example -%} +import spark.implicits._ +import com.johnsnowlabs.nlp.base.DocumentAssembler +import com.johnsnowlabs.nlp.annotators.seq2seq.CoHereTransformer +import org.apache.spark.ml.Pipeline + +val documentAssembler = new DocumentAssembler() + .setInputCol("text") + .setOutputCol("documents") + +val CoHere = CoHereTransformer.pretrained("c4ai_command_r_v01_int4") + .setInputCols(Array("documents")) + .setMinOutputLength(15) + .setMaxOutputLength(60) + .setDoSample(false) + .setTopK(40) + .setNoRepeatNgramSize(3) + .setOutputCol("generation") + +val pipeline = new Pipeline().setStages(Array(documentAssembler, CoHere)) + +val data = Seq( + ( + 1, + """ + <|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|> + """.stripMargin) +).toDF("id", "text") + +val result = pipeline.fit(data).transform(data) + +result.select("generation.result").show(truncate = false) +{%- endcapture -%} + +{%- capture api_link -%} +[CoHereTransformer](/api/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTransformer) +{%- endcapture -%} + +{%- capture python_api_link -%} +[CoHereTransformer](/api/python/reference/autosummary/sparknlp/annotator/seq2seq/cohere/index.html#sparknlp.annotator.seq2seq.cohere.CoHereTransformer) +{%- endcapture -%} + +{%- capture source_link -%} +[CoHereTransformer](https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTransformer.scala) +{%- endcapture -%} + +{% include templates/anno_template.md +title=title +description=description +input_anno=input_anno +output_anno=output_anno +python_example=python_example +scala_example=scala_example +api_link=api_link +python_api_link=python_api_link +source_link=source_link +%} \ No newline at end of file diff --git a/docs/en/transformer_entries/LLAVAForMultiModal.md b/docs/en/transformer_entries/LLAVAForMultiModal.md new file mode 100644 index 00000000000000..4b41694569baf4 --- /dev/null +++ b/docs/en/transformer_entries/LLAVAForMultiModal.md @@ -0,0 +1,122 @@ +{%- capture title -%} +LLAVAForMultiModal +{%- endcapture -%} + +{%- capture description -%} +Visual Question Answering using LLAVA. + +LLAVAForMultiModal can load LLAVA models for visual question answering. +The model consists of a vision encoder, a text encoder as well as a text decoder. +The vision encoder will encode the input image, the text encoder will encode the input question together +with the encoding of the image, and the text decoder will output the answer to the question. + +Pretrained models can be loaded with `pretrained` of the companion object: + +```scala +val visualQA = LLAVAForMultiModal.pretrained() + .setInputCols("image_assembler") + .setOutputCol("answer") +``` +The default model is `"llava_1_5_7b_hf"`, if no name is provided. + +For available pretrained models please see the +[Models Hub](https://sparknlp.org/models?task=Question+Answering). + +To see which models are compatible and how to import them see +[Import Transformers into Spark NLP 🚀](https://github.com/JohnSnowLabs/spark-nlp/discussions/5669). + +{%- endcapture -%} + +{%- capture input_anno -%} +IMAGE +{%- endcapture -%} + +{%- capture output_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture python_example -%} +import sparknlp +from sparknlp.base import * +from sparknlp.annotator import * +from pyspark.ml import Pipeline +from pyspark.sql.functions import lit + +image_df = spark.read.format("image").load(path=images_path) # Replace with your image path +test_df = image_df.withColumn("text", lit("USER: \n <|image|> \n What's this picture about? \n ASSISTANT:\n")) + +imageAssembler = ImageAssembler() + .setInputCol("image") + .setOutputCol("image_assembler") + +visualQAClassifier = LLAVAForMultiModal.pretrained() + .setInputCols("image_assembler") + .setOutputCol("answer") + +pipeline = Pipeline().setStages([ + imageAssembler, + visualQAClassifier +]) + +result = pipeline.fit(test_df).transform(test_df) +result.select("image_assembler.origin", "answer.result").show(False) +{%- endcapture -%} + +{%- capture scala_example -%} +import spark.implicits._ +import com.johnsnowlabs.nlp.base._ +import com.johnsnowlabs.nlp.annotator._ +import org.apache.spark.ml.Pipeline +import org.apache.spark.sql.DataFrame +import org.apache.spark.sql.functions.lit + +val imageFolder = "path/to/your/images" // Replace with your image path + +val imageDF: DataFrame = spark.read + .format("image") + .option("dropInvalid", value = true) + .load(imageFolder) + +val testDF: DataFrame = imageDF.withColumn("text", lit("USER: \n <|image|> \nWhat is unusual on this picture? \n ASSISTANT:\n")) + +val imageAssembler: ImageAssembler = new ImageAssembler() + .setInputCol("image") + .setOutputCol("image_assembler") + +val visualQAClassifier = LLAVAForMultiModal.pretrained() + .setInputCols("image_assembler") + .setOutputCol("answer") + +val pipeline = new Pipeline().setStages(Array( + imageAssembler, + visualQAClassifier +)) + +val result = pipeline.fit(testDF).transform(testDF) + +result.select("image_assembler.origin", "answer.result").show(false) +{%- endcapture -%} + +{%- capture api_link -%} +[LLAVAForMultiModal](https://www.google.com/url?sa=E&source=gmail&q=/api/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModal) +{%- endcapture -%} + +{%- capture python_api_link -%} +[LLAVAForMultiModal](https://www.google.com/url?sa=E&source=gmail&q=/api/python/reference/autosummary/sparknlp/annotator/cv/llava_for_multimodal/index.html#sparknlp.annotator.cv.llava_for_multimodal.LLAVAForMultiModal) +{%- endcapture -%} + +{%- capture source_link -%} +[LLAVAForMultiModal](https://www.google.com/url?sa=E&source=gmail&q=https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModal.scala) +{%- endcapture -%} + +{% include templates/anno_template.md +title=title +description=description +input_anno=input_anno +output_anno=output_anno +python_example=python_example +scala_example=scala_example +api_link=api_link +python_api_link=python_api_link +source_link=source_link +%} \ No newline at end of file diff --git a/docs/en/transformer_entries/MLLamaForMultimodal.md b/docs/en/transformer_entries/MLLamaForMultimodal.md new file mode 100644 index 00000000000000..f97456d9c795e4 --- /dev/null +++ b/docs/en/transformer_entries/MLLamaForMultimodal.md @@ -0,0 +1,116 @@ +{%- capture title -%} +MLLamaForMultimodal +{%- endcapture -%} + +{%- capture description -%} +Visual Question Answering using MLLama. + +MLLamaForMultimodal can load LLAMA 3.2 Vision models for visual question answering. +The model consists of a vision encoder, a text encoder, and a text decoder. +The vision encoder encodes the input image, the text encoder processes the input question +alongside the image encoding, and the text decoder generates the answer to the question. + +The Llama 3.2-Vision collection comprises pretrained and instruction-tuned multimodal large +language models (LLMs) available in 11B and 90B sizes. These models are optimized for visual +recognition, image reasoning, captioning, and answering general questions about images. +The models outperform many open-source and proprietary multimodal models on standard industry +benchmarks. + +Pretrained models can be loaded with `pretrained` of the companion object: + +```scala +val visualQAClassifier = MLLamaForMultimodal.pretrained() + .setInputCols("image_assembler") + .setOutputCol("answer") +``` +{%- capture input_anno -%} +IMAGE +{%- endcapture -%} + +{%- capture output_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture python_example -%} +import sparknlp +from sparknlp.base import * +from sparknlp.annotator import * +from pyspark.ml import Pipeline +from pyspark.sql.functions import lit + +image_df = spark.read.format("image").load(path=images_path) # Replace with your image path +test_df = image_df.withColumn( +    "text", +    lit("<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n") +) +imageAssembler = ImageAssembler() \\ +    .setInputCol("image") \\ +    .setOutputCol("image_assembler") +visualQAClassifier = MLLamaForMultimodal.pretrained() \\ +    .setInputCols("image_assembler") \\ +    .setOutputCol("answer") +pipeline = Pipeline().setStages([ +    imageAssembler, +    visualQAClassifier +]) +result = pipeline.fit(test_df).transform(test_df) +result.select("image_assembler.origin", "answer.result").show(truncate=False) + +{%- endcapture -%} + +{%- capture scala_example -%} +import spark.implicits._ +import com.johnsnowlabs.nlp.base._ +import com.johnsnowlabs.nlp.annotator._ +import org.apache.spark.ml.Pipeline +import org.apache.spark.sql.DataFrame +import org.apache.spark.sql.functions.lit + +val imageDF: DataFrame = spark.read +  .format("image") +  .option("dropInvalid", value = true) +  .load(imageFolder) // Replace with your image folder + +val testDF: DataFrame = imageDF.withColumn("text", lit("<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n")) + +val imageAssembler: ImageAssembler = new ImageAssembler() +   .setInputCol("image") +   .setOutputCol("image_assembler") + +val visualQAClassifier = MLLamaForMultimodal.pretrained() +   .setInputCols("image_assembler") +   .setOutputCol("answer") + +val pipeline = new Pipeline().setStages(Array( +  imageAssembler, +  visualQAClassifier +)) + +val result = pipeline.fit(testDF).transform(testDF) + +result.select("image_assembler.origin", "answer.result").show(truncate=false) +{%- endcapture -%} + +{%- capture api_link -%} +[MLLamaForMultimodal](/api/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodal) +{%- endcapture -%} + +{%- capture python_api_link -%} +[MLLamaForMultimodal](/api/python/reference/autosummary/sparknlp/annotator/cv/m_llama_for_multimodal/index.html#sparknlp.annotator.cv.mllama_for_multimodal.MLLamaForMultimodal) +{%- endcapture -%} + +{%- capture source_link -%} +[MLLamaForMultimodal](https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodal.scala) +{%- endcapture -%} + +{% include templates/anno_template.md +title=title +description=description +input_anno=input_anno +output_anno=output_anno +python_example=python_example +scala_example=scala_example +api_link=api_link +python_api_link=python_api_link +source_link=source_link +%} \ No newline at end of file diff --git a/docs/en/transformer_entries/OLMoTransformer.md b/docs/en/transformer_entries/OLMoTransformer.md new file mode 100644 index 00000000000000..77f7235481d9c4 --- /dev/null +++ b/docs/en/transformer_entries/OLMoTransformer.md @@ -0,0 +1,135 @@ +{%- capture title -%} +OLMoTransformer +{%- endcapture -%} + +{%- capture description -%} +OLMo, a series of Open Language Models, is designed to enable the science of language models. These models are trained on the Dolma dataset, offering open-source capabilities for language model research and application. The OLMo models support various NLP tasks including text generation, summarization, and more. + +Pretrained models can be loaded using the `pretrained` method from the companion object: + + +```scala +val olmo = OLMoTransformer.pretrained() + .setInputCols("document") + .setOutputCol("generation") +``` + +The default model is `"olmo_1b_int4"`, if no name is provided. + +For available pretrained models please see the +[Models Hub](https://sparknlp.org/models?q=OLMo). + +For extended examples of usage, see +[OLMoTestSpec](https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/OLMoTestSpec.scala). + +**Sources** : +[OLMo Project Page](https://allenai.org/olmo) +[OLMo GitHub Repository](https://github.com/allenai/OLMo) +[OLMo: Accelerating the Science of Language Models (Paper)](https://arxiv.org/pdf/2402.00838.pdf) + +**Paper abstract** + +*Language models (LMs) have become ubiquitous in both NLP research and commercial products. +As their commercial importance has surged, the most powerful models have become proprietary, +limiting scientific study. OLMo addresses this gap by offering an open-source framework, +including training data, models, and code. This initiative aims to empower the research community, +fostering transparency and innovation in language model development.* +{%- endcapture -%} + +{%- capture input_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture output_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture python_example -%} +import sparknlp +from sparknlp.base import * +from sparknlp.annotator import * +from pyspark.ml import Pipeline + +# Document Assembler +document_assembler = DocumentAssembler() \ +.setInputCol("text") \ +.setOutputCol("document") + +# OLMo Transformer +olmo = OLMoTransformer.pretrained("olmo_1b_int4") \ +.setInputCols(["document"]) \ +.setMinOutputLength(10) \ +.setMaxOutputLength(50) \ +.setDoSample(False) \ +.setTopK(50) \ +.setNoRepeatNgramSize(3) \ +.setOutputCol("generation") + +# Pipeline +pipeline = Pipeline(stages=[document_assembler, olmo]) + +# Sample Data +data = spark.createDataFrame([["My name is Leonardo."]]).toDF("text") +result = pipeline.fit(data).transform(data) + +# Display Results +result.select("generation.result").show(truncate=False) + +{%- endcapture -%} + +{%- capture scala_example -%} +import spark.implicits._ +import com.johnsnowlabs.nlp.base.DocumentAssembler +import com.johnsnowlabs.nlp.annotators.seq2seq.OLMoTransformer +import org.apache.spark.ml.Pipeline + +// Document Assembler +val documentAssembler = new DocumentAssembler() +.setInputCol("text") +.setOutputCol("document") + +// OLMo Transformer +val olmo = OLMoTransformer.pretrained("olmo_1b_int4") +.setInputCols(Array("document")) +.setMinOutputLength(10) +.setMaxOutputLength(50) +.setDoSample(false) +.setTopK(50) +.setNoRepeatNgramSize(3) +.setOutputCol("generation") + +// Pipeline +val pipeline = new Pipeline().setStages(Array(documentAssembler, olmo)) + +// Sample Data +val data = Seq("My name is Leonardo.").toDF("text") +val result = pipeline.fit(data).transform(data) + +// Display Results +result.select("generation.result").show(truncate = false) + +{%- endcapture -%} + +{%- capture api_link -%} +[OLMoTransformer](/api/com/johnsnowlabs/nlp/seq2seq/OLMoTransformer) +{%- endcapture -%} + +{%- capture python_api_link -%} +[OLMoTransformer](/api/python/reference/autosummary/sparknlp/annotator/seq2seq/olmo_transformer/index.html#sparknlp.annotator.seq2seq.olmo_transformer.OLMoTransformer) +{%- endcapture -%} + +{%- capture source_link -%} +[OLMoTransformer](https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/main/scala/com/johnsnowlabs/nlp/seq2seq/OLMoTransformer.scala) +{%- endcapture -%} + +{% include templates/anno_template.md +title=title +description=description +input_anno=input_anno +output_anno=output_anno +python_example=python_example +scala_example=scala_example +api_link=api_link +python_api_link=python_api_link +source_link=source_link +%} \ No newline at end of file diff --git a/docs/en/transformer_entries/Phi3Vision.md b/docs/en/transformer_entries/Phi3Vision.md new file mode 100644 index 00000000000000..f1c332373f5a7f --- /dev/null +++ b/docs/en/transformer_entries/Phi3Vision.md @@ -0,0 +1,127 @@ +{%- capture title -%} +Phi3Vision +{%- endcapture -%} + +{%- capture description -%} +Visual Question Answering using Phi3Vision. + +Phi3Vision can load Phi3Vision models for visual question answering. +The model consists of a vision encoder, a text encoder as well as a text decoder. +The vision encoder will encode the input image, the text encoder will encode the input question together +with the encoding of the image, and the text decoder will output the answer to the question. + +Pretrained models can be loaded with `pretrained` of the companion object: + +```scala +val visualQA = Phi3Vision.pretrained() + .setInputCols("image_assembler") + .setOutputCol("answer") +``` + +The default model is `"phi_3_vision_128k_instruct"`, if no name is provided. + +For available pretrained models please see the +[Models Hub](https://sparknlp.org/models?task=Question+Answering). + +Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. To +see which models are compatible and how to import them see +[Import Transformers into Spark NLP 🚀](https://github.com/JohnSnowLabs/spark-nlp/discussions/5669). + +For extended examples of usage, see +[Phi3VisionTestSpec](https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3VisionTest.scala). + +{%- endcapture -%} + +{%- capture input_anno -%} +IMAGE +{%- endcapture -%} + +{%- capture output_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture python_example -%} +import sparknlp +from sparknlp.base import * +from sparknlp.annotator import * +from pyspark.ml import Pipeline +from pyspark.sql.functions import lit + +image_df = spark.read.format("image").load(path=images_path) # Replace with your image path +test_df = image_df.withColumn("text", lit("<|user|> \n <|image_1|> \nWhat is unusual on this picture? <|end|>\n <|assistant|>\n")) + +imageAssembler = ImageAssembler() + .setInputCol("image") + .setOutputCol("image_assembler") + +visualQAClassifier = Phi3Vision.pretrained("phi_3_vision_128k_instruct","en") + .setInputCols("image_assembler") + .setOutputCol("answer") + +pipeline = Pipeline().setStages([ + imageAssembler, + visualQAClassifier +]) + +result = pipeline.fit(test_df).transform(test_df) +result.select("image_assembler.origin", "answer.result").show(False) +{%- endcapture -%} + +{%- capture scala_example -%} +import spark.implicits._ +import com.johnsnowlabs.nlp.base._ +import com.johnsnowlabs.nlp.annotator._ +import org.apache.spark.ml.Pipeline +import org.apache.spark.sql.DataFrame +import org.apache.spark.sql.functions.lit + +val imageFolder = "path/to/your/images" // Replace with your image path + +val imageDF: DataFrame = spark.read + .format("image") + .option("dropInvalid", value = true) + .load(imageFolder) + +val testDF: DataFrame = imageDF.withColumn("text", lit("<|user|> \n <|image_1|> \nWhat is unusual on this picture? <|end|>\n <|assistant|>\n")) + +val imageAssembler: ImageAssembler = new ImageAssembler() + .setInputCol("image") + .setOutputCol("image_assembler") + +val visualQAClassifier = Phi3Vision.pretrained("phi_3_vision_128k_instruct","en") + .setInputCols("image_assembler") + .setOutputCol("answer") + +val pipeline = new Pipeline().setStages(Array( + imageAssembler, + visualQAClassifier +)) + +val result = pipeline.fit(testDF).transform(testDF) + +result.select("image_assembler.origin", "answer.result").show(false) +{%- endcapture -%} + +{%- capture api_link -%} +[Phi3Vision](https://www.google.com/url?sa=E&source=gmail&q=/api/com/johnsnowlabs/nlp/annotators/cv/Phi3Vision) +{%- endcapture -%} + +{%- capture python_api_link -%} +[Phi3Vision](https://www.google.com/url?sa=E&source=gmail&q=/api/python/reference/autosummary/sparknlp/annotator/cv/phi3_vision/index.html#sparknlp.annotator.cv.phi3_vision.Phi3Vision) +{%- endcapture -%} + +{%- capture source_link -%} +[Phi3Vision](https://www.google.com/url?sa=E&source=gmail&q=https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3Vision.scala) +{%- endcapture -%} + +{% include templates/anno_template.md +title=title +description=description +input_anno=input_anno +output_anno=output_anno +python_example=python_example +scala_example=scala_example +api_link=api_link +python_api_link=python_api_link +source_link=source_link +%} \ No newline at end of file diff --git a/docs/en/transformer_entries/Qwen2VLTransformer.md b/docs/en/transformer_entries/Qwen2VLTransformer.md new file mode 100644 index 00000000000000..dd1f7df83ef28c --- /dev/null +++ b/docs/en/transformer_entries/Qwen2VLTransformer.md @@ -0,0 +1,111 @@ +{%- capture title -%} +Qwen2VLTransformer +{%- endcapture -%} + +{%- capture description -%} +Visual Question Answering and Multimodal Instruction Following using Qwen2-VL. + +Qwen2VLTransformer can load Qwen2 Vision-Language models for visual question answering and +multimodal instruction following. The model consists of a vision encoder, a text encoder, and +a text decoder. The vision encoder processes the input image, the text encoder integrates +the encoding of the image with the input text, and the text decoder outputs the response to +the query or instruction. + +Pretrained models can be loaded with `pretrained` of the companion object: + +```scala +val visualQA = Qwen2VLTransformer.pretrained() +  .setInputCols("image_assembler") +  .setOutputCol("answer") +``` +{%- capture input_anno -%} +IMAGE +{%- endcapture -%} + +{%- capture output_anno -%} +DOCUMENT +{%- endcapture -%} + +{%- capture python_example -%} +import sparknlp +from sparknlp.base import * +from sparknlp.annotator import * +from pyspark.ml import Pipeline +from pyspark.sql.functions import lit + +image_df = spark.read.format("image").load(path=images_path) # Replace with your image path +test_df = image_df.withColumn("text", lit("<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n")) + +imageAssembler = ImageAssembler() +    .setInputCol("image") +    .setOutputCol("image_assembler") + +visualQAClassifier = Qwen2VLTransformer.pretrained() +    .setInputCols("image_assembler") +    .setOutputCol("answer") + +pipeline = Pipeline().setStages([ +    imageAssembler, +    visualQAClassifier +]) + +result = pipeline.fit(test_df).transform(test_df) +result.select("image_assembler.origin", "answer.result").show(false) +{%- endcapture -%} + +{%- capture scala_example -%} +import spark.implicits._ +import com.johnsnowlabs.nlp.base._ +import com.johnsnowlabs.nlp.annotator._ +import org.apache.spark.ml.Pipeline +import org.apache.spark.sql.DataFrame +import org.apache.spark.sql.functions.lit + +val imageDF: DataFrame = spark.read +  .format("image") +  .option("dropInvalid", value = true) +  .load(imageFolder) // Replace with your image folder + +val testDF: DataFrame = imageDF.withColumn("text", lit("<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n")) + +val imageAssembler: ImageAssembler = new ImageAssembler() +   .setInputCol("image") +   .setOutputCol("image_assembler") + +val visualQAClassifier = Qwen2VLTransformer.pretrained() +   .setInputCols("image_assembler") +   .setOutputCol("answer") + +val pipeline = new Pipeline().setStages(Array( +  imageAssembler, +  visualQAClassifier +)) + +val result = pipeline.fit(testDF).transform(testDF) + +result.select("image_assembler.origin", "answer.result").show(false) +{%- endcapture -%} + +{%- capture api_link -%} +[Qwen2VLTransformer](/api/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformer) +{%- endcapture -%} + +{%- capture python_api_link -%} +[Qwen2VLTransformer](/api/python/reference/autosummary/sparknlp/annotator/cv/qwen2_vl/index.html#sparknlp.annotator.cv.qwen2_vl.Qwen2VLTransformer) +{%- endcapture -%} + +{%- capture source_link -%} +[Qwen2VLTransformer](https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformer.scala) +{%- endcapture -%} + +{% include templates/anno_template.md +title=title +description=description +input_anno=input_anno +output_anno=output_anno +python_example=python_example +scala_example=scala_example +api_link=api_link +python_api_link=python_api_link +source_link=source_link +%} \ No newline at end of file diff --git a/examples/python/data-preprocessing/SparkNLP_Cleaner_Demo.ipynb b/examples/python/data-preprocessing/SparkNLP_Cleaner_Demo.ipynb new file mode 100644 index 00000000000000..f55ee760c3a8f5 --- /dev/null +++ b/examples/python/data-preprocessing/SparkNLP_Cleaner_Demo.ipynb @@ -0,0 +1,1004 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/reader/SparkNLP_Cleaner_Demo.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "1b585db2-ed1b-4417-b38a-033812c206c3", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "tzcU5p2gdak9" + }, + "source": [ + "# Introducing Cleaner in SparkNLP\n", + "This notebook showcases the newly added `Cleaner()` annotator in Spark NLP to remove unnecessary or undesirable content from datasets, such as bullets, dashes, and non-ASCII characters, enhancing data consistency and readability." + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "68382b5d-51f1-44fc-a913-16b92e44d1ee", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DczWop6QeE8F", + "outputId": "ac97c962-bad5-4d71-d823-da1c67580219" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "Apache Spark version: 3.4.1\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "# let's start Spark with Spark NLP\n", + "spark = sparknlp.start()\n", + "\n", + "print(\"Apache Spark version: {}\".format(spark.version))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "c84cecef-45dc-4169-986c-30c9a6e42377", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "RFOFhaEedalB" + }, + "source": [ + "## Setup and Initialization\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "Support for reading html files was introduced in Spark NLP 6.0.0. Please make sure you have upgraded to the latest Spark NLP release.\n", + "We simple need to import the cleaners components to use `Cleaner` annotator:" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "596ffcc0-90fb-4bfd-8840-88be66f7bb6a", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "stirVdLP-ASE" + }, + "outputs": [], + "source": [ + "from sparknlp.annotator.cleaners import *" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "7c528b73-797c-40fe-a0a9-5e9b1d72f4fd", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "EoFI66NAdalE" + }, + "source": [ + "## Cleaning data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "7a29210a-143a-4fcd-a62f-9b3403f8d3c0", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "BjAsd5Gs8drv" + }, + "source": [ + "Clean a string with bytes to output a string with human visible characters" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "4f27952c-611f-47c7-8d7a-6e9075270eea", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "bAkMjJ1vdalE" + }, + "outputs": [], + "source": [ + "data = \"Hello ð\\\\x9f\\\\x98\\\\x80\"\n", + "data_set = spark.createDataFrame([[data]]).toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "8bd0e20a-aae0-46fe-89e0-b4020b7f618d", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OnxOTj_Uf3a0", + "outputId": "cc841020-4e5e-4b64-e6fc-ed82cee5dce3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+---------------------------------+\n", + "|cleaned |\n", + "+---------------------------------+\n", + "|[{chunk, 0, 8, Hello 😀, {}, []}]|\n", + "+---------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from sparknlp.annotator import *\n", + "from sparknlp.base import *\n", + "\n", + "document_assembler = DocumentAssembler().setInputCol(\"text\").setOutputCol(\"document\")\n", + "\n", + "cleaner = Cleaner() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\") \\\n", + " .setCleanerMode(\"bytes_string_to_string\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"cleaned\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "a729dcd7-b8bf-4356-96e2-199c0576dd5e", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "dpohooB0_yOa" + }, + "source": [ + "Cleaning special characters from a screen" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "0bcd1ac3-8b9e-4b8c-84f6-031753f3e205", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "OC_PElzuAKZw" + }, + "outputs": [], + "source": [ + "data = [\n", + " \"● An excellent point!\",\n", + " \"ITEM 1A: RISK-FACTORS\"\n", + "]\n", + "\n", + "data_set = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "8f78cc6f-95bc-434e-af72-f315c8f531a1", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8ESl4yUL_2WR", + "outputId": "a22fa5dd-09d8-4b40-e84e-adc5cc047696" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----------------------------------------------+\n", + "|cleaned |\n", + "+-----------------------------------------------+\n", + "|[{chunk, 0, 19, An excellent point!, {}, []}] |\n", + "|[{chunk, 0, 21, ITEM 1A: RISK FACTORS, {}, []}]|\n", + "+-----------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "cleaner = Cleaner() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\") \\\n", + " .setCleanerMode(\"clean\") \\\n", + " .setBullets(True) \\\n", + " .setExtraWhitespace(True) \\\n", + " .setDashes(True)\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"cleaned\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "3676aa02-945e-486d-8026-0f56a2ecb0ac", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "Hqm_ttjEAUaH" + }, + "source": [ + "Clean non-ascii characters" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "d502021d-9668-4bb6-9b3a-262c9958aea7", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "WB0bI47xAlIr" + }, + "outputs": [], + "source": [ + "data = [\"\\\\x88This text contains ®non-ascii characters!●\"]\n", + "data_set = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "9ef30555-9c58-492c-af19-94a4062514b2", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YykeYZltAXQX", + "outputId": "edd53be2-df90-4e77-dd18-930fcadfe5d0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------------------+\n", + "|cleaned |\n", + "+------------------------------------------------------------------+\n", + "|[{chunk, 0, 40, This text contains non-ascii characters!, {}, []}]|\n", + "+------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "cleaner = Cleaner() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\") \\\n", + " .setCleanerMode(\"clean_non_ascii_chars\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"cleaned\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "0a0c55c6-6ce7-4673-aac8-81ad8fc341ea", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "YPeqQL-UA17w" + }, + "source": [ + "Cleaning alphanumeric bullets from the beginning of a text" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "f4b6bb1a-31e7-4a54-b887-5ebb44afbee0", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "10_a1O9cA4Tk" + }, + "outputs": [], + "source": [ + "data = [(\"1.1 This is a very important point\",),\n", + " (\"a.1 This is a very important point\",),\n", + " (\"1.4.2 This is a very important point\",)]\n", + "\n", + "data_set = spark.createDataFrame(data).toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "52d71553-6f73-4eb9-9621-3e222ce10490", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JbOmybPLA_nV", + "outputId": "e53a283d-c4c4-471d-b1ef-0df2cf9bc9d1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+--------------------------------------------------------+\n", + "|cleaned |\n", + "+--------------------------------------------------------+\n", + "|[{chunk, 0, 30, This is a very important point, {}, []}]|\n", + "|[{chunk, 0, 30, This is a very important point, {}, []}]|\n", + "|[{chunk, 0, 30, This is a very important point, {}, []}]|\n", + "+--------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "cleaner = Cleaner() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\") \\\n", + " .setCleanerMode(\"clean_ordered_bullets\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"cleaned\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "a297a9ad-c715-4360-b85d-2183a08b6d33", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "EV4Wpr_qBFm1" + }, + "source": [ + "Clean postfix from a text based on a pattern" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "f6647dcf-e29b-48a3-81c3-b135b4e07950", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "UQxqmsFgBTw7" + }, + "outputs": [], + "source": [ + "data = [\"The end! END\"]\n", + "\n", + "data_set = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "0359b9bd-b3d0-4eb3-8d0a-a5c2f72a04c7", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AK_kwa4SBHZL", + "outputId": "a50cef0f-8be6-4139-8dad-52ffc4933322" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+---------------------------------+\n", + "|cleaned |\n", + "+---------------------------------+\n", + "|[{chunk, 0, 8, The end!, {}, []}]|\n", + "+---------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "cleaner = Cleaner() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\") \\\n", + " .setCleanerMode(\"clean_postfix\") \\\n", + " .setCleanPrefixPattern(\"(END|STOP)\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"cleaned\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "ff4acecb-0da2-43c2-a911-def8ddade7da", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "w9bBC9ebBgvi" + }, + "source": [ + "Clean prefix from a text based on a pattern" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "100dd0cd-9430-4c27-aaf6-f0efa79b8328", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "nDfwOWkEBjv4" + }, + "outputs": [], + "source": [ + "data = [\"SUMMARY: This is the best summary of all time!\"]\n", + "\n", + "data_set = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "12358399-be76-4312-9a74-b34752b07dc5", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qaVxWBT-C9eS", + "outputId": "73bb7cb7-36d1-4168-9f3f-adecbb61b615" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+---------------------------------------------------------------+\n", + "|cleaned |\n", + "+---------------------------------------------------------------+\n", + "|[{chunk, 0, 37, This is the best summary of all time!, {}, []}]|\n", + "+---------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "cleaner = Cleaner() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\") \\\n", + " .setCleanerMode(\"clean_prefix\") \\\n", + " .setCleanPrefixPattern(\"(SUMMARY|DESCRIPTION):\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"cleaned\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "a3c0b2fa-e0c1-4b99-ba32-3b736de782a9", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "ZJBz2_ZTGL82" + }, + "source": [ + "Cleaning unicode characters from a text" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "4652c85c-56de-4f2c-8586-905bd792d20c", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "iGZEspw1GR6Q" + }, + "outputs": [], + "source": [ + "data = [\n", + " \"\\x93A lovely quote!\\x94\",\n", + " \"\\x91A lovely quote!\\x92\",\n", + " \"\"\"\\u201CA lovely quote!\\u201D — with a dash\"\"\"\n", + "]\n", + "\n", + "data_set = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "5fa14989-2657-4b52-9b29-e6f6aa340a02", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mm0FrFtBGqBQ", + "outputId": "49697b57-2fa7-4407-93d3-6bb1e7aa2941" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+---------------------------------------------------------+\n", + "|cleaned |\n", + "+---------------------------------------------------------+\n", + "|[{chunk, 0, 17, “A lovely quote!”, {}, []}] |\n", + "|[{chunk, 0, 17, ‘A lovely quote!’, {}, []}] |\n", + "|[{chunk, 0, 31, ?A lovely quote!? ? with a dash, {}, []}]|\n", + "+---------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "cleaner = Cleaner() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\") \\\n", + " .setCleanerMode(\"replace_unicode_characters\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"cleaned\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "0d945d2d-c426-49ce-b755-12f0c497c38e", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "NdV4paKp6fwM" + }, + "source": [ + "### Translator" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "b882f749-fc63-498a-a111-efae9455b12f", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "UGMZ5puuKzcP" + }, + "source": [ + "You can use `Cleaner` annotator to even translate a text " + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "5119cc76-cc42-475c-b8f5-26b5811e0596", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "7GuykSrsK04V" + }, + "outputs": [], + "source": [ + "data = [\"This should go to French\"]\n", + "data_set = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "a1342379-a8a3-4ffc-bc9c-64a3a36d6504", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yX1no37ALAPO", + "outputId": "9b1cf6c0-2640-474a-a933-1428c1ae40c1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "opus_mt_en_fr download started this may take some time.\n", + "Approximate size to download 378.7 MB\n", + "\r", + "[ | ]\r", + "[ / ]\r", + "[ — ]\r", + "[ \\ ]\r", + "[ | ]\r", + "[ / ]\r", + "[ — ]\r", + "[ \\ ]\r", + "[ | ]\r", + "[ / ]\r", + "[ — ]\r", + "[ \\ ]\r", + "[ | ]\r", + "[ / ]\r", + "[ — ]\r", + "[ \\ ]\r", + "[ | ]\r", + "[ / ]\r", + "[ — ]\r", + "[ \\ ]\r", + "[ | ]\r", + "[ / ]\r", + "[ — ]\r", + "[ \\ ]\r", + "[ | ]\r", + "[OK!]\n", + "+-----------------------------------------------------------------------+\n", + "|cleaned |\n", + "+-----------------------------------------------------------------------+\n", + "|[{document, 0, 28, Ça devrait aller en français., {sentence -> 0}, []}]|\n", + "+-----------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "cleaner = Cleaner() \\\n", + " .pretrained() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"cleaned\").show(truncate=False)" + ] + } + ], + "metadata": { + "application/vnd.databricks.v1+notebook": { + "computePreferences": null, + "dashboards": [], + "environmentMetadata": null, + "language": "python", + "notebookMetadata": { + "pythonIndentUnit": 4 + }, + "notebookName": "SparkNLP_Cleaner_Demo", + "widgets": {} + }, + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/data-preprocessing/SparkNLP_Email_Data_Preparation.ipynb b/examples/python/data-preprocessing/SparkNLP_Email_Data_Preparation.ipynb new file mode 100644 index 00000000000000..5f256c363b4bbe --- /dev/null +++ b/examples/python/data-preprocessing/SparkNLP_Email_Data_Preparation.ipynb @@ -0,0 +1,446 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/reader/SparkNLP_Email_Data_Preparation.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tzcU5p2gdak9" + }, + "source": [ + "# Data Preparation with SparkNLP\n", + "This notebook demonstrates how to leverage the new `read()` component in Spark NLP alongside the `Cleaner` or `Extractor` annotators to efficiently preprocess your data before feeding it into an NLP model.\n", + "\n", + "Incorporating this preprocessing step into your pipeline is highly recommended, as it can significantly enhance the quality and performance of your NLP model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RFOFhaEedalB" + }, + "source": [ + "## Setup and Initialization\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "Support for reading email files was introduced in Spark NLP 5.5.2, while `Cleaner` and `Extractor` annotators was introduced in Spark NLP 6.0.0.\n", + "Please make sure you have upgraded to the latest Spark NLP release." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tc9FU1dr7RYd" + }, + "source": [ + "- Let's install and setup Spark NLP in Google Colab\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iR1g7FYu7cjv" + }, + "outputs": [], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TDGhekmq7dtF" + }, + "source": [ + "### Additional Configuration for Databricks" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dtVukFk48DAd" + }, + "source": [ + "When running on Databricks, it is necessary to include the following Spark configurations to avoid dependency conflicts:\n", + "\n", + "- `spark.driver.userClassPathFirst true`\n", + "- `spark.executor.userClassPathFirst true`\n", + "\n", + "These configurations are required because the Databricks runtime environment includes a bundled version of the `com.sun.mail:jakarta.mail` library, which conflicts with `jakarta.activation`. By setting these properties, the application ensures that the user-provided libraries take precedence over those bundled in the Databricks environment, resolving the dependency conflict." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BZS99lKh7T3l" + }, + "source": [ + "For local files example we will download a couple of email files from Spark NLP Github repo:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ya8qZe00dalC", + "outputId": "3d525daf-047e-4fbf-cf9a-cb7f3f4683f1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2025-02-12 20:07:48-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1093-Adding-support-to-read-Email-files/src/test/resources/reader/email/email-text-attachments.eml\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.110.133, 185.199.108.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 3175 (3.1K) [text/plain]\n", + "Saving to: ‘email-files/email-text-attachments.eml’\n", + "\n", + "\r", + " email-tex 0%[ ] 0 --.-KB/s \r", + "email-text-attachme 100%[===================>] 3.10K --.-KB/s in 0s \n", + "\n", + "2025-02-12 20:07:48 (43.7 MB/s) - ‘email-files/email-text-attachments.eml’ saved [3175/3175]\n", + "\n", + "--2025-02-12 20:07:48-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1093-Adding-support-to-read-Email-files/src/test/resources/reader/email/test-several-attachments.eml\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1324361 (1.3M) [text/plain]\n", + "Saving to: ‘email-files/test-several-attachments.eml’\n", + "\n", + "test-several-attach 100%[===================>] 1.26M --.-KB/s in 0.06s \n", + "\n", + "2025-02-12 20:07:49 (19.6 MB/s) - ‘email-files/test-several-attachments.eml’ saved [1324361/1324361]\n", + "\n" + ] + } + ], + "source": [ + "!mkdir email-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1093-Adding-support-to-read-Email-files/src/test/resources/reader/email/email-text-attachments.eml -P email-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1093-Adding-support-to-read-Email-files/src/test/resources/reader/email/test-several-attachments.eml -P email-files" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3xgGItNbU2DZ", + "outputId": "b65902f6-345f-477b-d59f-5853ef61a177" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 1.3M\n", + "-rw-r--r-- 1 root root 3.2K Feb 12 20:07 email-text-attachments.eml\n", + "-rw-r--r-- 1 root root 1.3M Feb 12 20:07 test-several-attachments.eml\n" + ] + } + ], + "source": [ + "!ls -lh ./email-files" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EoFI66NAdalE" + }, + "source": [ + "## Parsing Email from Local Files\n", + "Use the `email()` method to parse email content from local directories." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bAkMjJ1vdalE", + "outputId": "f6eefd3e-da98-4636-d93b-052f0dcfe219" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|email |\n", + "+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|[{Title, Email Text Attachments, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano }}, {NarrativeText, Email test with two text attachments\\r\\n\\r\\nCheers,\\r\\n\\r\\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/plain}}, {NarrativeText, \\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\nEmail  test with two text attachments\\r\\n
\\r\\n
\\r\\n
\\r\\n
\\r\\nCheers,
\\r\\n
\\r\\n
\\r\\n
\\r\\n\\r\\n\\r\\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/html}}, {Attachment, filename.txt, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , contentType -> text/plain; name=\"filename.txt\"}}, {Attachment, filename2.txt, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , contentType -> text/plain; name=\"filename2.txt\"}}] |\n", + "|[{Title, Test Several Attachments, {sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , cc_to -> Danilo Burbano }}, {NarrativeText, This is only a test email with attachments to verify EmailReader feature in Spark NLP.\\r\\n\\r\\nYou don't need to reply to this message 🙂\\r\\n\\r\\n\\r\\n, {sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , mimeType -> text/plain, cc_to -> Danilo Burbano }}, {NarrativeText, \\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n
\\r\\nThis is only a test email with attachments to verify EmailReader feature in Spark NLP.
\\r\\n
\\r\\n
\\r\\n
\\r\\n
\\r\\nYou don't need to reply to this message 🙂 
\\r\\n
\\r\\n
\\r\\n
\\r\\n
\\r\\n
\\r\\n
\\r\\n\\r\\n\\r\\n, {sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , mimeType -> text/html, cc_to -> Danilo Burbano }}, {Attachment, filename.txt, {sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , contentType -> text/plain; name=\"filename.txt\", cc_to -> Danilo Burbano }}, {Attachment, SparkNLP Email Reader.pdf, {sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , contentType -> application/pdf; name=\"SparkNLP Email Reader.pdf\", cc_to -> Danilo Burbano }}, {Attachment, SparkNLP 3D Logo v2.png, {sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , contentType -> image/png; name=\"SparkNLP 3D Logo v2.png\", cc_to -> Danilo Burbano }}]|\n", + "+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "email_df = sparknlp.read().email(\"./email-files\")\n", + "\n", + "email_df.select(\"email\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_5smLr4XmcsY" + }, + "source": [ + "Let's check the schema for this Dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fht7jtiG0A3W", + "outputId": "f4a63156-ddd0-466f-ed0f-6d98627ff925" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- path: string (nullable = true)\n", + " |-- content: binary (nullable = true)\n", + " |-- email: array (nullable = true)\n", + " | |-- element: struct (containsNull = true)\n", + " | | |-- elementType: string (nullable = true)\n", + " | | |-- content: string (nullable = true)\n", + " | | |-- metadata: map (nullable = true)\n", + " | | | |-- key: string\n", + " | | | |-- value: string (valueContainsNull = true)\n", + "\n" + ] + } + ], + "source": [ + "email_df.printSchema()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "06SvFW1Rl285" + }, + "source": [ + "As seen in the schema and output, we have the email information along with metadata that can be used to filter and sanitize the data. Let's take a closer look at the metadata for this email data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xH9UqFE00pDe", + "outputId": "7b6dfe5f-6e4a-4a25-ad6d-69b58e716c2b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|email_exploded |\n", + "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|{sent_to -> Danilo Burbano , sent_from -> Danilo Burbano } |\n", + "|{sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/plain} |\n", + "|{sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/html} |\n", + "|{sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , contentType -> text/plain; name=\"filename.txt\"} |\n", + "|{sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , contentType -> text/plain; name=\"filename2.txt\"} |\n", + "|{sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , cc_to -> Danilo Burbano } |\n", + "|{sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , mimeType -> text/plain, cc_to -> Danilo Burbano } |\n", + "|{sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , mimeType -> text/html, cc_to -> Danilo Burbano } |\n", + "|{sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , contentType -> text/plain; name=\"filename.txt\", cc_to -> Danilo Burbano } |\n", + "|{sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , contentType -> application/pdf; name=\"SparkNLP Email Reader.pdf\", cc_to -> Danilo Burbano }|\n", + "|{sent_to -> Maziyar Panahi , sent_from -> Danilo Burbano , contentType -> image/png; name=\"SparkNLP 3D Logo v2.png\", cc_to -> Danilo Burbano } |\n", + "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from pyspark.sql.functions import col, explode\n", + "\n", + "email_matadata_df = email_df.withColumn(\"email_metadata\", explode(col(\"email.metadata\")))\n", + "email_matadata_df.select(\"email_metadata\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6YeiszZSnMZU" + }, + "source": [ + "In this example, we are not interested in results containing HTML data, so we will focus only on plain text." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aQqqlUIEXMhF", + "outputId": "ab47ae69-1c00-4fe4-d5cc-abd762c65d1e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|path |narrative_text |\n", + "+------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|file:/content/email-files/email-text-attachments.eml |Email test with two text attachments\\r\\n\\r\\nCheers,\\r\\n\\r\\n |\n", + "|file:/content/email-files/test-several-attachments.eml|This is only a test email with attachments to verify EmailReader feature in Spark NLP.\\r\\n\\r\\nYou don't need to reply to this message 🙂\\r\\n\\r\\n\\r\\n|\n", + "+------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from pyspark.sql.functions import col, explode\n", + "\n", + "#Filter out only NarrativeText elements and text/plain content from the email array\n", + "narrative_email_df = email_df.selectExpr(\n", + " \"path\",\n", + " \"FILTER(email, x -> x.elementType = 'NarrativeText' AND x.metadata['mimeType'] = 'text/plain') AS narrative_email\"\n", + ")\n", + "\n", + "exploded_df = narrative_email_df.withColumn(\"email_exploded\", explode(col(\"narrative_email\")))\n", + "\n", + "#Select only the content field from the exploded struct\n", + "email_content_df = exploded_df.select(\n", + " \"path\",\n", + " col(\"email_exploded.content\").alias(\"narrative_text\")\n", + ")\n", + "\n", + "email_content_df.show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Fno3A-itndVO" + }, + "source": [ + "Now, we can use `Cleaner` annotator to remove any remaining undesired characters from the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yzLMr8jvT4w4", + "outputId": "9774f95b-b2e3-48db-947c-30318f3e78bf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|cleaned |\n", + "+------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|[{chunk, 0, 44, Email test with two text attachments Cheers,, {}, []}] |\n", + "|[{chunk, 0, 129, This is only a test email with attachments to verify EmailReader feature in Spark NLP. You don't need to reply to this message 🙂, {}, []}]|\n", + "+------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from sparknlp.base import *\n", + "from sparknlp.annotator.cleaners import *\n", + "\n", + "document_assembler = DocumentAssembler() \\\n", + " .setInputCol(\"narrative_text\") \\\n", + " .setOutputCol(\"document\")\n", + "\n", + "cleaner = Cleaner() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"cleaned\") \\\n", + " .setCleanerMode(\"clean\") \\\n", + " .setBullets(True) \\\n", + " .setExtraWhitespace(True) \\\n", + " .setDashes(True)\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " cleaner\n", + "])\n", + "\n", + "model = pipeline.fit(email_content_df)\n", + "clean_email_content_df = model.transform(email_content_df)\n", + "clean_email_content_df.select(\"cleaned\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Qtttw-LbC9I5" + }, + "source": [ + "Now, you have your enhanced text ready to feed into an NLP model for improved performance." + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/data-preprocessing/SparkNLP_Extractor_Demo.ipynb b/examples/python/data-preprocessing/SparkNLP_Extractor_Demo.ipynb new file mode 100644 index 00000000000000..58fd23df94a0ff --- /dev/null +++ b/examples/python/data-preprocessing/SparkNLP_Extractor_Demo.ipynb @@ -0,0 +1,1387 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/reader/SparkNLP_Extractor_Demo.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "0d4a5cfc-53fe-4996-a290-4dedb2ffdbf8", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "tzcU5p2gdak9" + }, + "source": [ + "# Introducing Extractor in SparkNLP\n", + "This notebook showcases the newly added `Extractor()` annotator in Spark NLP enabling seamless extraction of key information (e.g., dates, emails, IP addresses) from various data sources such as `.eml` files. This simplifies data parsing workflows by isolating relevant details automatically." + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "53dbab4c-5f20-4dc0-aaeb-5a6f7289768e", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DczWop6QeE8F", + "outputId": "3634f091-1da2-4013-bbe8-4abdcef6d0c5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "Apache Spark version: 3.4.1\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "# let's start Spark with Spark NLP\n", + "spark = sparknlp.start()\n", + "print(\"Apache Spark version: {}\".format(spark.version))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "593ff948-8109-4ea8-a21a-d1ee153150bf", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "RFOFhaEedalB" + }, + "source": [ + "## Setup and Initialization\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "Support for reading html files was introduced in Spark NLP 6.0.0. Please make sure you have upgraded to the latest Spark NLP release.\n", + "We simple need to import the cleaners components to use `Extractor` annotator:" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "4d27fe1e-e91e-4388-be7d-c6fc7229e8c5", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "stirVdLP-ASE" + }, + "outputs": [], + "source": [ + "from sparknlp.annotator.cleaners import *" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "71ca7bde-fb68-4ea0-855f-6931400b096f", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "EoFI66NAdalE" + }, + "source": [ + "## Extracting data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "49b2c5d2-991b-4e01-a639-7de15f5f1148", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "BjAsd5Gs8drv" + }, + "source": [ + "Extracting information from eml data" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "911c7225-8760-4e98-9878-7782ecf9d972", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "bAkMjJ1vdalE" + }, + "outputs": [], + "source": [ + "eml_data = \"\"\"from ABC.DEF.local ([ba23::58b5:2236:45g2:88h2]) by\n", + " \\n ABC.DEF.local2 ([ba23::58b5:2236:45g2:88h2%25]) with mapi id\\\n", + " n 32.88.5467.123; Fri, 26 Mar 2021 11:04:09 +1200\"\"\"\n", + "\n", + "data_set = spark.createDataFrame([[eml_data]]).toDF(\"text\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "eef12f80-6a1d-46aa-80d4-1e7c83308af6", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "DZ3tHeJM_wnD" + }, + "source": [ + "Extracting date" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "a56f1f7b-1aa4-431a-924b-fc2c94a0066c", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OnxOTj_Uf3a0", + "outputId": "bfb8bcaa-b9ca-43c7-d8bf-ca1a80808b4e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------------+\n", + "|date |\n", + "+------------------------------------------------------------+\n", + "|[{chunk, 136, 166, Fri, 26 Mar 2021 11:04:09 +1200, {}, []}]|\n", + "+------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from sparknlp.annotator import *\n", + "from sparknlp.base import *\n", + "\n", + "document_assembler = DocumentAssembler().setInputCol(\"text\").setOutputCol(\"document\")\n", + "\n", + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"date\") \\\n", + " .setExtractorMode(\"email_date\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"date\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "59beb7a2-243f-4888-a610-c785358ab739", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "dpohooB0_yOa" + }, + "source": [ + "Extracting email addresses" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "8c1ac427-2fe9-417b-a811-ee939c6f1c9b", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "OC_PElzuAKZw" + }, + "outputs": [], + "source": [ + "eml_data = [\n", + " \"Me me@email.com and You \\n ([ba23::58b5:2236:45g2:88h2]) (10.0.2.01)\",\n", + " \"Im Rabn \"\n", + "]\n", + "\n", + "data_set = spark.createDataFrame(eml_data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "9a96a56b-3b96-41a9-a090-278ab22fb2ac", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8ESl4yUL_2WR", + "outputId": "e40cf1f5-df1b-45b3-c663-ce5fc5d789a7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------------------------------+\n", + "|email |\n", + "+------------------------------------------------------------------------------+\n", + "|[{chunk, 3, 14, me@email.com, {}, []}, {chunk, 25, 37, You@email.com, {}, []}]|\n", + "|[{chunk, 9, 26, Im.Rabn@npf.gov.nr, {}, []}] |\n", + "+------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"email\") \\\n", + " .setExtractorMode(\"email_address\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"email\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "74edbb08-3fe5-47d8-9884-c22b1bd1dec3", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "Hqm_ttjEAUaH" + }, + "source": [ + "Extracting IPv4 and IPv6 addresses" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "a33d7eaf-d87d-47f9-832d-4ff6aa967210", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "WB0bI47xAlIr" + }, + "outputs": [], + "source": [ + "eml_data = [\n", + " \"\"\"from ABC.DEF.local ([ba23::58b5:2236:45g2:88h2]) by\n", + " ABC.DEF.local ([68.183.71.12]) with mapi id\n", + " 32.88.5467.123; Fri, 26 Mar 2021 11:04:09 +1200\"\"\"\n", + "]\n", + "\n", + "data_set = spark.createDataFrame(eml_data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "36cf18e8-7395-41be-a08e-d37495842685", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YykeYZltAXQX", + "outputId": "f250f242-098c-4766-e2d7-dfb6bfff08de" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------------------------------------------------------------------------------+\n", + "|ip_address |\n", + "+-------------------------------------------------------------------------------------------+\n", + "|[{chunk, 21, 45, ba23::58b5:2236:45g2:88h2, {}, []}, {chunk, 72, 83, 68.183.71.12, {}, []}]|\n", + "+-------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"ip_address\") \\\n", + " .setExtractorMode(\"ip_address\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"ip_address\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "dae9271c-5d0f-45da-a2b9-35c7b60db5e0", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "YPeqQL-UA17w" + }, + "source": [ + "Extracting MAPI IDs" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "e8463ec7-46d4-4e2d-8cbd-7ff9ba3bb207", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "10_a1O9cA4Tk" + }, + "outputs": [], + "source": [ + "eml_data = \"\"\"from ABC.DEF.local ([ba23::58b5:2236:45g2:88h2]) by\n", + " \\n ABC.DEF.local2 ([ba23::58b5:2236:45g2:88h2%25]) with mapi id\\\n", + " n 32.88.5467.123; Fri, 26 Mar 2021 11:04:09 +1200\"\"\"\n", + "\n", + "data_set = spark.createDataFrame([[eml_data]]).toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "f34e1e39-b8ac-45fe-931a-71de97e6c178", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JbOmybPLA_nV", + "outputId": "bf150f95-88d5-42db-8038-b4a44920cfd5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------------------------------+\n", + "|mapi_id |\n", + "+-------------------------------------------+\n", + "|[{chunk, 120, 133, 32.88.5467.123, {}, []}]|\n", + "+-------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"mapi_id\") \\\n", + " .setExtractorMode(\"mapi_id\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"mapi_id\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "2c492045-9883-48a9-a452-cf646b55d4bd", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "EV4Wpr_qBFm1" + }, + "source": [ + "Extracting US phone number" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "42356372-2e35-455b-8f88-a7c6f9320584", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "UQxqmsFgBTw7" + }, + "outputs": [], + "source": [ + "data = [\n", + " \"215-867-5309\",\n", + " \"Phone Number: +1 215.867.5309\",\n", + " \"Phone Number: Just Kidding\"\n", + "]\n", + "\n", + "test_df = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "4570b13f-7195-4720-8f22-e1da4de3e140", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AK_kwa4SBHZL", + "outputId": "ae506a88-6010-40d0-b580-2d73d171e498" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------+\n", + "|us_phones |\n", + "+------------------------------------------+\n", + "|[{chunk, 0, 11, 215-867-5309, {}, []}] |\n", + "|[{chunk, 14, 28, +1 215.867.5309, {}, []}]|\n", + "|[] |\n", + "+------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"us_phones\") \\\n", + " .setExtractorMode(\"us_phone_numbers\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(test_df)\n", + "result = model.transform(test_df)\n", + "result.select(\"us_phones\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "6bc9dcf3-70b3-4054-999b-37aea18af833", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "w9bBC9ebBgvi" + }, + "source": [ + "Extracting bullets from text" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "7fcdcbe1-bec5-49db-b94a-168ef0f9107b", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "nDfwOWkEBjv4" + }, + "outputs": [], + "source": [ + "data = [\n", + " \"1. Introduction:\",\n", + " \"a. Introduction:\",\n", + " \"5.3.1 Convolutional Networks\",\n", + " \"D.b.C Recurrent Neural Networks\",\n", + " \"2.b.1 Recurrent Neural Networks\",\n", + " \"bb.c Feed Forward Neural Networks\",\n", + " \"Fig. 2: The relationship\"\n", + "]\n", + "\n", + "test_df = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "ebf27f07-e422-4f1d-8c3f-579271096a9e", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qaVxWBT-C9eS", + "outputId": "86c71467-9b54-4acd-985b-af90e6cc075d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------------------------------------+\n", + "|bullets |\n", + "+------------------------------------------------------------------------------------+\n", + "|[{chunk, 0, 2, (1,None,None), {section -> 1}, []}] |\n", + "|[{chunk, 0, 2, (a,None,None), {section -> a}, []}] |\n", + "|[{chunk, 0, 5, (5,3,1), {section -> 5, sub_section -> 3, sub_sub_section -> 1}, []}]|\n", + "|[{chunk, 0, 5, (D,b,C), {section -> D, sub_section -> b, sub_sub_section -> C}, []}]|\n", + "|[{chunk, 0, 5, (2,b,1), {section -> 2, sub_section -> b, sub_sub_section -> 1}, []}]|\n", + "|[{chunk, 0, 4, (bb,c,None), {section -> bb, sub_section -> c}, []}] |\n", + "|[{chunk, 0, 0, (None,None,None), {}, []}] |\n", + "+------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"bullets\") \\\n", + " .setExtractorMode(\"bullets\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(test_df)\n", + "result = model.transform(test_df)\n", + "result.select(\"bullets\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "db36280f-40f6-4d4b-808d-545d2d88f6a6", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "ZJBz2_ZTGL82" + }, + "source": [ + "Extract image from URLS" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "76860b07-7b87-4396-b886-12e0ce4d646e", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "iGZEspw1GR6Q" + }, + "outputs": [], + "source": [ + "data = [\n", + " \"https://my-image.png with some text\",\n", + " \"some text https://my-image.jpg with another http://my-image.bmp\",\n", + " \"http://my-path/my%20image.JPG\",\n", + " \"\"\"\n", + " \n", + " \"\"\"\n", + "]\n", + "\n", + "test_df = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "48bc7615-869b-4e65-81a3-e5d7efd58371", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mm0FrFtBGqBQ", + "outputId": "4e206112-afe6-4bc1-fd4f-538b3373fb90" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------------------------------------------------------------------------------------------------------------------+\n", + "|image_urls |\n", + "+-------------------------------------------------------------------------------------------------------------------------------+\n", + "|[{chunk, 0, 19, https://my-image.png, {}, []}] |\n", + "|[{chunk, 10, 29, https://my-image.jpg, {}, []}, {chunk, 44, 62, http://my-image.bmp, {}, []}] |\n", + "|[{chunk, 0, 28, http://my-path/my%20image.JPG, {}, []}] |\n", + "|[{chunk, 10, 46, https://example.com/images/photo1.jpg, {}, []}, {chunk, 66, 100, https://example.org/assets/icon.png, {}, []}]|\n", + "+-------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"image_urls\") \\\n", + " .setExtractorMode(\"image_urls\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(test_df)\n", + "result = model.transform(test_df)\n", + "result.select(\"image_urls\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "57717be0-06be-451c-bdde-ca67cad1fab5", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "UGMZ5puuKzcP" + }, + "source": [ + "Extract text after" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "3de7cf0f-0897-4aae-812f-3808a585b2c4", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "7GuykSrsK04V" + }, + "outputs": [], + "source": [ + "data = [\"SPEAKER 1: Look at me, I'm flying!\"]\n", + "\n", + "test_df = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "b3fcf79f-c9e1-429c-8f63-60b2d0553dcd", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yX1no37ALAPO", + "outputId": "4b6e9f5f-1b0d-4eac-ac07-b794db799565" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------------+\n", + "|text_after |\n", + "+------------------------------------------------------------+\n", + "|[{chunk, 10, 34, Look at me, I'm flying!, {index -> 0}, []}]|\n", + "+------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"text_after\") \\\n", + " .setExtractorMode(\"text_after\") \\\n", + " .setTextPattern(\"SPEAKER \\\\d{1}:\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(test_df)\n", + "result = model.transform(test_df)\n", + "result.select(\"text_after\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "b0045ce9-8a27-4f50-95eb-054f5579ed91", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "ogDxF5DlLJvT" + }, + "source": [ + "Extract text before" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "1cc76379-f6a2-4c07-b2ec-86a551395d0d", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "zPiLiuh1LLC8" + }, + "outputs": [], + "source": [ + "data = [\"Here I am! STOP Look at me! STOP I'm flying! STOP\"]\n", + "\n", + "test_df = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "d989d7c7-1891-420d-9b96-f34541b5f50e", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jBBRy0hZLPz2", + "outputId": "cef60d80-3985-427a-c4b3-ebb7e54eb9bd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+----------------------------------------------+\n", + "|text_before |\n", + "+----------------------------------------------+\n", + "|[{chunk, 0, 11, Here I am!, {index -> 0}, []}]|\n", + "+----------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"text_before\") \\\n", + " .setExtractorMode(\"text_before\") \\\n", + " .setTextPattern(\"STOP\")\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(test_df)\n", + "result = model.transform(test_df)\n", + "result.select(\"text_before\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "764fa826-06c1-4309-a5b1-e279d6a5e0a2", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "SNzyE7rmLgL4" + }, + "source": [ + "## Custom Patterns" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "1d15170a-3cba-48c2-9728-f03ea388ec60", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "OxSYMMORLrsz" + }, + "source": [ + "As you can see in the output of the example above. We have by default patterns to extract most common data. However, you can also set custom regex patterns to address your specific extraction needs." + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "faecf90c-552f-42c8-b1aa-3e50da7e7b6c", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "Be0VrtdjLmAa" + }, + "outputs": [], + "source": [ + "eml_data = [\n", + " \"\"\"from ABC.DEF.local ([ba23::58b5:2236:45g2:88h2]) by\n", + " ABC.DEF.local ([68.183.71.12]) with mapi id\n", + " 32.88.5467.123; Fri, 26 Mar 2021 11:04:09 +1200\"\"\"\n", + "]\n", + "\n", + "data_set = spark.createDataFrame(eml_data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "0aa79ac9-c404-4901-a792-b5cb5ff33659", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_6Gi_PuvMU5x", + "outputId": "0318a824-cde1-4404-d2bf-d9859a6a4eb6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+---------------------------------------+\n", + "|ipv4_address |\n", + "+---------------------------------------+\n", + "|[{chunk, 72, 83, 68.183.71.12, {}, []}]|\n", + "+---------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "my_ipv4_regex = \"(?:25[0-5]|2[0-4]\\\\d|1\\\\d{2}|[1-9]?\\\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\\\d|1\\\\d{2}|[1-9]?\\\\d)){3}\"\n", + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"ipv4_address\") \\\n", + " .setExtractorMode(\"ip_address\") \\\n", + " .setIpAddressPattern(my_ipv4_regex)\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(data_set)\n", + "result = model.transform(data_set)\n", + "result.select(\"ipv4_address\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "ada7ab5b-5773-49cf-bac4-c86668e62343", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "H05hbWuQOuTA" + }, + "source": [ + "Index in After and Before text" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "f83245f5-4070-4a67-8aaf-11571c1e7ead", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "ihzYu3qhfrQ9" + }, + "source": [ + "The `index` parameter tells the `Extractor` which occurrence of the specified `text pattern` should be used as the reference point for extracting text. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "bacb0658-0658-49b6-9811-96d593af27e1", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "815xRlXsOwfP" + }, + "outputs": [], + "source": [ + "data = [\"Teacher: BLAH BLAH BLAH; Student: BLAH BLAH BLAH!\"]\n", + "\n", + "test_df = spark.createDataFrame(data, \"string\").toDF(\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "a8fb680b-5ff6-47cb-a0fa-dd0a473e10b4", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Rd0_m1D8O_BY", + "outputId": "d6295c30-6e96-4c8c-cd5e-1df5d53238a5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------------------------------------+\n", + "|text_before |\n", + "+-------------------------------------------------+\n", + "|[{chunk, 0, 14, Teacher: BLAH, {index -> 1}, []}]|\n", + "+-------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"text_before\") \\\n", + " .setExtractorMode(\"text_before\") \\\n", + " .setTextPattern(\"BLAH\") \\\n", + " .setIndex(1)\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(test_df)\n", + "result = model.transform(test_df)\n", + "result.select(\"text_before\").show(truncate=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "c489beb3-caaf-44f4-8f66-736ae50fb95e", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IIwNAetLYUYN", + "outputId": "6eb8da1e-c0b8-4966-d621-34570d7949b3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------------------------------+\n", + "|text_before |\n", + "+-------------------------------------------+\n", + "|[{chunk, 0, 9, Teacher:, {index -> 0}, []}]|\n", + "+-------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "extractor = Extractor() \\\n", + " .setInputCols([\"document\"]) \\\n", + " .setOutputCol(\"text_before\") \\\n", + " .setExtractorMode(\"text_before\") \\\n", + " .setTextPattern(\"BLAH\") \\\n", + "\n", + "pipeline = Pipeline().setStages([\n", + " document_assembler,\n", + " extractor\n", + "])\n", + "\n", + "model = pipeline.fit(test_df)\n", + "result = model.transform(test_df)\n", + "result.select(\"text_before\").show(truncate=False)" + ] + } + ], + "metadata": { + "application/vnd.databricks.v1+notebook": { + "computePreferences": null, + "dashboards": [], + "environmentMetadata": null, + "language": "python", + "notebookMetadata": { + "pythonIndentUnit": 4 + }, + "notebookName": "SparkNLP_Extractor_Demo", + "widgets": {} + }, + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb b/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb index d4152e51194c25..8d00e9d3b1a291 100644 --- a/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb +++ b/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb @@ -264,8 +264,7 @@ "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" + "pygments_lexer": "ipython3" } }, "nbformat": 4, diff --git a/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFModel.ipynb b/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFModel.ipynb index 3a76bdf5f01ece..09be6b85ee1083 100644 --- a/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFModel.ipynb +++ b/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFModel.ipynb @@ -31,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -320,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -335,7 +335,6 @@ "source": [ "from sparknlp.annotator import *\n", "\n", - "# All these params should be identical to the original ONNX model\n", "autoGGUFModel = (\n", " AutoGGUFModel.loadSavedModel(EXPORT_PATH, spark)\n", " .setInputCols(\"document\")\n", @@ -355,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -389,7 +388,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -415,7 +414,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -619,8 +618,7 @@ "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" + "pygments_lexer": "ipython3" } }, "nbformat": 4, diff --git a/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb b/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb new file mode 100644 index 00000000000000..a33d9c351ba094 --- /dev/null +++ b/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb @@ -0,0 +1,805 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb)\n", + "\n", + "# Import llama.cpp 🦙 vision models into Spark NLP 🚀\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- Multimodal inference with llama.cpp was introduced in `Spark NLP 5.6.0`, enabling quantized LLM inference on a wide range of devices. Please make sure you have upgraded to the latest Spark NLP release.\n", + "- You need to use your own `.gguf` model files, which also include the models from the [Hugging Face Models](https://huggingface.co/models?library=gguf).", + "- At the moment only CLIP based models are supported." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download a GGUF Vision Model\n", + "\n", + "Let's download a GGUF vision model to test it out. For this, we will use [Mozilla/llava-v1.5-7b](https://huggingface.co/Mozilla/llava-v1.5-7b-llamafile/tree/main). It is a 7B parameter model which also is available in 4-bit quantization.\n", + "\n", + "We can download the model and its multimodal projection (mmproj) file by selecting the q4 GGUF file from the \"Files and versions\" tab.\n", + "\n", + "Once downloaded, we can directly import this model into Spark NLP!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "EXPORT_PATH_MODEL = \"llava-v1.5-7b-Q4_K.gguf\"\n", + "EXPORT_PATH_MMPROJ = \"llava-v1.5-7b-mmproj-Q4_0.gguf\"\n", + "! wget \"https://huggingface.co/Mozilla/llava-v1.5-7b-llamafile/resolve/main/{EXPORT_PATH_MODEL}?download=true\" -O {EXPORT_PATH_MODEL}\n", + "! wget \"https://huggingface.co/Mozilla/llava-v1.5-7b-llamafile/resolve/main/{EXPORT_PATH_MMPROJ}?download=true\" -O {EXPORT_PATH_MMPROJ}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import and Save AutGGUFVision models in Spark NLP\n", + "\n", + "- Let's install and setup Spark NLP (if running it Google Colab)\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Only execute this if you are on Google Colab\n", + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start Spark with Spark NLP included via our simple `start()` function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import sparknlp\n", + "\n", + "# let's start Spark with Spark NLP with GPU enabled. If you don't have GPUs available remove this parameter.\n", + "spark = sparknlp.start(gpu=True)\n", + "print(sparknlp.version())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Let's use the `loadSavedModel` function in `AutoGGUFVisionModel`\n", + "- Most parameters will be set automatically. They can also be set later after loading the model in `AutoGGUFVisionModel` during runtime, so don't worry about setting them now.\n", + "- `loadSavedModel` accepts three parameters: \n", + " 1. the path to the exported gguf model\n", + " 1. the path to the exported mmproj gguf model\n", + " 2. the SparkSession that is `spark` variable we previously started via `sparknlp.start()`\n", + "- NOTE: `loadSavedModel` accepts local paths in addition to distributed file systems such as `HDFS`, `S3`, `DBFS`, etc. This feature was introduced in Spark NLP 4.2.2 release. Keep in mind the best and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sparknlp.annotator import *\n", + "\n", + "autoGGUFModel = (\n", + " AutoGGUFVisionModel.loadSavedModel(EXPORT_PATH_MODEL, EXPORT_PATH_MMPROJ, spark)\n", + " .setInputCols([\"caption_document\", \"image_assembler\"])\n", + " .setOutputCol(\"completions\")\n", + " .setChatTemplate(\"vicuna\")\n", + " .setBatchSize(4)\n", + " .setNGpuLayers(99)\n", + " .setNCtx(4096)\n", + " .setMinKeep(0)\n", + " .setMinP(0.05)\n", + " .setNPredict(40)\n", + " .setNProbs(0)\n", + " .setPenalizeNl(False)\n", + " .setRepeatLastN(256)\n", + " .setRepeatPenalty(1.18)\n", + " .setStopStrings([\"\", \"Llama:\", \"User:\"])\n", + " .setTemperature(0.05)\n", + " .setTfsZ(1)\n", + " .setTypicalP(1)\n", + " .setTopK(40)\n", + " .setTopP(0.95)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Let's save it on disk so it is easier to be moved around and also be used later via `.load` function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "autoGGUFModel.write().overwrite().save(f\"llava_v1.5_7b_Q4_0_gguf_spark_nlp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Awesome 😎 !\n", + "\n", + "This is your GGUF model from loaded and saved by Spark NLP 🚀. You can now use it on other machines, clusters, or any place you wish to use your new and shiny GGUF model 😊" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "llava-v1.5-7b-mmproj-Q4_0.gguf\tllava-v1.5-7b-Q4_K.gguf metadata\n" + ] + } + ], + "source": [ + "! ls llava_v1.5_7b_Q4_0_gguf_spark_nlp" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example: Captioning Images\n", + "\n", + "Now let's see how we can use the model to caption some images. Let's first download some images we can caption." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "!wget -q https://s3.amazonaws.com/auxdata.johnsnowlabs.com/public/resources/en/images/images.zip\n", + "import shutil\n", + "shutil.unpack_archive(\"images.zip\", \"images\", \"zip\")\n", + "\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "\n", + "_, axes = plt.subplots(2, 5, figsize=(10,5))\n", + "axes = axes.flatten()\n", + "\n", + "i = 0\n", + "images_path = \"images/images/\"\n", + "for file_name in os.listdir(images_path):\n", + " if file_name.lower().endswith((\".png\", \".jpg\", \".jpeg\", \".gif\")):\n", + " file_path = os.path.join(\"images/images/\", file_name)\n", + " ax = axes[i]\n", + " ax.imshow(Image.open(file_path).convert(\"RGB\"))\n", + " ax.title.set_text(file_name)\n", + " ax.axis(\"off\")\n", + " i += 1\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can load the images to Spark.\n", + "\n", + "**NOTE**: The llama.cpp backend of the annotator expects a different image byte format than the default format used by Spark. This annotator expects *raw* image bytes, instead of the OpenCV image compatible format, which is used by default.\n", + "\n", + "For this, we can use the helper function `loadImagesAsBytes` from the `ImageAssembler`. It will load the images in the right format in a Spark DataFrame. Additionally, we will add a column for the caption:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sparknlp.base import *\n", + "from pyspark.sql.functions import lit\n", + "\n", + "data = ImageAssembler.loadImagesAsBytes(spark, images_path)\n", + "# Add a caption to each image.\n", + "data = data.withColumn(\"caption\", lit(\"Caption this image.\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now We need an `ImageAssembler` and `DocumentAssembler` to turn the images and captions into the right format for Spark NLP. We also load the model we just saved above. Then we can assemble a pipeline and run it!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/18 13:46:33 WARN DAGScheduler: Broadcasting large task binary with size 1090.9 KiB\n", + "clip_model_load: model name: openai/clip-vit-large-patch14-336 (0 + 1) / 1]\n", + "clip_model_load: description: image encoder for LLaVA\n", + "clip_model_load: GGUF version: 3\n", + "clip_model_load: alignment: 32\n", + "clip_model_load: n_tensors: 377\n", + "clip_model_load: n_kv: 19\n", + "clip_model_load: ftype: q4_0\n", + "\n", + "clip_model_load: loaded meta data with 19 key-value pairs and 377 tensors from /tmp/spark-5acddb2b-4bca-474e-befd-d8613d27a78e/userFiles-4926735e-f265-46bc-8a9f-9edb6a65484e/llava-v1.5-7b-mmproj-Q4_0.gguf\n", + "clip_model_load: Dumping metadata keys/values. Note: KV overrides do not apply in this output.\n", + "clip_model_load: - kv 0: general.architecture str = clip\n", + "clip_model_load: - kv 1: clip.has_text_encoder bool = false\n", + "clip_model_load: - kv 2: clip.has_vision_encoder bool = true\n", + "clip_model_load: - kv 3: clip.has_llava_projector bool = true\n", + "clip_model_load: - kv 4: general.file_type u32 = 2\n", + "clip_model_load: - kv 5: general.name str = openai/clip-vit-large-patch14-336\n", + "clip_model_load: - kv 6: general.description str = image encoder for LLaVA\n", + "clip_model_load: - kv 7: clip.vision.image_size u32 = 336\n", + "clip_model_load: - kv 8: clip.vision.patch_size u32 = 14\n", + "clip_model_load: - kv 9: clip.vision.embedding_length u32 = 1024\n", + "clip_model_load: - kv 10: clip.vision.feed_forward_length u32 = 4096\n", + "clip_model_load: - kv 11: clip.vision.projection_dim u32 = 768\n", + "clip_model_load: - kv 12: clip.vision.attention.head_count u32 = 16\n", + "clip_model_load: - kv 13: clip.vision.attention.layer_norm_epsilon f32 = 0.000010\n", + "clip_model_load: - kv 14: clip.vision.block_count u32 = 23\n", + "clip_model_load: - kv 15: clip.vision.image_mean arr[f32,3] = [0.481455, 0.457828, 0.408211]\n", + "clip_model_load: - kv 16: clip.vision.image_std arr[f32,3] = [0.268630, 0.261303, 0.275777]\n", + "clip_model_load: - kv 17: clip.use_gelu bool = false\n", + "clip_model_load: - kv 18: general.quantization_version u32 = 2\n", + "clip_model_load: - type f32: 235 tensors\n", + "clip_model_load: - type f16: 1 tensors\n", + "clip_model_load: - type q4_0: 141 tensors\n", + "ggml_cuda_init: GGML_CUDA_FORCE_MMQ: no\n", + "ggml_cuda_init: GGML_CUDA_FORCE_CUBLAS: no\n", + "ggml_cuda_init: found 1 CUDA devices:\n", + " Device 0: NVIDIA GeForce RTX 3070, compute capability 8.6, VMM: yes\n", + "clip_model_load: CLIP using CUDA backend\n", + "clip_model_load: text_encoder: 0\n", + "clip_model_load: vision_encoder: 1\n", + "clip_model_load: llava_projector: 1\n", + "clip_model_load: model size: 169.18 MB\n", + "clip_model_load: metadata size: 0.13 MB\n", + "clip_model_load: params backend buffer size = 169.18 MB (377 tensors)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] build info build=3534 commit=\"641f5dd2\"\n", + "[INFO] system info n_threads=6 n_threads_batch=-1 total_threads=6 system_info=\"AVX = 1 | AVX_VNNI = 0 | AVX2 = 1 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | AVX512_BF16 = 0 | FMA = 1 | NEON = 0 | SVE = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 1 | SSSE3 = 1 | VSX = 0 | MATMUL_INT8 = 0 | LLAMAFILE = 1 | \"\n", + "[INFO] Multi Modal Mode Enabled\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "key clip.vision.image_grid_pinpoints not found in file\n", + "key clip.vision.mm_patch_merge_type not found in file\n", + "key clip.vision.image_crop_resolution not found in file\n", + "ggml_gallocr_reserve_n: reallocating CUDA0 buffer from size 0.00 MiB to 32.89 MiB\n", + "clip_model_load: compute allocated memory: 32.89 MB\n", + "llama_model_loader: loaded meta data with 19 key-value pairs and 291 tensors from /tmp/spark-5acddb2b-4bca-474e-befd-d8613d27a78e/userFiles-4926735e-f265-46bc-8a9f-9edb6a65484e/llava-v1.5-7b-Q4_K.gguf (version GGUF V3 (latest))\n", + "llama_model_loader: Dumping metadata keys/values. Note: KV overrides do not apply in this output.\n", + "llama_model_loader: - kv 0: general.architecture str = llama\n", + "llama_model_loader: - kv 1: general.name str = LLaMA v2\n", + "llama_model_loader: - kv 2: llama.context_length u32 = 4096\n", + "llama_model_loader: - kv 3: llama.embedding_length u32 = 4096\n", + "llama_model_loader: - kv 4: llama.block_count u32 = 32\n", + "llama_model_loader: - kv 5: llama.feed_forward_length u32 = 11008\n", + "llama_model_loader: - kv 6: llama.rope.dimension_count u32 = 128\n", + "llama_model_loader: - kv 7: llama.attention.head_count u32 = 32\n", + "llama_model_loader: - kv 8: llama.attention.head_count_kv u32 = 32\n", + "llama_model_loader: - kv 9: llama.attention.layer_norm_rms_epsilon f32 = 0.000010\n", + "llama_model_loader: - kv 10: general.file_type u32 = 15\n", + "llama_model_loader: - kv 11: tokenizer.ggml.model str = llama\n", + "llama_model_loader: - kv 12: tokenizer.ggml.tokens arr[str,32000] = [\"\", \"\", \"\", \"<0x00>\", \"<...\n", + "llama_model_loader: - kv 13: tokenizer.ggml.scores arr[f32,32000] = [0.000000, 0.000000, 0.000000, 0.0000...\n", + "llama_model_loader: - kv 14: tokenizer.ggml.token_type arr[i32,32000] = [2, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, ...\n", + "llama_model_loader: - kv 15: tokenizer.ggml.bos_token_id u32 = 1\n", + "llama_model_loader: - kv 16: tokenizer.ggml.eos_token_id u32 = 2\n", + "llama_model_loader: - kv 17: tokenizer.ggml.padding_token_id u32 = 0\n", + "llama_model_loader: - kv 18: general.quantization_version u32 = 2\n", + "llama_model_loader: - type f32: 65 tensors\n", + "llama_model_loader: - type q4_K: 193 tensors\n", + "llama_model_loader: - type q6_K: 33 tensors\n", + "llm_load_vocab: special tokens cache size = 3\n", + "llm_load_vocab: token to piece cache size = 0.1684 MB\n", + "llm_load_print_meta: format = GGUF V3 (latest)\n", + "llm_load_print_meta: arch = llama\n", + "llm_load_print_meta: vocab type = SPM\n", + "llm_load_print_meta: n_vocab = 32000\n", + "llm_load_print_meta: n_merges = 0\n", + "llm_load_print_meta: vocab_only = 0\n", + "llm_load_print_meta: n_ctx_train = 4096\n", + "llm_load_print_meta: n_embd = 4096\n", + "llm_load_print_meta: n_layer = 32\n", + "llm_load_print_meta: n_head = 32\n", + "llm_load_print_meta: n_head_kv = 32\n", + "llm_load_print_meta: n_rot = 128\n", + "llm_load_print_meta: n_swa = 0\n", + "llm_load_print_meta: n_embd_head_k = 128\n", + "llm_load_print_meta: n_embd_head_v = 128\n", + "llm_load_print_meta: n_gqa = 1\n", + "llm_load_print_meta: n_embd_k_gqa = 4096\n", + "llm_load_print_meta: n_embd_v_gqa = 4096\n", + "llm_load_print_meta: f_norm_eps = 0.0e+00\n", + "llm_load_print_meta: f_norm_rms_eps = 1.0e-05\n", + "llm_load_print_meta: f_clamp_kqv = 0.0e+00\n", + "llm_load_print_meta: f_max_alibi_bias = 0.0e+00\n", + "llm_load_print_meta: f_logit_scale = 0.0e+00\n", + "llm_load_print_meta: n_ff = 11008\n", + "llm_load_print_meta: n_expert = 0\n", + "llm_load_print_meta: n_expert_used = 0\n", + "llm_load_print_meta: causal attn = 1\n", + "llm_load_print_meta: pooling type = 0\n", + "llm_load_print_meta: rope type = 0\n", + "llm_load_print_meta: rope scaling = linear\n", + "llm_load_print_meta: freq_base_train = 10000.0\n", + "llm_load_print_meta: freq_scale_train = 1\n", + "llm_load_print_meta: n_ctx_orig_yarn = 4096\n", + "llm_load_print_meta: rope_finetuned = unknown\n", + "llm_load_print_meta: ssm_d_conv = 0\n", + "llm_load_print_meta: ssm_d_inner = 0\n", + "llm_load_print_meta: ssm_d_state = 0\n", + "llm_load_print_meta: ssm_dt_rank = 0\n", + "llm_load_print_meta: model type = 7B\n", + "llm_load_print_meta: model ftype = Q4_K - Medium\n", + "llm_load_print_meta: model params = 6.74 B\n", + "llm_load_print_meta: model size = 3.80 GiB (4.84 BPW) \n", + "llm_load_print_meta: general.name = LLaMA v2\n", + "llm_load_print_meta: BOS token = 1 ''\n", + "llm_load_print_meta: EOS token = 2 ''\n", + "llm_load_print_meta: UNK token = 0 ''\n", + "llm_load_print_meta: PAD token = 0 ''\n", + "llm_load_print_meta: LF token = 13 '<0x0A>'\n", + "llm_load_print_meta: max token length = 48\n", + "llm_load_tensors: ggml ctx size = 0.27 MiB\n", + "llm_load_tensors: offloading 32 repeating layers to GPU\n", + "llm_load_tensors: offloading non-repeating layers to GPU\n", + "llm_load_tensors: offloaded 33/33 layers to GPU\n", + "llm_load_tensors: CPU buffer size = 70.31 MiB\n", + "llm_load_tensors: CUDA0 buffer size = 3820.94 MiB\n", + "..................................................................................................\n", + "llama_new_context_with_model: n_ctx = 4096\n", + "llama_new_context_with_model: n_batch = 512\n", + "llama_new_context_with_model: n_ubatch = 512\n", + "llama_new_context_with_model: flash_attn = 0\n", + "llama_new_context_with_model: freq_base = 10000.0\n", + "llama_new_context_with_model: freq_scale = 1\n", + "llama_kv_cache_init: CUDA0 KV buffer size = 2048.00 MiB\n", + "llama_new_context_with_model: KV self size = 2048.00 MiB, K (f16): 1024.00 MiB, V (f16): 1024.00 MiB\n", + "llama_new_context_with_model: CUDA_Host output buffer size = 0.12 MiB\n", + "ggml_gallocr_reserve_n: reallocating CUDA0 buffer from size 0.00 MiB to 296.00 MiB\n", + "ggml_gallocr_reserve_n: reallocating CUDA_Host buffer from size 0.00 MiB to 16.01 MiB\n", + "llama_new_context_with_model: CUDA0 compute buffer size = 296.00 MiB\n", + "llama_new_context_with_model: CUDA_Host compute buffer size = 16.01 MiB\n", + "llama_new_context_with_model: graph nodes = 1030\n", + "llama_new_context_with_model: graph splits = 2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] initializing slots n_slots=1\n", + "[INFO] new slot slot_id=0 n_ctx_slot=4096\n", + "[INFO] model loaded\n", + "[INFO] chat template chat_example=\"You are a helpful assistant\\n\\nUSER: Hello\\nASSISTANT: Hi there\\nUSER: How are you?\\nASSISTANT:\" built_in=false\n", + "[INFO] all slots are idle and system prompt is empty, clear the KV cache\n", + "[INFO] slot is processing task slot_id=0 task_id=0\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=0 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 76.17 ms by CLIP ( 0.13 ms per image patch)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "llama_output_reserve: reallocating output buffer from size 0.12 MiB to 1.22 MiB\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 481.17 ms / 1 tokens ( 481.17 ms per token, 2.08 tokens per second) slot_id=0 task_id=0 t_prompt_processing=481.165 n_prompt_tokens_processed=1 t_token=481.165 n_tokens_second=2.078289152369769\n", + "[INFO] generation eval time = 757.27 ms / 40 runs ( 18.93 ms per token, 52.82 tokens per second) slot_id=0 task_id=0 t_token_generation=757.271 n_decoded=40 t_token=18.931775 n_tokens_second=52.821248932020374\n", + "[INFO] total time = 1238.44 ms slot_id=0 task_id=0 t_prompt_processing=481.165 t_token_generation=757.271 t_total=1238.436\n", + "[INFO] slot released slot_id=0 task_id=0 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n", + "[INFO] slot is processing task slot_id=0 task_id=1\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=1 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 48.94 ms by CLIP ( 0.08 ms per image patch)\n", + "ggml_gallocr_needs_realloc: node inp_embd is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 418.86 ms / 1 tokens ( 418.86 ms per token, 2.39 tokens per second) slot_id=0 task_id=1 t_prompt_processing=418.858 n_prompt_tokens_processed=1 t_token=418.858 n_tokens_second=2.387443954753162\n", + "[INFO] generation eval time = 760.78 ms / 40 runs ( 19.02 ms per token, 52.58 tokens per second) slot_id=0 task_id=1 t_token_generation=760.785 n_decoded=40 t_token=19.019624999999998 n_tokens_second=52.57727215967718\n", + "[INFO] total time = 1179.64 ms slot_id=0 task_id=1 t_prompt_processing=418.858 t_token_generation=760.785 t_total=1179.643\n", + "[INFO] slot released slot_id=0 task_id=1 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/18 13:46:37 WARN DAGScheduler: Broadcasting large task binary with size 1090.9 KiB\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] slot is processing task slot_id=0 task_id=84\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=84 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 51.93 ms by CLIP ( 0.09 ms per image patch)\n", + "ggml_gallocr_needs_realloc: node inp_embd is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 434.93 ms / 1 tokens ( 434.93 ms per token, 2.30 tokens per second) slot_id=0 task_id=84 t_prompt_processing=434.926 n_prompt_tokens_processed=1 t_token=434.926 n_tokens_second=2.2992417100840146\n", + "[INFO] generation eval time = 759.00 ms / 40 runs ( 18.98 ms per token, 52.70 tokens per second) slot_id=0 task_id=84 t_token_generation=759.003 n_decoded=40 t_token=18.975075 n_tokens_second=52.70071396292241\n", + "[INFO] total time = 1193.93 ms slot_id=0 task_id=84 t_prompt_processing=434.926 t_token_generation=759.003 t_total=1193.929\n", + "[INFO] slot released slot_id=0 task_id=84 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n", + "[INFO] slot is processing task slot_id=0 task_id=85\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=85 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 49.35 ms by CLIP ( 0.09 ms per image patch)\n", + "ggml_gallocr_needs_realloc: node inp_embd is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "encode_image_with_clip: image embedding created: 576 tokens (1 + 3) / 4]\n", + "\n", + "encode_image_with_clip: image encoded in 50.33 ms by CLIP ( 0.09 ms per image patch)\n", + "ggml_gallocr_needs_realloc: node inp_embd is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 418.23 ms / 1 tokens ( 418.23 ms per token, 2.39 tokens per second) slot_id=0 task_id=85 t_prompt_processing=418.234 n_prompt_tokens_processed=1 t_token=418.234 n_tokens_second=2.391005991861016\n", + "[INFO] generation eval time = 310.67 ms / 17 runs ( 18.27 ms per token, 54.72 tokens per second) slot_id=0 task_id=85 t_token_generation=310.665 n_decoded=17 t_token=18.274411764705885 n_tokens_second=54.72132361225113\n", + "[INFO] total time = 728.90 ms slot_id=0 task_id=85 t_prompt_processing=418.234 t_token_generation=310.665 t_total=728.899\n", + "[INFO] slot released slot_id=0 task_id=85 n_ctx=4096 n_past=609 n_system_tokens=0 n_cache_tokens=18 truncated=false\n", + "[INFO] slot is processing task slot_id=0 task_id=87\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=87 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 423.11 ms / 1 tokens ( 423.11 ms per token, 2.36 tokens per second) slot_id=0 task_id=87 t_prompt_processing=423.106 n_prompt_tokens_processed=1 t_token=423.106 n_tokens_second=2.3634739285190944\n", + "[INFO] generation eval time = 771.11 ms / 40 runs ( 19.28 ms per token, 51.87 tokens per second) slot_id=0 task_id=87 t_token_generation=771.106 n_decoded=40 t_token=19.27765 n_tokens_second=51.873542677660396\n", + "[INFO] total time = 1194.21 ms slot_id=0 task_id=87 t_prompt_processing=423.106 t_token_generation=771.106 t_total=1194.212\n", + "[INFO] slot released slot_id=0 task_id=87 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n", + "[INFO] slot is processing task slot_id=0 task_id=88\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=88 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 50.07 ms by CLIP ( 0.09 ms per image patch)\n", + "ggml_gallocr_needs_realloc: node inp_embd is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 423.79 ms / 1 tokens ( 423.79 ms per token, 2.36 tokens per second) slot_id=0 task_id=88 t_prompt_processing=423.79 n_prompt_tokens_processed=1 t_token=423.79 n_tokens_second=2.359659265202105\n", + "[INFO] generation eval time = 251.86 ms / 14 runs ( 17.99 ms per token, 55.59 tokens per second) slot_id=0 task_id=88 t_token_generation=251.863 n_decoded=14 t_token=17.990214285714284 n_tokens_second=55.58577480614461\n", + "[INFO] total time = 675.65 ms slot_id=0 task_id=88 t_prompt_processing=423.79 t_token_generation=251.863 t_total=675.653\n", + "[INFO] slot released slot_id=0 task_id=88 n_ctx=4096 n_past=606 n_system_tokens=0 n_cache_tokens=15 truncated=false\n", + "[INFO] slot is processing task slot_id=0 task_id=89\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=89 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 49.78 ms by CLIP ( 0.09 ms per image patch)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 50.26 ms by CLIP ( 0.09 ms per image patch)\n", + "ggml_gallocr_needs_realloc: node inp_embd is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 422.05 ms / 1 tokens ( 422.05 ms per token, 2.37 tokens per second) slot_id=0 task_id=89 t_prompt_processing=422.047 n_prompt_tokens_processed=1 t_token=422.047 n_tokens_second=2.369404355439086\n", + "[INFO] generation eval time = 351.31 ms / 19 runs ( 18.49 ms per token, 54.08 tokens per second) slot_id=0 task_id=89 t_token_generation=351.31 n_decoded=19 t_token=18.49 n_tokens_second=54.08328826392644\n", + "[INFO] total time = 773.36 ms slot_id=0 task_id=89 t_prompt_processing=422.047 t_token_generation=351.31 t_total=773.357\n", + "[INFO] slot released slot_id=0 task_id=89 n_ctx=4096 n_past=611 n_system_tokens=0 n_cache_tokens=20 truncated=false\n", + "[INFO] slot is processing task slot_id=0 task_id=90\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=90 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 419.07 ms / 1 tokens ( 419.07 ms per token, 2.39 tokens per second) slot_id=0 task_id=90 t_prompt_processing=419.071 n_prompt_tokens_processed=1 t_token=419.071 n_tokens_second=2.386230495548487\n", + "[INFO] generation eval time = 768.85 ms / 40 runs ( 19.22 ms per token, 52.03 tokens per second) slot_id=0 task_id=90 t_token_generation=768.849 n_decoded=40 t_token=19.221225 n_tokens_second=52.0258204146718\n", + "[INFO] total time = 1187.92 ms slot_id=0 task_id=90 t_prompt_processing=419.071 t_token_generation=768.849 t_total=1187.92\n", + "[INFO] slot released slot_id=0 task_id=90 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n", + "[INFO] slot is processing task slot_id=0 task_id=91\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=91 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 49.82 ms by CLIP ( 0.09 ms per image patch)\n", + "ggml_gallocr_needs_realloc: node inp_embd is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 424.45 ms / 1 tokens ( 424.45 ms per token, 2.36 tokens per second) slot_id=0 task_id=91 t_prompt_processing=424.45 n_prompt_tokens_processed=1 t_token=424.45 n_tokens_second=2.3559901048415597\n", + "[INFO] generation eval time = 761.95 ms / 40 runs ( 19.05 ms per token, 52.50 tokens per second) slot_id=0 task_id=91 t_token_generation=761.953 n_decoded=40 t_token=19.048825 n_tokens_second=52.49667630418149\n", + "[INFO] total time = 1186.40 ms slot_id=0 task_id=91 t_prompt_processing=424.45 t_token_generation=761.953 t_total=1186.403\n", + "[INFO] slot released slot_id=0 task_id=91 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n", + "[INFO] slot is processing task slot_id=0 task_id=92\n", + "[INFO] kv cache rm [p0, end) slot_id=0 task_id=92 p0=0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "encode_image_with_clip: image embedding created: 576 tokens\n", + "\n", + "encode_image_with_clip: image encoded in 49.04 ms by CLIP ( 0.09 ms per image patch)\n", + "ggml_gallocr_needs_realloc: node inp_embd is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] prompt eval time = 417.26 ms / 1 tokens ( 417.26 ms per token, 2.40 tokens per second) slot_id=0 task_id=92 t_prompt_processing=417.263 n_prompt_tokens_processed=1 t_token=417.263 n_tokens_second=2.3965700289745318\n", + "[INFO] generation eval time = 329.49 ms / 18 runs ( 18.31 ms per token, 54.63 tokens per second) slot_id=0 task_id=92 t_token_generation=329.493 n_decoded=18 t_token=18.305166666666665 n_tokens_second=54.629385146270174\n", + "[INFO] total time = 746.76 ms slot_id=0 task_id=92 t_prompt_processing=417.263 t_token_generation=329.493 t_total=746.756\n", + "[INFO] slot released slot_id=0 task_id=92 n_ctx=4096 n_past=610 n_system_tokens=0 n_cache_tokens=19 truncated=false\n", + "+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|image_name |result |\n", + "+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|palace.JPEG |[ The image depicts a large, ornate room with high ceilings and yellow walls. It features an elegant sitting area with several chairs arranged around the space. There are also multiple c] |\n", + "|egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the frame and appears to be sleeping while holding] |\n", + "|hippopotamus.JPEG|[ A large brown hippo is swimming in a pond, with its head above the water. The hippo appears to be enjoying itself as it floats on top of the water.] |\n", + "|hen.JPEG |[ The image features a large white chicken standing next to several baby chicks. There are at least five visible chickens in the scene, with one adult and four young ones surrounding it. They]|\n", + "|ostrich.JPEG |[ A large ostrich stands in a grassy field, surrounded by trees and bushes. The bird is the main focus of the image with its long neck stretched out as it looks around at] |\n", + "|junco.JPEG |[ A small bird with a black head and white chest is standing on the snow.] |\n", + "|bluetick.jpg |[ A dog with a red collar is sitting on the floor.] |\n", + "|chihuahua.jpg |[ A small brown dog wearing a sweater and collar is sitting on the floor.] |\n", + "|tractor.JPEG |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels. The tractor appears to be parked on top of an agricultural field with rows of] |\n", + "|ox.JPEG |[ A large bull with long horns is standing in a grassy field.] |\n", + "+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n", + "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n", + "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n", + " \r" + ] + } + ], + "source": [ + "import sparknlp\n", + "from sparknlp.base import *\n", + "from sparknlp.annotator import *\n", + "from pyspark.ml import Pipeline\n", + "\n", + "documentAssembler = (\n", + " DocumentAssembler().setInputCol(\"caption\").setOutputCol(\"caption_document\")\n", + ")\n", + "imageAssembler = ImageAssembler().setInputCol(\"image\").setOutputCol(\"image_assembler\")\n", + "model = AutoGGUFVisionModel.load(\"llava_v1.5_7b_Q4_0_gguf_spark_nlp\")\n", + "pipeline = Pipeline().setStages([documentAssembler, imageAssembler, model])\n", + "\n", + "pipeline.fit(data).transform(data).selectExpr(\n", + " \"reverse(split(image.origin, '/'))[0] as image_name\", \"completions.result\"\n", + ").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's it! You can now go wild and use hundreds of GGUF models from HuggingFace 🤗 in Spark NLP 🚀\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "sparknlp_dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/python/reader/SparkNLP_Email_Reader_Demo.ipynb b/examples/python/reader/SparkNLP_Email_Reader_Demo.ipynb index 1e35592f81f748..1574e3d6f202bc 100644 --- a/examples/python/reader/SparkNLP_Email_Reader_Demo.ipynb +++ b/examples/python/reader/SparkNLP_Email_Reader_Demo.ipynb @@ -48,25 +48,6 @@ "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Additional Configuration for Databricks" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "When running on Databricks, it is necessary to include the following Spark configurations to avoid dependency conflicts:\n", - "\n", - "- `spark.driver.userClassPathFirst true`\n", - "- `spark.executor.userClassPathFirst true`\n", - "\n", - "These configurations are required because the Databricks runtime environment includes a bundled version of the `com.sun.mail:jakarta.mail` library, which conflicts with `jakarta.activation`. By setting these properties, the application ensures that the user-provided libraries take precedence over those bundled in the Databricks environment, resolving the dependency conflict." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -76,41 +57,42 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ya8qZe00dalC", - "outputId": "a9916407-f76d-4c59-fdad-ea17ca0a4326" + "outputId": "d5d30ba3-710f-481a-c68a-b97f8a808db6" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "mkdir: cannot create directory ‘email-files’: File exists\n", - "--2024-11-13 21:01:15-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1093-Adding-support-to-read-Email-files/src/test/resources/reader/email/email-text-attachments.eml\n", + "--2025-03-06 00:20:35-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/email/email-text-attachments.eml\n", "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 3175 (3.1K) [text/plain]\n", "Saving to: ‘email-files/email-text-attachments.eml’\n", "\n", + "\r", + " email-tex 0%[ ] 0 --.-KB/s \r", "email-text-attachme 100%[===================>] 3.10K --.-KB/s in 0s \n", "\n", - "2024-11-13 21:01:15 (29.9 MB/s) - ‘email-files/email-text-attachments.eml’ saved [3175/3175]\n", + "2025-03-06 00:20:35 (34.6 MB/s) - ‘email-files/email-text-attachments.eml’ saved [3175/3175]\n", "\n", - "--2024-11-13 21:01:15-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1093-Adding-support-to-read-Email-files/src/test/resources/reader/email/test-several-attachments.eml\n", - "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", - "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "--2025-03-06 00:20:35-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/email/test-several-attachments.eml\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.110.133, 185.199.108.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1324361 (1.3M) [text/plain]\n", "Saving to: ‘email-files/test-several-attachments.eml’\n", "\n", - "test-several-attach 100%[===================>] 1.26M --.-KB/s in 0.05s \n", + "test-several-attach 100%[===================>] 1.26M --.-KB/s in 0.01s \n", "\n", - "2024-11-13 21:01:16 (26.7 MB/s) - ‘email-files/test-several-attachments.eml’ saved [1324361/1324361]\n", + "2025-03-06 00:20:35 (126 MB/s) - ‘email-files/test-several-attachments.eml’ saved [1324361/1324361]\n", "\n" ] } @@ -123,13 +105,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3xgGItNbU2DZ", - "outputId": "12f8a7be-f9b4-49ce-a9ab-222142f28293" + "outputId": "ddb35b87-76e6-41d3-ffda-9cf00108b2c3" }, "outputs": [ { @@ -137,8 +119,8 @@ "output_type": "stream", "text": [ "total 1.3M\n", - "-rw-r--r-- 1 root root 3.2K Nov 13 21:01 email-text-attachments.eml\n", - "-rw-r--r-- 1 root root 1.3M Nov 13 21:01 test-several-attachments.eml\n" + "-rw-r--r-- 1 root root 3.2K Mar 6 00:20 email-text-attachments.eml\n", + "-rw-r--r-- 1 root root 1.3M Mar 6 00:20 test-several-attachments.eml\n" ] } ], @@ -158,13 +140,13 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "bAkMjJ1vdalE", - "outputId": "4b360b6c-5049-4f10-bb52-60e0e0e52e52" + "outputId": "d1f3f6e0-b8d8-4d2e-c83b-e41be1e8767e" }, "outputs": [ { @@ -175,8 +157,8 @@ "+--------------------+\n", "| email|\n", "+--------------------+\n", - "|[{Title, Email Te...|\n", "|[{Title, Test Sev...|\n", + "|[{Title, Email Te...|\n", "+--------------------+\n", "\n" ] @@ -191,13 +173,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7CMPPubFTeHj", - "outputId": "48ee68cf-0f7f-408a-a855-2fd2eb2e8bd1" + "outputId": "360f6051-718f-48fe-9650-55886141b383" }, "outputs": [ { @@ -206,7 +188,6 @@ "text": [ "root\n", " |-- path: string (nullable = true)\n", - " |-- content: binary (nullable = true)\n", " |-- email: array (nullable = true)\n", " | |-- element: struct (containsNull = true)\n", " | | |-- elementType: string (nullable = true)\n", @@ -228,10 +209,263 @@ "id": "Qooecm9VTeus" }, "source": [ - "You can also use DFS file systems like:\n", - "- Databricks: `dbfs://`\n", - "- HDFS: `hdfs://`\n", - "- Microsoft Fabric OneLake: `abfss://`" + "You can also use DFS like Databricks `dbfs://` or HDFS directories `hdfs://`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a5uyqiYQo9Xe" + }, + "source": [ + "### Configuration Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9Lcd5fvozko6" + }, + "source": [ + "Let's add an email file for this example." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "S2ub8DT5pEq2", + "outputId": "03967d94-7e83-424a-ee3b-d01e1e913d29" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2025-03-06 00:20:57-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/email/email-text-attachments.eml\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.111.133, 185.199.108.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 3175 (3.1K) [text/plain]\n", + "Saving to: ‘email-files/email-text-attachments.eml.1’\n", + "\n", + "\r", + " email-tex 0%[ ] 0 --.-KB/s \r", + "email-text-attachme 100%[===================>] 3.10K --.-KB/s in 0s \n", + "\n", + "2025-03-06 00:20:57 (27.2 MB/s) - ‘email-files/email-text-attachments.eml.1’ saved [3175/3175]\n", + "\n" + ] + } + ], + "source": [ + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/email/email-text-attachments.eml -P email-files" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jg3XfrrnpBm3" + }, + "source": [ + "- `addAttachmentContent`: By default, this is set to `false`. When enabled, the output will include the content of attachments." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cBNdYiRfq7kr", + "outputId": "45cc42f2-ef11-4f25-f1bb-ae641fb9d9b6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n" + ] + } + ], + "source": [ + "params = {\"addAttachmentContent\": \"true\"}\n", + "email_df = sparknlp.read(params).email(\"./email-files/email-text-attachments.eml\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UzkzDBXHrtcc", + "outputId": "0a362808-43d8-4566-f185-e174ab98c42a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|elementType |content |\n", + "+-------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|NarrativeText|Email test with two text attachments\\r\\n\\r\\nCheers,\\r\\n\\r\\n |\n", + "|NarrativeText|\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\nEmail  test with two text attachments\\r\\n
\\r\\n
\\r\\n
\\r\\n
\\r\\nCheers,
\\r\\n
\\r\\n
\\r\\n
\\r\\n\\r\\n\\r\\n|\n", + "|NarrativeText|This is the content of the file.\\n |\n", + "|NarrativeText|This is an additional content file.\\n |\n", + "+-------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from pyspark.sql.functions import explode, col\n", + "\n", + "narrative_text_df = (\n", + " email_df\n", + " .select(\n", + " explode(col(\"email\")).alias(\"email_element\")\n", + " )\n", + " .filter(col(\"email_element.elementType\") == \"NarrativeText\")\n", + " .select(\n", + " col(\"email_element.elementType\"),\n", + " col(\"email_element.content\")\n", + " )\n", + ")\n", + "\n", + "narrative_text_df.show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k-AUDev1zraM" + }, + "source": [ + "As you can see in the dataframe above the NarrativeText include the data from the attached text files." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OKotsvSspORA", + "outputId": "303d5057-6812-4900-e0f6-d4a7686298b9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "email_df = sparknlp.read().email(\"./email-files/email-text-attachments.eml\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ut_K1uidvaAu", + "outputId": "09c7e16f-f513-46a1-9e57-6e429bd993b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|elementType |content |\n", + "+-------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|NarrativeText|Email test with two text attachments\\r\\n\\r\\nCheers,\\r\\n\\r\\n |\n", + "|NarrativeText|\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\nEmail  test with two text attachments\\r\\n
\\r\\n
\\r\\n
\\r\\n
\\r\\nCheers,
\\r\\n
\\r\\n
\\r\\n
\\r\\n\\r\\n\\r\\n|\n", + "+-------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from pyspark.sql.functions import explode, col\n", + "\n", + "narrative_text_df = (\n", + " email_df\n", + " .select(\n", + " explode(col(\"email\")).alias(\"email_element\")\n", + " )\n", + " .filter(col(\"email_element.elementType\") == \"NarrativeText\")\n", + " .select(\n", + " col(\"email_element.elementType\"),\n", + " col(\"email_element.content\")\n", + " )\n", + ")\n", + "\n", + "narrative_text_df.show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wusCNu2oz1Jq" + }, + "source": [ + "As you can see in the dataframe above the NarrativeText does not include the data from the attached text files." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GtUESNPQq4rz" + }, + "source": [ + "- `storeContent`: By default, this is set to `false`. When enabled, the output will include the byte content of the file." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4OmCy_S4pXeC", + "outputId": "caa62b94-94bf-4b00-ad48-6a690ecf740a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+--------------------+\n", + "| path| email| content|\n", + "+--------------------+--------------------+--------------------+\n", + "|file:/content/ema...|[{Title, Email Te...|[46 72 6F 6D 3A 2...|\n", + "+--------------------+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"storeContent\": \"true\"}\n", + "email_df = sparknlp.read(params).email(\"./email-files/email-text-attachments.eml\")\n", + "email_df.show()" ] } ], diff --git a/examples/python/reader/SparkNLP_Excel_Reader_Demo.ipynb b/examples/python/reader/SparkNLP_Excel_Reader_Demo.ipynb new file mode 100644 index 00000000000000..d5b3838b45c051 --- /dev/null +++ b/examples/python/reader/SparkNLP_Excel_Reader_Demo.ipynb @@ -0,0 +1,329 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "9ehZGOlcBf98" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/reader/SparkNLP_Excel_Reader_Demo.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tzcU5p2gdak9" + }, + "source": [ + "# Introducing Excel reader in SparkNLP\n", + "This notebook showcases the newly added `sparknlp.read().xls()` method in Spark NLP that parses Excel content from both local files and both local and distributed file systems into a Spark DataFrame." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RFOFhaEedalB" + }, + "source": [ + "## Setup and Initialization\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "Support for reading html files was introduced in Spark NLP 6.0.0. Please make sure you have upgraded to the latest Spark NLP release." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xFY30Xy8Brav" + }, + "source": [ + "- Let's install and setup Spark NLP in Google Colab\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "qEllqTAQBs61" + }, + "outputs": [], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D02R4ZahBunE" + }, + "source": [ + "For local files example we will download an Excel file from Spark NLP Github repo:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ya8qZe00dalC", + "outputId": "32108d19-0a00-4e59-c056-1839111aa56d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2025-03-06 15:41:14-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1102-Adding-support-to-read-Excel-files/src/test/resources/reader/xls/vodafone.xlsx\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 12541 (12K) [application/octet-stream]\n", + "Saving to: ‘excel-files/vodafone.xlsx’\n", + "\n", + "\r", + "vodafone.xlsx 0%[ ] 0 --.-KB/s \r", + "vodafone.xlsx 100%[===================>] 12.25K --.-KB/s in 0s \n", + "\n", + "2025-03-06 15:41:14 (61.1 MB/s) - ‘excel-files/vodafone.xlsx’ saved [12541/12541]\n", + "\n" + ] + } + ], + "source": [ + "!mkdir excel-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/xls/vodafone.xlsx -P excel-files" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EoFI66NAdalE" + }, + "source": [ + "## Parsing Excel sheets from Local Files\n", + "Use the `xls()` method to parse Excel content from local directories." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bAkMjJ1vdalE", + "outputId": "24edd331-b503-4c1b-d174-60c5bd128b4a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+\n", + "| path| xls|\n", + "+--------------------+--------------------+\n", + "|file:/content/exc...|[{Title, Financia...|\n", + "+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "xls_df = sparknlp.read().xls(\"./excel-files\")\n", + "\n", + "xls_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VWbUgoVQrO8m", + "outputId": "bd72bc6e-1e38-4b94-e063-49f827896fda" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- path: string (nullable = true)\n", + " |-- xls: array (nullable = true)\n", + " | |-- element: struct (containsNull = true)\n", + " | | |-- elementType: string (nullable = true)\n", + " | | |-- content: string (nullable = true)\n", + " | | |-- metadata: map (nullable = true)\n", + " | | | |-- key: string\n", + " | | | |-- value: string (valueContainsNull = true)\n", + "\n" + ] + } + ], + "source": [ + "xls_df.printSchema()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VQD2k4E5dalF" + }, + "source": [ + "## Configuration Parameters\n", + "- `titleFontSize`: You can customize the font size used to identify paragraphs that should be treated as titles. By default, the font size is set to 9.\n", + "- `cellSeparator`: You can also customize the separator for each cell in the sheet. By defult, the separator is tab `\"\\t\"`\n", + "\n", + "However, if your Excel files require a different configuration, you can adjust this parameter accordingly. The example below demonstrates how to modify and work with this setting:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MMTGmxLQdalG", + "outputId": "a436f4a9-68c3-473c-d04c-e46ed45198ab" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|xls |\n", + "+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|[{NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {Title, ;Financial performance;;;;;;;;;, {SheetName -> Index}}, {Title, ;Topic;Period;;;Page;;;;;, {SheetName -> Index}}, {NarrativeText, ;Quarterly revenue;Nine quarters to 30 June 2023;;;1.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Group financial performance;FY 22;FY 23;;2.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Segmental results;FY 22;FY 23;;3.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Segmental analysis;FY 22;FY 23;;4.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Cash flow;FY 22;FY 23;;5.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {Title, ;Operational metrics;;;;;;;;;, {SheetName -> Index}}, {Title, ;Topic;Period;;;Page;;;;;, {SheetName -> Index}}, {NarrativeText, ;Mobile customers;Nine quarters to 30 June 2023;;;6.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Fixed broadband customers;Nine quarters to 30 June 2023;;;7.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Marketable homes passed;Nine quarters to 30 June 2023;;;8.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;TV customers;Nine quarters to 30 June 2023;;;9.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Converged customers;Nine quarters to 30 June 2023;;;10.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Mobile churn;Nine quarters to 30 June 2023;;;11.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Mobile data usage;Nine quarters to 30 June 2023;;;12.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Mobile ARPU;Nine quarters to 30 June 2023;;;13.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {Title, ;Other;;;;;;;;;, {SheetName -> Index}}, {Title, ;Topic;Period;;;Page;;;;;, {SheetName -> Index}}, {NarrativeText, ;Average foreign exchange rates;Nine quarters to 30 June 2023;;;14.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;Guidance rates;FY 23/24;;;14.0;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}, {NarrativeText, ;;;;;;;;;;, {SheetName -> Index}}]|\n", + "+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"titleFontSize\": \"9\", \"cellSeparator\": \";\"}\n", + "xls_df = sparknlp.read(params).xls(\"./excel-files\")\n", + "xls_df.select(\"xls\").show(truncate=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oBj0cHPXSD1m", + "outputId": "51d52150-8764-4b0b-8728-42cfaaa55800" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- path: string (nullable = true)\n", + " |-- xls: array (nullable = true)\n", + " | |-- element: struct (containsNull = true)\n", + " | | |-- elementType: string (nullable = true)\n", + " | | |-- content: string (nullable = true)\n", + " | | |-- metadata: map (nullable = true)\n", + " | | | |-- key: string\n", + " | | | |-- value: string (valueContainsNull = true)\n", + "\n" + ] + } + ], + "source": [ + "xls_df.printSchema()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BB2FEfegGuxl" + }, + "source": [ + "You can also use DFS file systems like:\n", + "- Databricks: `dbfs://`\n", + "- HDFS: `hdfs://`\n", + "- Microsoft Fabric OneLake: `abfss://`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1oihvmD4B3v8" + }, + "source": [ + "- `storeContent`: By default, this is set to `false`. When enabled, the output will include the byte content of the file." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uYGF7rQDB5Mc", + "outputId": "7e540660-5ab0-4e9a-a86e-8fee2158cee0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+--------------------+\n", + "| path| xls| content|\n", + "+--------------------+--------------------+--------------------+\n", + "|file:/content/exc...|[{Title, Financia...|[50 4B 03 04 14 0...|\n", + "+--------------------+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"storeContent\": \"true\"}\n", + "xls_df = sparknlp.read(params).xls(\"./excel-files\")\n", + "xls_df.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/reader/SparkNLP_HTML_Reader_Demo.ipynb b/examples/python/reader/SparkNLP_HTML_Reader_Demo.ipynb index 99782a9e04683c..955652e0474f98 100644 --- a/examples/python/reader/SparkNLP_HTML_Reader_Demo.ipynb +++ b/examples/python/reader/SparkNLP_HTML_Reader_Demo.ipynb @@ -32,12 +32,14 @@ "## Setup and Initialization\n", "Let's keep in mind a few things before we start 😊\n", "\n", - "Support for reading html files was introduced in `Spark NLP 5.5.2`. Please make sure you have upgraded to the latest Spark NLP release." + "Support for reading html files was introduced in Spark NLP 5.5.2. Please make sure you have upgraded to the latest Spark NLP release." ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "id": "Y3hWfT5q-npM" + }, "source": [ "- Let's install and setup Spark NLP in Google Colab\n", "- This part is pretty easy via our simple script" @@ -46,7 +48,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "id": "u3ORYVyb-pRI" + }, "outputs": [], "source": [ "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" @@ -54,7 +58,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "id": "oIbFQyEo-tat" + }, "source": [ "For local files example we will download a couple of HTML files from Spark NLP Github repo:" ] @@ -67,27 +73,25 @@ "base_uri": "https://localhost:8080/" }, "id": "ya8qZe00dalC", - "outputId": "4399cc35-31d4-459c-bee8-d7eeba3d40cd" + "outputId": "96efd082-1c63-414b-d07c-6d41074bd397" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "--2024-11-05 20:02:19-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1089-Support-more-file-types-in-SparkNLP/src/test/resources/reader/html/example-10k.html\n", + "--2025-03-05 23:21:42-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/html/example-10k.html\n", "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 2456707 (2.3M) [text/plain]\n", "Saving to: ‘html-files/example-10k.html’\n", "\n", - "\r", - "example-10k.html 0%[ ] 0 --.-KB/s \r", - "example-10k.html 100%[===================>] 2.34M --.-KB/s in 0.01s \n", + "example-10k.html 100%[===================>] 2.34M --.-KB/s in 0.08s \n", "\n", - "2024-11-05 20:02:19 (157 MB/s) - ‘html-files/example-10k.html’ saved [2456707/2456707]\n", + "2025-03-05 23:21:43 (30.6 MB/s) - ‘html-files/example-10k.html’ saved [2456707/2456707]\n", "\n", - "--2024-11-05 20:02:20-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1089-Support-more-file-types-in-SparkNLP/src/test/resources/reader/html/fake-html.html\n", + "--2025-03-05 23:21:43-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/html/fake-html.html\n", "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", @@ -96,7 +100,7 @@ "\n", "fake-html.html 100%[===================>] 665 --.-KB/s in 0s \n", "\n", - "2024-11-05 20:02:20 (41.9 MB/s) - ‘html-files/fake-html.html’ saved [665/665]\n", + "2025-03-05 23:21:43 (40.3 MB/s) - ‘html-files/fake-html.html’ saved [665/665]\n", "\n" ] } @@ -125,7 +129,7 @@ "base_uri": "https://localhost:8080/" }, "id": "bAkMjJ1vdalE", - "outputId": "c4bb38d4-963d-465b-e222-604dc6b617aa" + "outputId": "ff94b96a-71b3-44e2-af0b-86b83d6f604f" }, "outputs": [ { @@ -133,12 +137,12 @@ "output_type": "stream", "text": [ "Warning::Spark Session already created, some configs may not take.\n", - "+--------------------+--------------------+--------------------+\n", - "| path| content| html|\n", - "+--------------------+--------------------+--------------------+\n", - "|file:/content/htm...|\\n...|[{Title, 0, My Fi...|\n", - "|file:/content/htm...| 1}}, {NarrativeText, This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission., {pageNumber -> 1}}, {NarrativeText, More information... More information..., {pageNumber -> 1}}]|\n", + "+--------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", "\n" ] } ], "source": [ "html_df = sparknlp.read().html(\"https://example.com/\")\n", - "html_df.select(\"html\").show()" + "html_df.show(truncate=False)" ] }, { "cell_type": "code", "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oBj0cHPXSD1m", + "outputId": "995f2dfc-9491-4b83-965f-c97b415ef524" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- url: string (nullable = true)\n", + " |-- html: array (nullable = true)\n", + " | |-- element: struct (containsNull = true)\n", + " | | |-- elementType: string (nullable = true)\n", + " | | |-- content: string (nullable = true)\n", + " | | |-- metadata: map (nullable = true)\n", + " | | | |-- key: string\n", + " | | | |-- value: string (valueContainsNull = true)\n", + "\n" + ] + } + ], + "source": [ + "html_df.printSchema()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "-psYdzWodalG", - "outputId": "544cd7e3-93a6-465a-8b9a-52d487d63b21" + "outputId": "04c0fb8a-73c6-4002-baa9-7655ce8f9239" }, "outputs": [ { @@ -219,8 +245,8 @@ "+--------------------+--------------------+\n", "| url| html|\n", "+--------------------+--------------------+\n", - "|https://www.wikip...|[{Title, 0, Wikip...|\n", - "|https://example.com/|[{Title, 0, Examp...|\n", + "|https://www.wikip...|[{Title, Wikipedi...|\n", + "|https://example.com/|[{Title, Example ...|\n", "+--------------------+--------------------+\n", "\n" ] @@ -251,13 +277,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "aNfN0fQC0Vzz", - "outputId": "0b849a86-2d59-4415-981a-dcd9a9f7a14a" + "outputId": "8e9c511b-e1fb-41df-affd-47dfacf3d4c9" }, "outputs": [ { @@ -265,11 +291,11 @@ "output_type": "stream", "text": [ "Warning::Spark Session already created, some configs may not take.\n", - "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", - "|html |\n", - "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", - "|[{Title, 0, My First Heading, {pageNumber -> 1}}, {Title, 0, My Second Heading, {pageNumber -> 1}}, {NarrativeText, 0, My first paragraph. lorem ipsum dolor set amet. if the cow comes home under the sun how do you fault the cow for it's worn hooves?, {pageNumber -> 1}}, {Title, 0, A Third Heading, {pageNumber -> 1}}, {Table, 0, Column 1 Column 2 Row 1, Cell 1 Row 1, Cell 2 Row 2, Cell 1 Row 2, Cell 2, {pageNumber -> 1}}]|\n", - "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|html |\n", + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|[{Title, My First Heading, {pageNumber -> 1}}, {Title, My Second Heading, {pageNumber -> 1}}, {NarrativeText, My first paragraph. lorem ipsum dolor set amet. if the cow comes home under the sun how do you fault the cow for it's worn hooves?, {pageNumber -> 1}}, {Title, A Third Heading, {pageNumber -> 1}}, {Table, Column 1 Column 2 Row 1, Cell 1 Row 1, Cell 2 Row 2, Cell 1 Row 2, Cell 2, {pageNumber -> 1}}]|\n", + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", "\n" ] } @@ -279,6 +305,46 @@ "html_df = sparknlp.read(params).html(\"./html-files/fake-html.html\")\n", "html_df.select(\"html\").show(truncate=False)" ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O8DePUq8nkYm" + }, + "source": [ + "You can access the raw content of the file using the `storeContent` parameter. This parameter was added in Spark NLP 6.0.0" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jTM1btqNntUL", + "outputId": "aa96124f-4ea6-4d33-b04e-47fa4af0bbe6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+--------------------+\n", + "| path| content| html|\n", + "+--------------------+--------------------+--------------------+\n", + "|file:/content/htm...|\\n...|[{Title, My First...|\n", + "+--------------------+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"storeContent\": \"true\"}\n", + "html_df = sparknlp.read(params).html(\"./html-files/fake-html.html\")\n", + "html_df.show()" + ] } ], "metadata": { diff --git a/examples/python/reader/SparkNLP_PDFToText_Annotator_Demo.ipynb b/examples/python/reader/SparkNLP_PDFToText_Annotator_Demo.ipynb new file mode 100644 index 00000000000000..6c37923fe94d43 --- /dev/null +++ b/examples/python/reader/SparkNLP_PDFToText_Annotator_Demo.ipynb @@ -0,0 +1,278 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/reader/SparkNLP_PDFToText_Annotator_Demo.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tzcU5p2gdak9" + }, + "source": [ + "# Introducing PDFToText annotator in SparkNLP\n", + "This notebook showcases the newly added `PDFToText` method in Spark NLP that parses PDF content from both local files and distributed file systems into a Spark DataFrame." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RFOFhaEedalB" + }, + "source": [ + "## Setup and Initialization\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "Support for reading pdf files was introduced in Spark NLP 6.0.0 Please make sure you have upgraded to the latest Spark NLP release." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's install and setup Spark NLP in Google Colab. This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For local files example we will download a couple of PDF files from Spark NLP Github repo:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ya8qZe00dalC", + "outputId": "a54d8f71-be37-43eb-b7e7-bc4c05848358" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2025-02-24 21:31:17-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1098-Adding-a-PDF-Reader-to-Spark-NLP/src/test/resources/reader/pdf/pdf-title.pdf\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 25803 (25K) [application/octet-stream]\n", + "Saving to: ‘pdf-files/pdf-title.pdf’\n", + "\n", + "pdf-title.pdf 100%[===================>] 25.20K --.-KB/s in 0.001s \n", + "\n", + "2025-02-24 21:31:18 (31.4 MB/s) - ‘pdf-files/pdf-title.pdf’ saved [25803/25803]\n", + "\n", + "--2025-02-24 21:31:18-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1098-Adding-a-PDF-Reader-to-Spark-NLP/src/test/resources/reader/pdf/text_3_pages.pdf\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.110.133, 185.199.111.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 9487 (9.3K) [application/octet-stream]\n", + "Saving to: ‘pdf-files/text_3_pages.pdf’\n", + "\n", + "text_3_pages.pdf 100%[===================>] 9.26K --.-KB/s in 0s \n", + "\n", + "2025-02-24 21:31:18 (45.7 MB/s) - ‘pdf-files/text_3_pages.pdf’ saved [9487/9487]\n", + "\n" + ] + } + ], + "source": [ + "!mkdir pdf-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/pdf/pdf-title.pdf -P pdf-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/pdf/text_3_pages.pdf -P pdf-files" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EoFI66NAdalE" + }, + "source": [ + "## Parsing PDFs from Local Files\n", + "Use the `PdfToText()` annotator to parse Excel content from local directories." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bAkMjJ1vdalE", + "outputId": "aabe0859-ec33-4830-e052-d3bc3a58f7e0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Apache Spark version: 3.5.4\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "# let's start Spark with Spark NLP\n", + "spark = sparknlp.start()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "acetAKBOHbif" + }, + "source": [ + "We need to set the configuraiton below. This setting is primarily included for backward compatibility with older versions of Spark." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "id": "6SSkLxHp4Ayq" + }, + "outputs": [], + "source": [ + "spark.conf.set(\"spark.sql.legacy.allowUntypedScalaUDF\", \"true\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "HHxmco4D17RB" + }, + "outputs": [], + "source": [ + "from sparknlp.base import *\n", + "from sparknlp.annotator import *\n", + "from sparknlp.reader.pdf_to_text import *\n", + "\n", + "pdf_to_text = PdfToText().setStoreSplittedPdf(True)\n", + "test_df = spark.read.format(\"binaryFile\").load(\"./pdf-examples\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "M3peSmKx2Rt-", + "outputId": "2b6ae1d8-485e-4ed1-a2c0-728b423d46c2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+--------------------+--------------------+------+------------------------------+----------------+---------------+--------------------+---------+-------+\n", + "| path| modificationTime|length|PdfToText_d08a2552221b__output|height_dimension|width_dimension| content|exception|pagenum|\n", + "+--------------------+--------------------+------+------------------------------+----------------+---------------+--------------------+---------+-------+\n", + "|file:/content/pdf...|2025-02-24 21:26:...| 25803| This is a Title \\...| 842| 596|[25 50 44 46 2D 3...| NULL| 0|\n", + "|file:/content/pdf...|2025-02-24 21:26:...| 9487| This is a page.\\n| 841| 595|[25 50 44 46 2D 3...| NULL| 0|\n", + "|file:/content/pdf...|2025-02-24 21:26:...| 9487| This is another p...| 841| 595|[25 50 44 46 2D 3...| NULL| 1|\n", + "|file:/content/pdf...|2025-02-24 21:26:...| 9487| Yet another page.\\n| 841| 595|[25 50 44 46 2D 3...| NULL| 2|\n", + "+--------------------+--------------------+------+------------------------------+----------------+---------------+--------------------+---------+-------+\n", + "\n" + ] + } + ], + "source": [ + "pipeline = Pipeline(stages=[pdf_to_text])\n", + "pipeline_model = pipeline.fit(test_df)\n", + "pdf_df = pipeline_model.transform(test_df)\n", + "pdf_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VWbUgoVQrO8m", + "outputId": "e89dc2fd-3051-40ee-d4af-8cddccb60a91" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- path: string (nullable = true)\n", + " |-- modificationTime: timestamp (nullable = true)\n", + " |-- length: long (nullable = true)\n", + " |-- PdfToText_d08a2552221b__output: string (nullable = true)\n", + " |-- height_dimension: integer (nullable = true)\n", + " |-- width_dimension: integer (nullable = true)\n", + " |-- content: binary (nullable = true)\n", + " |-- exception: string (nullable = true)\n", + " |-- pagenum: integer (nullable = true)\n", + "\n" + ] + } + ], + "source": [ + "pdf_df.printSchema()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BB2FEfegGuxl" + }, + "source": [ + "You can also use DFS file systems like:\n", + "- Databricks: `dbfs://`\n", + "- HDFS: `hdfs://`\n", + "- Microsoft Fabric OneLake: `abfss://`" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/reader/SparkNLP_PDF_Reader_Demo.ipynb b/examples/python/reader/SparkNLP_PDF_Reader_Demo.ipynb new file mode 100644 index 00000000000000..3dd09faf1eca7c --- /dev/null +++ b/examples/python/reader/SparkNLP_PDF_Reader_Demo.ipynb @@ -0,0 +1,376 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/reader/SparkNLP_PDF_Reader_Demo.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "9179255b-6bfd-415f-9f0a-54b6a3512617", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "tzcU5p2gdak9" + }, + "source": [ + "# Introducing PDF reader in SparkNLP\n", + "This notebook showcases the newly added `sparknlp.read().pdf()` method in Spark NLP that parses PDF content from both local files and distributed file systems into a Spark DataFrame." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "c3f8f91e-aee4-4e63-bfc7-89d93ac079cb", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "RFOFhaEedalB" + }, + "source": [ + "## Setup and Initialization\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "Support for reading pdf files was introduced in Spark NLP 6.0.0 Please make sure you have upgraded to the latest Spark NLP release." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's install and setup Spark NLP in Google Colab. This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "73d60304-095c-4068-ac38-614c0163f4ac", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "ya8qZe00dalC" + }, + "outputs": [], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For local files example we will download a couple of PDF files from Spark NLP Github repo:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!mkdir pdf-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/pdf/pdf-title.pdf -P pdf-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/pdf/text_3_pages.pdf -P pdf-files" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "e58c3483-2505-4f72-bf7d-617a96c4fbf0", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "EoFI66NAdalE" + }, + "source": [ + "## Parsing PDFs from Local Files\n", + "Use the `pdf()` method to parse Excel content from local directories." + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "ee51b499-e008-4861-b425-8450076e2d2e", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bAkMjJ1vdalE", + "outputId": "0fb33993-97b0-471a-c9e0-002a830b61d0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+-------------------+------+--------------------+----------------+---------------+-------+---------+-------+\n", + "| path| modificationTime|length| text|height_dimension|width_dimension|content|exception|pagenum|\n", + "+--------------------+-------------------+------+--------------------+----------------+---------------+-------+---------+-------+\n", + "|dbfs:/danilo/data...|2025-02-21 21:33:00| 25803|This is a Title \\...| 842| 596| NULL| NULL| 0|\n", + "|dbfs:/danilo/data...|2025-02-21 21:33:01| 15629| \\n\\n\\n| 841| 595| NULL| NULL| 0|\n", + "|dbfs:/danilo/data...|2025-02-21 21:33:01| 9487|This is a page.\\n...| 841| 595| NULL| NULL| 0|\n", + "+--------------------+-------------------+------+--------------------+----------------+---------------+-------+---------+-------+\n", + "\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "\n", + "pdf_df = sparknlp.read().pdf(\"./pdf-examples\")\n", + "pdf_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "65091263-01a0-4af3-aa0e-988761e9ba52", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VWbUgoVQrO8m", + "outputId": "cc6b55d7-aa86-4d2f-b43b-be7ec5797c2b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- path: string (nullable = true)\n", + " |-- modificationTime: timestamp (nullable = true)\n", + " |-- length: long (nullable = true)\n", + " |-- text: string (nullable = true)\n", + " |-- height_dimension: integer (nullable = true)\n", + " |-- width_dimension: integer (nullable = true)\n", + " |-- content: binary (nullable = true)\n", + " |-- exception: string (nullable = true)\n", + " |-- pagenum: integer (nullable = true)\n", + "\n" + ] + } + ], + "source": [ + "pdf_df.printSchema()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "b7119184-b033-4197-88c9-f8fa50b42be3", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "BB2FEfegGuxl" + }, + "source": [ + "You can also use DFS file systems like:\n", + "- Databricks: `dbfs://`\n", + "- HDFS: `hdfs://`\n", + "- Microsoft Fabric OneLake: `abfss://`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "60bfae5d-21a0-4932-8acb-30d19529e4cf", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "C1KhfLcCPizR" + }, + "source": [ + "### Configuration Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "d046ddfa-f097-41db-84a9-80d93d4c2693", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "OUSSGmjrPnPY" + }, + "source": [ + "You can customize the behavior of PDF reader with some parameters." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "9f8ae4b7-a73a-4e70-bbb9-afe69dd74d95", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "7jefzVyEP8f_" + }, + "source": [ + "- `storeSplittedPdf`: By default, it's `false`. When it's `true` it stores bytes content of splitted pdf in `content` column" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "643c4165-0b12-429c-9a75-3c2fd5207a72", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gDJyUi_9R4fr", + "outputId": "d4ac184d-dc46-4ced-87ff-f42f23f52cd2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+-------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+\n", + "| path| modificationTime|length| text|height_dimension|width_dimension| content|exception|pagenum|\n", + "+--------------------+-------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+\n", + "|dbfs:/danilo/data...|2025-02-21 21:33:00| 25803|This is a Title \\...| 842| 596|[25 50 44 46 2D 3...| NULL| 0|\n", + "|dbfs:/danilo/data...|2025-02-21 21:33:01| 15629| \\n\\n\\n| 841| 595|[25 50 44 46 2D 3...| NULL| 0|\n", + "|dbfs:/danilo/data...|2025-02-21 21:33:01| 9487|This is a page.\\n...| 841| 595|[25 50 44 46 2D 3...| NULL| 0|\n", + "+--------------------+-------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"storeSplittedPdf\": \"true\"}\n", + "pdf_df = sparknlp.read(params).pdf(\"./pdf-examples\")\n", + "pdf_df.show()" + ] + } + ], + "metadata": { + "application/vnd.databricks.v1+notebook": { + "computePreferences": null, + "dashboards": [], + "environmentMetadata": null, + "language": "python", + "notebookMetadata": { + "pythonIndentUnit": 4 + }, + "notebookName": "SparkNLP_PDF_Reader_Demo", + "widgets": {} + }, + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/reader/SparkNLP_PowerPoint_Reader_Demo.ipynb b/examples/python/reader/SparkNLP_PowerPoint_Reader_Demo.ipynb new file mode 100644 index 00000000000000..b70c0ac889c7b1 --- /dev/null +++ b/examples/python/reader/SparkNLP_PowerPoint_Reader_Demo.ipynb @@ -0,0 +1,265 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "H_ssGnSHQytt" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/reader/SparkNLP_PowerPoint_Reader_Demo.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tzcU5p2gdak9" + }, + "source": [ + "# Introducing PowerPoint reader in SparkNLP\n", + "This notebook showcases the newly added `sparknlp.read().ppt()` method in Spark NLP that parses Excel content from both local files and both local and distributed file systems into a Spark DataFrame." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RFOFhaEedalB" + }, + "source": [ + "## Setup and Initialization\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "Support for reading html files was introduced in Spark NLP 6.0.0. Please make sure you have upgraded to the latest Spark NLP release." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UYkjwyv7Qyt2" + }, + "source": [ + "- Let's install and setup Spark NLP in Google Colab\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "oRvzXqEFQyt3" + }, + "outputs": [], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3YoyZLVYQyt4" + }, + "source": [ + "For local files example we will download a couple of HTML files from Spark NLP Github repo:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ya8qZe00dalC", + "outputId": "8c76ad45-1102-4f7e-d18e-35df54b51265" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['--2025-03-06 17:00:19-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1103-Adding-support-to-read-PowerPoint-files/src/test/resources/reader/ppt/fake-power-point.pptx',\n", + " 'Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.111.133, ...',\n", + " 'Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.',\n", + " 'HTTP request sent, awaiting response... 200 OK',\n", + " 'Length: 38412 (38K) [application/octet-stream]',\n", + " 'Saving to: ‘power-point-files/fake-power-point.pptx’',\n", + " '',\n", + " '',\n", + " 'fake-power-point.pp 0%[ ] 0 --.-KB/s ',\n", + " 'fake-power-point.pp 100%[===================>] 37.51K --.-KB/s in 0.004s ',\n", + " '',\n", + " '2025-03-06 17:00:19 (9.90 MB/s) - ‘power-point-files/fake-power-point.pptx’ saved [38412/38412]',\n", + " '']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "!mkdir power-point-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/ppt/fake-power-point.pptx -P power-point-files" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EoFI66NAdalE" + }, + "source": [ + "## Parsing PowerPoint slides from Local Files\n", + "Use the `ppt()` method to parse Excel content from local directories." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bAkMjJ1vdalE", + "outputId": "d8391d2f-17b8-495d-bbba-03ef73db3bd2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+\n", + "| path| ppt|\n", + "+--------------------+--------------------+\n", + "|file:/content/pow...|[{Title, Adding a...|\n", + "+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "\n", + "ppt_df = sparknlp.read().ppt(\"./power-point-files\")\n", + "ppt_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VWbUgoVQrO8m", + "outputId": "faf985ce-92a3-4c4f-9827-70ce51081082" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- path: string (nullable = true)\n", + " |-- ppt: array (nullable = true)\n", + " | |-- element: struct (containsNull = true)\n", + " | | |-- elementType: string (nullable = true)\n", + " | | |-- content: string (nullable = true)\n", + " | | |-- metadata: map (nullable = true)\n", + " | | | |-- key: string\n", + " | | | |-- value: string (valueContainsNull = true)\n", + "\n" + ] + } + ], + "source": [ + "ppt_df.printSchema()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BB2FEfegGuxl" + }, + "source": [ + "You can also use DFS file systems like:\n", + "- Databricks: `dbfs://`\n", + "- HDFS: `hdfs://`\n", + "- Microsoft Fabric OneLake: `abfss://`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e9KEkKxERI_U" + }, + "source": [ + "### Configuration Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VLbJsw20ROAO" + }, + "source": [ + "- `storeContent`: By default, this is set to `false`. When enabled, the output will include the byte content of the file." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5ARg336ZROUc", + "outputId": "c26761ad-c3f2-41dd-d334-25c7f73a0726" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+--------------------+\n", + "| path| ppt| content|\n", + "+--------------------+--------------------+--------------------+\n", + "|file:/content/pow...|[{Title, Adding a...|[50 4B 03 04 14 0...|\n", + "+--------------------+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"storeContent\": \"true\"}\n", + "ppt_df = sparknlp.read(params).ppt(\"./power-point-files\")\n", + "ppt_df.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/reader/SparkNLP_TXT_Reader_Demo.ipynb b/examples/python/reader/SparkNLP_TXT_Reader_Demo.ipynb new file mode 100644 index 00000000000000..cad8c88b28a5f4 --- /dev/null +++ b/examples/python/reader/SparkNLP_TXT_Reader_Demo.ipynb @@ -0,0 +1,367 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "0o5UQ-Gy2Xvr" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/reader/SparkNLP_TXT_Reader_Demo.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "c0efed73-75e9-41f1-9a2e-a2d0953b3a76", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "tzcU5p2gdak9" + }, + "source": [ + "# Introducing TXT reader in SparkNLP\n", + "This notebook showcases the newly added `sparknlp.read().txt()` method in Spark NLP that parses txt file content from both local files and real-time URLs into a Spark DataFrame." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "356de93e-af38-4156-823b-6371d7fd825c", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "RFOFhaEedalB" + }, + "source": [ + "## Setup and Initialization\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "Support for reading html files was introduced in Spark NLP 6.0.0. Please make sure you have upgraded to the latest Spark NLP release.\n", + "\n", + "- Let's install and setup Spark NLP in Google Colab\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "xrWTskQJ2Xv5" + }, + "outputs": [], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9B98jlOn2Xv8" + }, + "source": [ + "For local files example we will download a TXT file from Spark NLP Github repo:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "bb622e88-2ef9-49c4-8cfb-e49209ad206a", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ya8qZe00dalC", + "outputId": "144186be-781d-451b-894e-d9c590a93c6a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mkdir: cannot create directory ‘txt-files’: File exists\n", + "--2025-03-07 00:33:21-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1113-Adding-support-to-enhance-read-TXT-files/src/test/resources/reader/txt/simple-text.txt\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.109.133, 185.199.111.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 300 [text/plain]\n", + "Saving to: ‘txt-files/simple-text.txt’\n", + "\n", + "simple-text.txt 100%[===================>] 300 --.-KB/s in 0s \n", + "\n", + "2025-03-07 00:33:21 (4.67 MB/s) - ‘txt-files/simple-text.txt’ saved [300/300]\n", + "\n" + ] + } + ], + "source": [ + "!mkdir txt-files\n", + "!wget https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/txt/simple-text.txt -P txt-files" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "13d72e9f-04b4-4547-bc4e-35b3878a93c2", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "id": "EoFI66NAdalE" + }, + "source": [ + "## Parsing text from Local Files\n", + "Use the `txt()` method to parse text file content from local directories." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "df54ed9b-682b-4b99-891a-84c23bc5cbd0", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bAkMjJ1vdalE", + "outputId": "74f0e218-6378-4df4-9b12-3ee6e33020e6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+\n", + "| path| txt|\n", + "+--------------------+--------------------+\n", + "|file:/content/txt...|[{Title, BIG DATA...|\n", + "+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "\n", + "txt_df = sparknlp.read().txt(\"./txt-files\")\n", + "txt_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "application/vnd.databricks.v1+cell": { + "cellMetadata": { + "byteLimit": 2048000, + "rowLimit": 10000 + }, + "inputWidgets": {}, + "nuid": "9f5c787d-2eab-4546-8001-e34f00124670", + "showTitle": false, + "tableResultSettingsMap": {}, + "title": "" + }, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4iky1gvEz7Pt", + "outputId": "ead23526-18be-4bb9-e952-38ef3d483cb0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|txt |\n", + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|[{Title, BIG DATA ANALYTICS, {paragraph -> 0}}, {NarrativeText, Apache Spark is a fast and general-purpose cluster computing system.\\nIt provides high-level APIs in Java, Scala, Python, and R., {paragraph -> 0}}, {Title, MACHINE LEARNING, {paragraph -> 1}}, {NarrativeText, Spark's MLlib provides scalable machine learning algorithms.\\nIt includes tools for classification, regression, clustering, and more., {paragraph -> 1}}]|\n", + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "txt_df.select(\"txt\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "brto-6NX2wLT" + }, + "source": [ + "You can also use DFS file systems like:\n", + "- Databricks: `dbfs://`\n", + "- HDFS: `hdfs://`\n", + "- Microsoft Fabric OneLake: `abfss://`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CYnoVMVD211Z" + }, + "source": [ + "### Configuration Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rJhyeem_3Gqh" + }, + "source": [ + "- `titleLengthSize`: You can customize the font size used to identify titles that should be treated as titles. By default, the font size is set to 50. However, if your text files require a different configuration, you can adjust this parameter accordingly. The example below demonstrates how to modify and work with this setting:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nLUtWTk-3jcT", + "outputId": "60d10ba0-cf91-4706-efb4-4e640d7e6bb0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|path |txt |\n", + "+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|file:/content/txt-files/simple-text.txt|[{NarrativeText, BIG DATA ANALYTICS, {paragraph -> 0}}, {NarrativeText, Apache Spark is a fast and general-purpose cluster computing system.\\nIt provides high-level APIs in Java, Scala, Python, and R., {paragraph -> 0}}, {NarrativeText, MACHINE LEARNING, {paragraph -> 1}}, {NarrativeText, Spark's MLlib provides scalable machine learning algorithms.\\nIt includes tools for classification, regression, clustering, and more., {paragraph -> 1}}]|\n", + "+---------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"titleLengthSize\": \"5\"}\n", + "txt_df = sparknlp.read(params).txt(\"./txt-files\")\n", + "txt_df.show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "d444S-MK239M" + }, + "source": [ + "- `storeContent`: By default, this is set to `false`. When enabled, the output will include the raw content of the file." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "optYF_SS22TW", + "outputId": "e21f8dab-ef69-432b-aa3e-fb0afc075bbb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+--------------------+\n", + "| path| txt| content|\n", + "+--------------------+--------------------+--------------------+\n", + "|file:/content/txt...|[{Title, BIG DATA...|BIG DATA ANALYTIC...|\n", + "+--------------------+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"storeContent\": \"true\"}\n", + "txt_df = sparknlp.read(params).txt(\"./txt-files\")\n", + "txt_df.show()" + ] + } + ], + "metadata": { + "application/vnd.databricks.v1+notebook": { + "computePreferences": null, + "dashboards": [], + "environmentMetadata": null, + "language": "python", + "notebookMetadata": { + "pythonIndentUnit": 4 + }, + "notebookName": "SparkNLP_TXT_Reader_Demo", + "widgets": {} + }, + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/reader/SparkNLP_Word_Reader_Demo.ipynb b/examples/python/reader/SparkNLP_Word_Reader_Demo.ipynb index 15f4f99a2ca33a..9593f30424aca0 100644 --- a/examples/python/reader/SparkNLP_Word_Reader_Demo.ipynb +++ b/examples/python/reader/SparkNLP_Word_Reader_Demo.ipynb @@ -2,7 +2,9 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "id": "fVCTDXvj23JY" + }, "source": [ "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", "\n", @@ -33,7 +35,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "id": "_lK9PBpd23Je" + }, "source": [ "- Let's install and setup Spark NLP in Google Colab\n", "- This part is pretty easy via our simple script" @@ -41,8 +45,10 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 1, + "metadata": { + "id": "diBT0PwL23Je" + }, "outputs": [], "source": [ "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" @@ -50,38 +56,42 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "id": "HWjx-reJ23Jf" + }, "source": [ "For local files example we will download a couple of Word files from Spark NLP Github repo:" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ya8qZe00dalC", - "outputId": "f6800bce-c101-47e3-8030-cf1a0b758183" + "outputId": "d4ac0a0d-edd7-4126-cf01-9ad5ed0500a3" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "--2024-12-11 02:43:35-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1094-Adding-support-to-read-Word-files-v2/src/test/resources/reader/doc/contains-pictures.docx\n", - "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.109.133, 185.199.108.133, ...\n", - "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n", + "--2025-03-06 00:33:05-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/doc/contains-pictures.docx\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.111.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 95087 (93K) [application/octet-stream]\n", "Saving to: ‘word-files/contains-pictures.docx’\n", "\n", - "contains-pictures.d 100%[===================>] 92.86K --.-KB/s in 0.04s \n", + "\r", + "contains-pictures.d 0%[ ] 0 --.-KB/s \r", + "contains-pictures.d 100%[===================>] 92.86K --.-KB/s in 0.02s \n", "\n", - "2024-12-11 02:43:35 (2.47 MB/s) - ‘word-files/contains-pictures.docx’ saved [95087/95087]\n", + "2025-03-06 00:33:06 (3.86 MB/s) - ‘word-files/contains-pictures.docx’ saved [95087/95087]\n", "\n", - "--2024-12-11 02:43:36-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/feature/SPARKNLP-1094-Adding-support-to-read-Word-files-v2/src/test/resources/reader/doc/fake_table.docx\n", + "--2025-03-06 00:33:06-- https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp/master/src/test/resources/reader/doc/fake_table.docx\n", "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.111.133, 185.199.110.133, ...\n", "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", @@ -90,7 +100,7 @@ "\n", "fake_table.docx 100%[===================>] 12.10K --.-KB/s in 0s \n", "\n", - "2024-12-11 02:43:36 (24.7 MB/s) - ‘word-files/fake_table.docx’ saved [12392/12392]\n", + "2025-03-06 00:33:06 (99.2 MB/s) - ‘word-files/fake_table.docx’ saved [12392/12392]\n", "\n" ] } @@ -103,13 +113,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "oZLpFt7qcWoC", - "outputId": "6e5ce0b8-383a-481c-9b7b-d4250d385f25" + "outputId": "4a0b4ef5-40e8-4020-e5f4-3a2002a0fc61" }, "outputs": [ { @@ -117,8 +127,8 @@ "output_type": "stream", "text": [ "total 112K\n", - "-rw-r--r-- 1 root root 93K Dec 11 02:43 contains-pictures.docx\n", - "-rw-r--r-- 1 root root 13K Dec 11 02:43 fake_table.docx\n" + "-rw-r--r-- 1 root root 93K Mar 6 00:33 contains-pictures.docx\n", + "-rw-r--r-- 1 root root 13K Mar 6 00:33 fake_table.docx\n" ] } ], @@ -138,13 +148,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "_3GKYbmScehR", - "outputId": "24941880-c772-4b4e-dd0d-349fe8ea31c9" + "outputId": "8a0cba04-4db8-4705-ccb4-4c7b8f74fc99" }, "outputs": [ { @@ -163,31 +173,31 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 16, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "eKOYqIigmlmh", - "outputId": "1a3ec3b7-b49d-420b-cdaf-e4682b4f66e1" + "outputId": "f437fcf7-247e-4fda-d8cf-855c7fd6e6c3" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "+--------------------+\n", - "| doc|\n", - "+--------------------+\n", - "|[{Table, Header C...|\n", - "|[{Header, An inli...|\n", - "+--------------------+\n", + "+--------------------+--------------------+\n", + "| path| doc|\n", + "+--------------------+--------------------+\n", + "|file:/content/wor...|[{Header, An inli...|\n", + "|file:/content/wor...|[{Table, Header C...|\n", + "+--------------------+--------------------+\n", "\n" ] } ], "source": [ - "doc_df.select(\"doc\").show()" + "doc_df.show()" ] }, { @@ -198,7 +208,7 @@ "base_uri": "https://localhost:8080/" }, "id": "IoC1eqPPcmqN", - "outputId": "b994396c-b670-49af-8bb9-b5e6ff44e8fe" + "outputId": "73acbe65-0844-446a-f59a-6549dddfdd47" }, "outputs": [ { @@ -207,7 +217,6 @@ "text": [ "root\n", " |-- path: string (nullable = true)\n", - " |-- content: binary (nullable = true)\n", " |-- doc: array (nullable = true)\n", " | |-- element: struct (containsNull = true)\n", " | | |-- elementType: string (nullable = true)\n", @@ -234,6 +243,56 @@ "- HDFS: `hdfs://`\n", "- Microsoft Fabric OneLake: `abfss://`" ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1DHIwRe13Ko7" + }, + "source": [ + "### Configuration Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FFnRYtys3Tv6" + }, + "source": [ + "- `storeContent`: By default, this is set to `false`. When enabled, the output will include the byte content of the file. This parameter was added in SparkNLP 6.0.0" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EY9qzmZu3NC8", + "outputId": "0d0916b1-b0ca-4c58-b723-dcad794cd3e3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning::Spark Session already created, some configs may not take.\n", + "+--------------------+--------------------+--------------------+\n", + "| path| doc| content|\n", + "+--------------------+--------------------+--------------------+\n", + "|file:/content/wor...|[{Header, An inli...|[50 4B 03 04 14 0...|\n", + "|file:/content/wor...|[{Table, Header C...|[50 4B 03 04 14 0...|\n", + "+--------------------+--------------------+--------------------+\n", + "\n" + ] + } + ], + "source": [ + "params = {\"storeContent\": \"true\"}\n", + "doc_df = sparknlp.read(params).doc(\"./word-files\")\n", + "doc_df.show()" + ] } ], "metadata": { diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_AlbertForMultipleChoice.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_AlbertForMultipleChoice.ipynb new file mode 100644 index 00000000000000..c17e5a0a3dc99b --- /dev/null +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_AlbertForMultipleChoice.ipynb @@ -0,0 +1,529 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "PAsu8UVGoLVf" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_AlbertForMultipleChoice.ipynb)\n", + "\n", + "## Import ONNX AlbertForMultipleChoice models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- ONNX support was introduced in `Spark NLP 5.0.0`, enabling high performance inference for models.\n", + "- `AlbertForMultipleChoice` is only available since in `Spark NLP 5.6.0` and after. So please make sure you have upgraded to the latest Spark NLP release\n", + "- You can import ALBERT models trained/fine-tuned for question answering via `AlbertForMultipleChoice` or `AlbertForMultipleChoice`. These models are usually under `Multiple Choice` category and have `bert` in their labels\n", + "- Reference: [AlbertForMultipleChoice](https://huggingface.co/docs/transformers/main/en/model_doc/albert#transformers.AlbertForMultipleChoice)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OzijcdtQpOx9" + }, + "source": [ + "## Export and Save HuggingFace model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MlgoClMXpSg4" + }, + "source": [ + "- Let's install `transformers` package with the `onnx` extension and it's dependencies. You don't need `onnx` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cJWbob-kHICU", + "outputId": "d05b0dac-d342-40b4-aafc-f8ebd52d97a7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m424.1/424.1 kB\u001b[0m \u001b[31m30.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m113.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m212.7/212.7 kB\u001b[0m \u001b[31m21.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m480.6/480.6 kB\u001b[0m \u001b[31m39.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m84.5/84.5 kB\u001b[0m \u001b[31m8.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m62.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m455.8/455.8 kB\u001b[0m \u001b[31m39.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m13.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.3/179.3 kB\u001b[0m \u001b[31m19.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m9.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m15.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m106.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.5/55.5 kB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m19.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\n", + "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install -q --upgrade transformers[onnx] optimum" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XtewR2xdOa5s" + }, + "source": [ + "- HuggingFace has an extension called Optimum which offers specialized model inference, including ONNX. We can use this to import and export ONNX models with `from_pretrained` and `save_pretrained`.\n", + "- We'll use the treained model above as an example and load it as a `ORTModelForMultipleChoice`, representing an ONNX model." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "87VKKCh1N-Ut" + }, + "outputs": [], + "source": [ + "!pip install -q --upgrade transformers[onnx] optimum" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "Id33annImYM8" + }, + "outputs": [], + "source": [ + "from optimum.onnxruntime import ORTModelForMultipleChoice\n", + "\n", + "MODEL_NAME = \"Ariffiq99/CRAB_COPA_KUCI_e_care_albert_Base_Finetuned\"\n", + "ONNX_MODEL_PATH = f\"onnx_models/albert_multiple_choice\"\n", + "\n", + "ort_model = ORTModelForMultipleChoice.from_pretrained(MODEL_NAME, export=True)\n", + "ort_model.save_pretrained(ONNX_MODEL_PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e1696tiVO51u" + }, + "source": [ + "Let's have a look inside these two directories and see what we are dealing with:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NFamGuT4OJC2", + "outputId": "724401e5-2d11-4c89-ba0b-d995e6276ba5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 48M\n", + "-rw-r--r-- 1 root root 871 Dec 27 19:03 config.json\n", + "-rw-r--r-- 1 root root 45M Dec 27 19:03 model.onnx\n", + "-rw-r--r-- 1 root root 970 Dec 27 19:03 special_tokens_map.json\n", + "-rw-r--r-- 1 root root 743K Dec 27 19:03 spiece.model\n", + "-rw-r--r-- 1 root root 1.5K Dec 27 19:03 tokenizer_config.json\n", + "-rw-r--r-- 1 root root 2.2M Dec 27 19:03 tokenizer.json\n" + ] + } + ], + "source": [ + "!ls -lh {ONNX_MODEL_PATH}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "THEhUhYRO6-y" + }, + "source": [ + "We need the `spiece.model` for the Tokenizer. This is the same for every model, these are assets (saved in /assets) needed for tokenization inside Spark NLP." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "N_-ljjz1PVLD" + }, + "outputs": [], + "source": [ + "!mkdir {ONNX_MODEL_PATH}/assets" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "MI0KJCcJPjoX" + }, + "outputs": [], + "source": [ + "!mv {ONNX_MODEL_PATH}/spiece.model {ONNX_MODEL_PATH}/assets/" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rOT64bl9Ppk-" + }, + "source": [ + "Voila! We have our vocab.txt inside assets directory" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1BcINpaqPmgQ", + "outputId": "a705bff5-f98d-405b-dcea-0449b0383d27" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "onnx_models/albert_multiple_choice:\n", + "total 48312\n", + "drwxr-xr-x 2 root root 4096 Dec 27 19:04 assets\n", + "-rw-r--r-- 1 root root 871 Dec 27 19:03 config.json\n", + "-rw-r--r-- 1 root root 47180962 Dec 27 19:03 model.onnx\n", + "-rw-r--r-- 1 root root 970 Dec 27 19:03 special_tokens_map.json\n", + "-rw-r--r-- 1 root root 1442 Dec 27 19:03 tokenizer_config.json\n", + "-rw-r--r-- 1 root root 2272611 Dec 27 19:03 tokenizer.json\n", + "\n", + "onnx_models/albert_multiple_choice/assets:\n", + "total 744\n", + "-rw-r--r-- 1 root root 760289 Dec 27 19:03 spiece.model\n" + ] + } + ], + "source": [ + "!ls -lR {ONNX_MODEL_PATH}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3rgd1jHMRC7q" + }, + "source": [ + "## Import and Save AlbertForMultipleChoice in Spark NLP" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N0dY2lHcRG5t" + }, + "source": [ + "- Let's install and setup Spark NLP in Google Colab\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9ld2osF6STCv" + }, + "outputs": [], + "source": [ + "!wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "u1kTC9LQRHbg", + "outputId": "6add9710-c8ee-4323-9944-960ff9fcfd65" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Apache Spark version: 3.5.3\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "# let's start Spark with Spark NLP\n", + "spark = sparknlp.start()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h3lTxyr-R9LH" + }, + "source": [ + "- Let's use `loadSavedModel` functon in `AlbertForMultipleChoice` which allows us to load TensorFlow model in SavedModel format\n", + "- Most params can be set later when you are loading this model in `AlbertForMultipleChoice` in runtime like `setMaxSentenceLength`, so don't worry what you are setting them now\n", + "- `loadSavedModel` accepts two params, first is the path to the TF SavedModel. The second is the SparkSession that is `spark` variable we previously started via `sparknlp.start()`\n", + "- NOTE: `loadSavedModel` accepts local paths in addition to distributed file systems such as `HDFS`, `S3`, `DBFS`, etc. This feature was introduced in Spark NLP 4.2.2 release. Keep in mind the best and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "6O6v4t3HSFRU" + }, + "outputs": [], + "source": [ + "from sparknlp.annotator import *\n", + "from sparknlp.base import *\n", + "\n", + "\n", + "albertMultpleChoiceClassifier = AlbertForMultipleChoice.loadSavedModel(\n", + " f\"{ONNX_MODEL_PATH}\",\n", + " spark\n", + " )\\\n", + " .setInputCols([\"document_question\", \"document_context\"])\\\n", + " .setOutputCol(\"answer\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OmxG3UynSxFf" + }, + "source": [ + "Let's save it on disk so it is easier to be moved around and also be used later via .load function" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "dl9v_UCISfbJ" + }, + "outputs": [], + "source": [ + "albertMultpleChoiceClassifier.write().overwrite().save(\"./{}_spark_nlp_onnx\".format(MODEL_NAME))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YPSFjBLuS2Lk" + }, + "source": [ + "Let's clean up stuff we don't need anymore" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "id": "spbp5G5sS2lR" + }, + "outputs": [], + "source": [ + "!rm -rf {ONNX_MODEL_PATH}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LxK9WcnJS_XC" + }, + "source": [ + "Now let's see how we can use it on other machines, clusters, or any place you wish to use your new and shiny `AlbertForMultipleChoice` model in Spark NLP 🚀 pipeline!" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "id": "Gs3VQBACg8jm" + }, + "outputs": [], + "source": [ + " testing_data = [\n", + " (\"In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.\",\n", + " \"It is eaten with a fork and a knife, It is eaten while held in the hand.\"),\n", + "\n", + " (\"The Eiffel Tower is located in which country?\",\n", + " \"Germany, France, Italy\"),\n", + "\n", + " (\"Which animal is known as the king of the jungle?\",\n", + " \"Lion, Elephant, Tiger, Leopard\"),\n", + "\n", + " (\"Water boils at what temperature?\",\n", + " \"90°C, 120°C, 100°C\"),\n", + "\n", + " (\"Which planet is known as the Red Planet?\",\n", + " \"Jupiter, Mars, Venus\"),\n", + "\n", + " (\"Which language is primarily spoken in Brazil?\",\n", + " \"Spanish, Portuguese, English\"),\n", + "\n", + " (\"The Great Wall of China was built to protect against invasions from which group?\",\n", + " \"The Greeks, The Romans, The Mongols, The Persians\"),\n", + "\n", + " (\"Which chemical element has the symbol 'O'?\",\n", + " \"Oxygenm, Osmium, Ozone\"),\n", + "\n", + " (\"Which continent is the Sahara Desert located in?\",\n", + " \"Asia, Africa, South America\"),\n", + "\n", + " (\"Which artist painted the Mona Lisa?\",\n", + " \"Vincent van Gogh, Leonardo da Vinci, Pablo Picasso\")\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wQ-hmCBSPCsU", + "outputId": "929d3ea1-193c-409a-eb00-8ada21e3b18f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------------------------------------------+------------------------------------------------------------------------+\n", + "|question |choices |\n", + "+------------------------------------------------------------------------------------------+------------------------------------------------------------------------+\n", + "|In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.|It is eaten with a fork and a knife, It is eaten while held in the hand.|\n", + "|The Eiffel Tower is located in which country? |Germany, France, Italy |\n", + "|Which animal is known as the king of the jungle? |Lion, Elephant, Tiger, Leopard |\n", + "|Water boils at what temperature? |90°C, 120°C, 100°C |\n", + "|Which planet is known as the Red Planet? |Jupiter, Mars, Venus |\n", + "|Which language is primarily spoken in Brazil? |Spanish, Portuguese, English |\n", + "|The Great Wall of China was built to protect against invasions from which group? |The Greeks, The Romans, The Mongols, The Persians |\n", + "|Which chemical element has the symbol 'O'? |Oxygenm, Osmium, Ozone |\n", + "|Which continent is the Sahara Desert located in? |Asia, Africa, South America |\n", + "|Which artist painted the Mona Lisa? |Vincent van Gogh, Leonardo da Vinci, Pablo Picasso |\n", + "+------------------------------------------------------------------------------------------+------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "testing_df = spark.createDataFrame(testing_data, [\"question\", \"choices\"])\n", + "testing_df.show(truncate=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8IX6B1rHTNwt", + "outputId": "b5d5d8b1-5d3e-42e2-b219-9dc6cd80017d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------------------------------------------------------------------------------------------------------+\n", + "|answer |\n", + "+------------------------------------------------------------------------------------------------------------+\n", + "|[{chunk, 0, 35, It is eaten while held in the hand., {sentence -> 0, chunk -> 0, score -> 0.55574197}, []}]|\n", + "|[{chunk, 0, 5, Italy, {sentence -> 0, chunk -> 0, score -> 0.3497405}, []}] |\n", + "|[{chunk, 0, 8, Elephant, {sentence -> 0, chunk -> 0, score -> 0.28558698}, []}] |\n", + "|[{chunk, 0, 5, 100°C, {sentence -> 0, chunk -> 0, score -> 0.34499714}, []}] |\n", + "|[{chunk, 0, 4, Mars, {sentence -> 0, chunk -> 0, score -> 0.3803456}, []}] |\n", + "|[{chunk, 0, 10, Portuguese, {sentence -> 0, chunk -> 0, score -> 0.36515844}, []}] |\n", + "|[{chunk, 0, 11, The Mongols, {sentence -> 0, chunk -> 0, score -> 0.2663425}, []}] |\n", + "|[{chunk, 0, 6, Osmium, {sentence -> 0, chunk -> 0, score -> 0.35382026}, []}] |\n", + "|[{chunk, 0, 13, South America, {sentence -> 0, chunk -> 0, score -> 0.38049418}, []}] |\n", + "|[{chunk, 0, 13, Pablo Picasso, {sentence -> 0, chunk -> 0, score -> 0.3762705}, []}] |\n", + "+------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "document_assembler = MultiDocumentAssembler() \\\n", + " .setInputCols([\"question\", \"choices\"]) \\\n", + " .setOutputCols([\"document_question\", \"document_choices\"])\n", + "\n", + "albert_for_multiple_choice = AlbertForMultipleChoice() \\\n", + " .load(\"./{}_spark_nlp_onnx\".format(MODEL_NAME)) \\\n", + " .setInputCols([\"document_question\", \"document_choices\"])\\\n", + " .setOutputCol(\"answer\") \\\n", + " .setBatchSize(4)\n", + "\n", + "pipeline = Pipeline(stages=[document_assembler, albert_for_multiple_choice])\n", + "pipeline_model = pipeline.fit(testing_df)\n", + "\n", + "pipeline_df = pipeline_model.transform(testing_df)\n", + "\n", + "pipeline_df.select(\"answer\").show(truncate=False)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_BertForMultipleChoice.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_BertForMultipleChoice.ipynb index 7503cfd9f8b000..b6faed087c98ea 100644 --- a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_BertForMultipleChoice.ipynb +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_BertForMultipleChoice.ipynb @@ -91,30 +91,6 @@ "- We'll use the treained model above as an example and load it as a `ORTModelForMultipleChoice`, representing an ONNX model." ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "avTe8Oe5N-vw", - "outputId": "270cf088-de9d-4dd2-d0cf-56daba62e141" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n" - ] - } - ], - "source": [ - "from google.colab import drive\n", - "drive.mount('/content/drive')" - ] - }, { "cell_type": "code", "execution_count": 5, @@ -446,51 +422,11 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "al3szq-HRy2s", - "outputId": "a08dc94b-614a-44f8-daf1-98149d057011" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: pyspark in /usr/local/lib/python3.10/dist-packages (3.5.3)\n", - "Requirement already satisfied: py4j==0.10.9.7 in /usr/local/lib/python3.10/dist-packages (from pyspark) (0.10.9.7)\n" - ] - } - ], - "source": [ - "!pip install pyspark" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "9ld2osF6STCv", - "outputId": "ad4bd7ce-b2f9-406c-bc47-63a18f8b1ee6" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing ./spark_nlp-5.5.0-py2.py3-none-any.whl\n", - "Installing collected packages: spark-nlp\n", - "Successfully installed spark-nlp-5.5.0\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "!pip install spark_nlp-5.5.0-py2.py3-none-any.whl" + "!wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" ] }, { diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_DistilBertForMultipleChoice.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_DistilBertForMultipleChoice.ipynb new file mode 100644 index 00000000000000..d3ff42a5bec59c --- /dev/null +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_DistilBertForMultipleChoice.ipynb @@ -0,0 +1,2751 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "PAsu8UVGoLVf" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_DistilBertForMultipleChoice.ipynb)\n", + "\n", + "## Import ONNX DistilBertForMultipleChoice models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- ONNX support was introduced in `Spark NLP 5.0.0`, enabling high performance inference for models.\n", + "- `DistilBertForMultipleChoice` is only available since in `Spark NLP 5.6.0` and after. So please make sure you have upgraded to the latest Spark NLP release\n", + "- You can import BERT models trained/fine-tuned for question answering via `DistilBertForMultipleChoice` or `TFDistilBertForMultipleChoice`. These models are usually under `Multiple Choice` category and have `bert` in their labels\n", + "- Reference: [DistilBertForMultipleChoice](https://huggingface.co/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForMultipleChoice)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OzijcdtQpOx9" + }, + "source": [ + "## Export and Save HuggingFace model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MlgoClMXpSg4" + }, + "source": [ + "- Let's install `transformers` package with the `onnx` extension and it's dependencies. You don't need `onnx` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cJWbob-kHICU", + "outputId": "b9a93019-f7a9-4f13-d727-502e8806d75c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/424.1 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m419.8/424.1 kB\u001b[0m \u001b[31m13.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m424.1/424.1 kB\u001b[0m \u001b[31m10.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/13.3 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.1/13.3 MB\u001b[0m \u001b[31m124.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━\u001b[0m \u001b[32m11.4/13.3 MB\u001b[0m \u001b[31m183.8 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m195.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m110.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/212.7 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m212.7/212.7 kB\u001b[0m \u001b[31m20.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m4.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m480.6/480.6 kB\u001b[0m \u001b[31m42.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m84.5/84.5 kB\u001b[0m \u001b[31m9.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m65.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m455.8/455.8 kB\u001b[0m \u001b[31m38.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m11.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.3/179.3 kB\u001b[0m \u001b[31m18.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m9.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m14.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m102.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.5/55.5 kB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m21.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\n", + "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install -q --upgrade transformers[onnx] optimum" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XtewR2xdOa5s" + }, + "source": [ + "- HuggingFace has an extension called Optimum which offers specialized model inference, including ONNX. We can use this to import and export ONNX models with `from_pretrained` and `save_pretrained`.\n", + "- We'll use the treained model above as an example and load it as a `ORTModelForMultipleChoice`, representing an ONNX model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 313, + "referenced_widgets": [ + "3fa8c62ddf034288bbe3c585e481582a", + "b942bc8a478b40c18b3afeb2ef549b82", + "74b1760ba60d4217be2b0a0540f9dc22", + "e6bd749383ad44c49d7d2555ed8f773a", + "35e316e7eedc4829a1c421b87e25cc6b", + "d10a939a7c294d51ac0970c1e6e67400", + "c501f85ca9104291b32766594abfb177", + "35c33ddbb5e64f2eaad2cf22bd2b312e", + "8e1edff76eb74812a4a57d8f9a7c66a5", + "f76dd41f539a42d883ea85d6fc249381", + "dc07286d1da74c1b8c80edf7b22ec105", + "5c1e19066ac2428f892903b335136e05", + "41bfa9e47892418981d2105b727c6651", + "10177825cf9746fe8f142462f7723aef", + "be47affd0e774f038ba4b935a7dc0fda", + "115e14b1a23046f6bde91b91368110cd", + "4c1c4ff45bdc4658b11d783c67d08f79", + "367b13b5545a4c65a5d8a827720271f6", + "895587a2608a49e7ad3d6132abb3a833", + "8a3001347f6e47afac38e3fa860a7aee", + "341bc46cd55148759af3deb3ad08a816", + "0ae4ff0010404177ae68147ac49ea7e6", + "2f44f043a48c4b79a08c8b8fab68be5c", + "b01be358bde44be1b233b147dfaaf9ad", + "b4e498dbede94fa49d93372f238b4966", + "c05e109ef7344f92a1fb33cd3d6b45e2", + "5bef47b4061f4d638796c17779e780dc", + "45757698c34b4db9ac25e7257cd15435", + "0c3da599f3304566920f6002e90a6961", + "d36768137ea04899b36b79c738a13fa6", + "2f9901d1aaf14f2c9bbed14e85e58ca1", + "19b1c94ebf85413da435ce89cad2d666", + "b851e1cbb82f446bb6a275afed0cc3b1", + "1e5cbd2c3f46415fbbc0ce27f4c48ce9", + "65331501cffe49428c3ee28e43432b74", + "1a9b4a12cc9443059cb57a411d1c2637", + "455d7eadeb44420a883b2066628640d8", + "b39e0fb3fbf44cba8fab21ddfac7a2cc", + "bdb846fc731e487ca1a72f55d7aa8d6e", + "9dca665841224956be77804fe1f90391", + "f23cd3265e034825b8cd3dd2d393d421", + "4c958a2b95b944c7829a9d2bc0cb77ac", + "9388c8035d2c47e08ab99040dcd00cf9", + "62f926c3d9f9461596521ba34e795b3a", + "d7b0df281fcb4e95abc2ac1f33503fb2", + "11fce16817ab484f953b590045ed3d5c", + "005cdb63a2ef454f8c7f401ec377e2df", + "a5d4aa7482434d43b0d856558d27664c", + "c8d906a71eb24d83bb823bac76af29cc", + "7d6ebb345cba4bcab22f9d1f7261d5c8", + "f4942df43b0d42e8ade2b3a953e76c86", + "1fb6829e34664a0cb82c56616160a4a7", + "4e3c9f8eb4964535a1ae416600f57e93", + "540d3b239d76402d8495be7e23351f07", + "fd869a4e8ec5472aa15916213b60f1cb", + "49307ab4126b42618a7c16fa81c22117", + "9a99cd70f2ff4e41ba7e60ea0142d45b", + "ab3833fcf88747c69da9c98ca60b3443", + "67bff7bbad194bef948cb8dfd985cd1b", + "6999f459998a4032ad29f074d5134847", + "cb1bef115ba54c549acc1056c3149ebd", + "3826c29474704eca93ed9a7d97865909", + "2999fb3ce9b041839ff03250080f0501", + "09369dd140294679ac321835d8a085e2", + "176a27c38a96473c8603b69e4009daf8", + "15a0cd6793ef4c4dbcbada0adada95a9" + ] + }, + "id": "Id33annImYM8", + "outputId": "a195cc94-133d-4705-cb1f-a3cd12fff670" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n", + "The secret `HF_TOKEN` does not exist in your Colab secrets.\n", + "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n", + "You will be able to reuse this secret in all of your notebooks.\n", + "Please note that authentication is recommended but still optional to access public models or datasets.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3fa8c62ddf034288bbe3c585e481582a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "config.json: 0%| | 0.00/574 [00:00 0, chunk -> 0, score -> 0.6048505}, []}]|\n", + "|[{chunk, 0, 6, Germany, {sentence -> 0, chunk -> 0, score -> 0.39137164}, []}] |\n", + "|[{chunk, 0, 5, Tiger, {sentence -> 0, chunk -> 0, score -> 0.2897997}, []}] |\n", + "|[{chunk, 0, 3, 90°C, {sentence -> 0, chunk -> 0, score -> 0.35916787}, []}] |\n", + "|[{chunk, 0, 6, Jupiter, {sentence -> 0, chunk -> 0, score -> 0.35939977}, []}] |\n", + "|[{chunk, 0, 7, English, {sentence -> 0, chunk -> 0, score -> 0.3640033}, []}] |\n", + "|[{chunk, 0, 11, The Mongols, {sentence -> 0, chunk -> 0, score -> 0.29171145}, []}] |\n", + "|[{chunk, 0, 6, Osmium, {sentence -> 0, chunk -> 0, score -> 0.4062368}, []}] |\n", + "|[{chunk, 0, 13, South America, {sentence -> 0, chunk -> 0, score -> 0.392063}, []}] |\n", + "|[{chunk, 0, 13, Pablo Picasso, {sentence -> 0, chunk -> 0, score -> 0.4129128}, []}] |\n", + "+----------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "document_assembler = MultiDocumentAssembler() \\\n", + " .setInputCols([\"question\", \"choices\"]) \\\n", + " .setOutputCols([\"document_question\", \"document_choices\"])\n", + "\n", + "distilbert_for_multiple_choice = DistilBertForMultipleChoice() \\\n", + " .load(\"./{}_spark_nlp_onnx\".format(MODEL_NAME)) \\\n", + " .setInputCols([\"document_question\", \"document_choices\"])\\\n", + " .setOutputCol(\"answer\") \\\n", + " .setBatchSize(4)\n", + "\n", + "pipeline = Pipeline(stages=[document_assembler, distilbert_for_multiple_choice])\n", + "pipeline_model = pipeline.fit(testing_df)\n", + "\n", + "pipeline_df = pipeline_model.transform(testing_df)\n", + "\n", + "pipeline_df.select(\"answer\").show(truncate=False)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "005cdb63a2ef454f8c7f401ec377e2df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1fb6829e34664a0cb82c56616160a4a7", + "max": 711396, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4e3c9f8eb4964535a1ae416600f57e93", + "value": 711396 + } + }, + "09369dd140294679ac321835d8a085e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0ae4ff0010404177ae68147ac49ea7e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0c3da599f3304566920f6002e90a6961": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "10177825cf9746fe8f142462f7723aef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_895587a2608a49e7ad3d6132abb3a833", + "max": 267829484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8a3001347f6e47afac38e3fa860a7aee", + "value": 267829484 + } + }, + "115e14b1a23046f6bde91b91368110cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "11fce16817ab484f953b590045ed3d5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7d6ebb345cba4bcab22f9d1f7261d5c8", + "placeholder": "​", + "style": "IPY_MODEL_f4942df43b0d42e8ade2b3a953e76c86", + "value": "tokenizer.json: 100%" + } + }, + "15a0cd6793ef4c4dbcbada0adada95a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "176a27c38a96473c8603b69e4009daf8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "19b1c94ebf85413da435ce89cad2d666": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1a9b4a12cc9443059cb57a411d1c2637": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f23cd3265e034825b8cd3dd2d393d421", + "max": 231508, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4c958a2b95b944c7829a9d2bc0cb77ac", + "value": 231508 + } + }, + "1e5cbd2c3f46415fbbc0ce27f4c48ce9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_65331501cffe49428c3ee28e43432b74", + "IPY_MODEL_1a9b4a12cc9443059cb57a411d1c2637", + "IPY_MODEL_455d7eadeb44420a883b2066628640d8" + ], + "layout": "IPY_MODEL_b39e0fb3fbf44cba8fab21ddfac7a2cc" + } + }, + "1fb6829e34664a0cb82c56616160a4a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2999fb3ce9b041839ff03250080f0501": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f44f043a48c4b79a08c8b8fab68be5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b01be358bde44be1b233b147dfaaf9ad", + "IPY_MODEL_b4e498dbede94fa49d93372f238b4966", + "IPY_MODEL_c05e109ef7344f92a1fb33cd3d6b45e2" + ], + "layout": "IPY_MODEL_5bef47b4061f4d638796c17779e780dc" + } + }, + "2f9901d1aaf14f2c9bbed14e85e58ca1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "341bc46cd55148759af3deb3ad08a816": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35c33ddbb5e64f2eaad2cf22bd2b312e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35e316e7eedc4829a1c421b87e25cc6b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "367b13b5545a4c65a5d8a827720271f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3826c29474704eca93ed9a7d97865909": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3fa8c62ddf034288bbe3c585e481582a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b942bc8a478b40c18b3afeb2ef549b82", + "IPY_MODEL_74b1760ba60d4217be2b0a0540f9dc22", + "IPY_MODEL_e6bd749383ad44c49d7d2555ed8f773a" + ], + "layout": "IPY_MODEL_35e316e7eedc4829a1c421b87e25cc6b" + } + }, + "41bfa9e47892418981d2105b727c6651": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c1c4ff45bdc4658b11d783c67d08f79", + "placeholder": "​", + "style": "IPY_MODEL_367b13b5545a4c65a5d8a827720271f6", + "value": "model.safetensors: 100%" + } + }, + "455d7eadeb44420a883b2066628640d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9388c8035d2c47e08ab99040dcd00cf9", + "placeholder": "​", + "style": "IPY_MODEL_62f926c3d9f9461596521ba34e795b3a", + "value": " 232k/232k [00:00<00:00, 2.56MB/s]" + } + }, + "45757698c34b4db9ac25e7257cd15435": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "49307ab4126b42618a7c16fa81c22117": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9a99cd70f2ff4e41ba7e60ea0142d45b", + "IPY_MODEL_ab3833fcf88747c69da9c98ca60b3443", + "IPY_MODEL_67bff7bbad194bef948cb8dfd985cd1b" + ], + "layout": "IPY_MODEL_6999f459998a4032ad29f074d5134847" + } + }, + "4c1c4ff45bdc4658b11d783c67d08f79": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c958a2b95b944c7829a9d2bc0cb77ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4e3c9f8eb4964535a1ae416600f57e93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "540d3b239d76402d8495be7e23351f07": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5bef47b4061f4d638796c17779e780dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c1e19066ac2428f892903b335136e05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_41bfa9e47892418981d2105b727c6651", + "IPY_MODEL_10177825cf9746fe8f142462f7723aef", + "IPY_MODEL_be47affd0e774f038ba4b935a7dc0fda" + ], + "layout": "IPY_MODEL_115e14b1a23046f6bde91b91368110cd" + } + }, + "62f926c3d9f9461596521ba34e795b3a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "65331501cffe49428c3ee28e43432b74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bdb846fc731e487ca1a72f55d7aa8d6e", + "placeholder": "​", + "style": "IPY_MODEL_9dca665841224956be77804fe1f90391", + "value": "vocab.txt: 100%" + } + }, + "67bff7bbad194bef948cb8dfd985cd1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_176a27c38a96473c8603b69e4009daf8", + "placeholder": "​", + "style": "IPY_MODEL_15a0cd6793ef4c4dbcbada0adada95a9", + "value": " 125/125 [00:00<00:00, 10.1kB/s]" + } + }, + "6999f459998a4032ad29f074d5134847": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74b1760ba60d4217be2b0a0540f9dc22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35c33ddbb5e64f2eaad2cf22bd2b312e", + "max": 574, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8e1edff76eb74812a4a57d8f9a7c66a5", + "value": 574 + } + }, + "7d6ebb345cba4bcab22f9d1f7261d5c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "895587a2608a49e7ad3d6132abb3a833": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a3001347f6e47afac38e3fa860a7aee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8e1edff76eb74812a4a57d8f9a7c66a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9388c8035d2c47e08ab99040dcd00cf9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a99cd70f2ff4e41ba7e60ea0142d45b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb1bef115ba54c549acc1056c3149ebd", + "placeholder": "​", + "style": "IPY_MODEL_3826c29474704eca93ed9a7d97865909", + "value": "special_tokens_map.json: 100%" + } + }, + "9dca665841224956be77804fe1f90391": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a5d4aa7482434d43b0d856558d27664c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_540d3b239d76402d8495be7e23351f07", + "placeholder": "​", + "style": "IPY_MODEL_fd869a4e8ec5472aa15916213b60f1cb", + "value": " 711k/711k [00:00<00:00, 15.3MB/s]" + } + }, + "ab3833fcf88747c69da9c98ca60b3443": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2999fb3ce9b041839ff03250080f0501", + "max": 125, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_09369dd140294679ac321835d8a085e2", + "value": 125 + } + }, + "b01be358bde44be1b233b147dfaaf9ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_45757698c34b4db9ac25e7257cd15435", + "placeholder": "​", + "style": "IPY_MODEL_0c3da599f3304566920f6002e90a6961", + "value": "tokenizer_config.json: 100%" + } + }, + "b39e0fb3fbf44cba8fab21ddfac7a2cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b4e498dbede94fa49d93372f238b4966": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d36768137ea04899b36b79c738a13fa6", + "max": 1224, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2f9901d1aaf14f2c9bbed14e85e58ca1", + "value": 1224 + } + }, + "b851e1cbb82f446bb6a275afed0cc3b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b942bc8a478b40c18b3afeb2ef549b82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d10a939a7c294d51ac0970c1e6e67400", + "placeholder": "​", + "style": "IPY_MODEL_c501f85ca9104291b32766594abfb177", + "value": "config.json: 100%" + } + }, + "bdb846fc731e487ca1a72f55d7aa8d6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be47affd0e774f038ba4b935a7dc0fda": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_341bc46cd55148759af3deb3ad08a816", + "placeholder": "​", + "style": "IPY_MODEL_0ae4ff0010404177ae68147ac49ea7e6", + "value": " 268M/268M [00:06<00:00, 42.6MB/s]" + } + }, + "c05e109ef7344f92a1fb33cd3d6b45e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_19b1c94ebf85413da435ce89cad2d666", + "placeholder": "​", + "style": "IPY_MODEL_b851e1cbb82f446bb6a275afed0cc3b1", + "value": " 1.22k/1.22k [00:00<00:00, 99.0kB/s]" + } + }, + "c501f85ca9104291b32766594abfb177": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c8d906a71eb24d83bb823bac76af29cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb1bef115ba54c549acc1056c3149ebd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d10a939a7c294d51ac0970c1e6e67400": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d36768137ea04899b36b79c738a13fa6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7b0df281fcb4e95abc2ac1f33503fb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_11fce16817ab484f953b590045ed3d5c", + "IPY_MODEL_005cdb63a2ef454f8c7f401ec377e2df", + "IPY_MODEL_a5d4aa7482434d43b0d856558d27664c" + ], + "layout": "IPY_MODEL_c8d906a71eb24d83bb823bac76af29cc" + } + }, + "dc07286d1da74c1b8c80edf7b22ec105": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e6bd749383ad44c49d7d2555ed8f773a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f76dd41f539a42d883ea85d6fc249381", + "placeholder": "​", + "style": "IPY_MODEL_dc07286d1da74c1b8c80edf7b22ec105", + "value": " 574/574 [00:00<00:00, 48.8kB/s]" + } + }, + "f23cd3265e034825b8cd3dd2d393d421": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f4942df43b0d42e8ade2b3a953e76c86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f76dd41f539a42d883ea85d6fc249381": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd869a4e8ec5472aa15916213b60f1cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_MPNetForQuestionAnswering.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_MPNetForQuestionAnswering.ipynb index cd4835de6d3325..75b4a28a439e73 100644 --- a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_MPNetForQuestionAnswering.ipynb +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_MPNetForQuestionAnswering.ipynb @@ -378,10 +378,10 @@ "colab": { "provenance": [] }, - "kernelspec": ,{ + "kernelspec": { "display_name": "Python 3", "name": "python3" - } + }, "language_info": { "codemirror_mode": { "name": "ipython", diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_OLMO.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_OLMO.ipynb new file mode 100644 index 00000000000000..dd2d0b08b4f8f7 --- /dev/null +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_OLMO.ipynb @@ -0,0 +1,1217 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "GB-OotnsS-JG" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_OLMO.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gRuRMH7QS-JI" + }, + "source": [ + "## Import ONNX OLMO models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- ONNX support was introduced in `Spark NLP 5.0.0`, enabling high performance inference for models.\n", + "- You can import OLMO models via `OLMOModel`. These models are usually under `Text2Text Generation` category and have `OLMO` in their labels\n", + "- This is a very computationally expensive module especially on larger sequence. The use of an accelerator such as GPU is recommended.\n", + "- Reference: [OLMOModel](https://huggingface.co/docs/transformers/en/model_doc/OLMO)\n", + "- Some [example models](https://huggingface.co/models?other=OLMO)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Vd98DUZxS-JJ" + }, + "source": [ + "## Export and Save HuggingFace model\n", + "\n", + "- Let's install `transformers` package with the `onnx` extension and it's dependencies. You don't need `onnx` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n", + "- We lock `transformers` on version `4.41.0`. This doesn't mean it won't work with the future releases\n", + "- We will also need `sentencepiece` for tokenization." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "wFf3GagOS-JJ", + "outputId": "78b6529d-afad-414c-baa3-e8087061072f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: optimum in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (1.24.0)\n", + "Requirement already satisfied: sentencepiece in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (0.2.0)\n", + "Requirement already satisfied: onnx in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (1.17.0)\n", + "Requirement already satisfied: onnxruntime in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (1.19.2)\n", + "Collecting ai2-olmo\n", + " Downloading ai2_olmo-0.6.0-py3-none-any.whl.metadata (25 kB)\n", + "Requirement already satisfied: transformers>=4.29 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from optimum) (4.41.0)\n", + "Requirement already satisfied: torch>=1.11 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from optimum) (2.6.0)\n", + "Requirement already satisfied: packaging in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from optimum) (24.2)\n", + "Requirement already satisfied: numpy in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from optimum) (2.0.2)\n", + "Requirement already satisfied: huggingface-hub>=0.8.0 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from optimum) (0.28.1)\n", + "Requirement already satisfied: protobuf>=3.20.2 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from onnx) (3.20.2)\n", + "Requirement already satisfied: coloredlogs in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from onnxruntime) (15.0.1)\n", + "Requirement already satisfied: flatbuffers in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from onnxruntime) (25.2.10)\n", + "Requirement already satisfied: sympy in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from onnxruntime) (1.13.1)\n", + "Collecting numpy (from optimum)\n", + " Using cached numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n", + "Collecting ai2-olmo-core==0.1.0 (from ai2-olmo)\n", + " Downloading ai2_olmo_core-0.1.0-py3-none-any.whl.metadata (14 kB)\n", + "Collecting omegaconf (from ai2-olmo)\n", + " Using cached omegaconf-2.3.0-py3-none-any.whl.metadata (3.9 kB)\n", + "Collecting rich (from ai2-olmo)\n", + " Downloading rich-13.9.4-py3-none-any.whl.metadata (18 kB)\n", + "Collecting boto3 (from ai2-olmo)\n", + " Downloading boto3-1.36.18-py3-none-any.whl.metadata (6.7 kB)\n", + "Collecting google-cloud-storage (from ai2-olmo)\n", + " Downloading google_cloud_storage-3.0.0-py2.py3-none-any.whl.metadata (12 kB)\n", + "Requirement already satisfied: tokenizers in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from ai2-olmo) (0.19.1)\n", + "Collecting cached_path>=1.6.2 (from ai2-olmo)\n", + " Downloading cached_path-1.6.7-py3-none-any.whl.metadata (19 kB)\n", + "Collecting importlib_resources (from ai2-olmo)\n", + " Downloading importlib_resources-6.5.2-py3-none-any.whl.metadata (3.9 kB)\n", + "Requirement already satisfied: safetensors in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from ai2-olmo-core==0.1.0->ai2-olmo) (0.5.2)\n", + "Collecting pydantic<3.0,>=2.0 (from ai2-olmo-core==0.1.0->ai2-olmo)\n", + " Downloading pydantic-2.10.6-py3-none-any.whl.metadata (30 kB)\n", + "Requirement already satisfied: requests in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from ai2-olmo-core==0.1.0->ai2-olmo) (2.32.3)\n", + "Requirement already satisfied: filelock<4.0,>=3.4 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from cached_path>=1.6.2->ai2-olmo) (3.17.0)\n", + "Collecting google-cloud-storage (from ai2-olmo)\n", + " Downloading google_cloud_storage-2.19.0-py2.py3-none-any.whl.metadata (9.1 kB)\n", + "Collecting huggingface-hub>=0.8.0 (from optimum)\n", + " Downloading huggingface_hub-0.27.1-py3-none-any.whl.metadata (13 kB)\n", + "Collecting botocore<1.37.0,>=1.36.18 (from boto3->ai2-olmo)\n", + " Downloading botocore-1.36.18-py3-none-any.whl.metadata (5.7 kB)\n", + "Collecting jmespath<2.0.0,>=0.7.1 (from boto3->ai2-olmo)\n", + " Using cached jmespath-1.0.1-py3-none-any.whl.metadata (7.6 kB)\n", + "Collecting s3transfer<0.12.0,>=0.11.0 (from boto3->ai2-olmo)\n", + " Downloading s3transfer-0.11.2-py3-none-any.whl.metadata (1.7 kB)\n", + "Collecting google-auth<3.0dev,>=2.26.1 (from google-cloud-storage->ai2-olmo)\n", + " Downloading google_auth-2.38.0-py2.py3-none-any.whl.metadata (4.8 kB)\n", + "Collecting google-api-core<3.0.0dev,>=2.15.0 (from google-cloud-storage->ai2-olmo)\n", + " Downloading google_api_core-2.24.1-py3-none-any.whl.metadata (3.0 kB)\n", + "Collecting google-cloud-core<3.0dev,>=2.3.0 (from google-cloud-storage->ai2-olmo)\n", + " Using cached google_cloud_core-2.4.1-py2.py3-none-any.whl.metadata (2.7 kB)\n", + "Collecting google-resumable-media>=2.7.2 (from google-cloud-storage->ai2-olmo)\n", + " Downloading google_resumable_media-2.7.2-py2.py3-none-any.whl.metadata (2.2 kB)\n", + "Collecting google-crc32c<2.0dev,>=1.0 (from google-cloud-storage->ai2-olmo)\n", + " Downloading google_crc32c-1.6.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (2.3 kB)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from huggingface-hub>=0.8.0->optimum) (2025.2.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from huggingface-hub>=0.8.0->optimum) (6.0.2)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from huggingface-hub>=0.8.0->optimum) (4.67.1)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from huggingface-hub>=0.8.0->optimum) (4.12.2)\n", + "Collecting markdown-it-py>=2.2.0 (from rich->ai2-olmo)\n", + " Using cached markdown_it_py-3.0.0-py3-none-any.whl.metadata (6.9 kB)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from rich->ai2-olmo) (2.19.1)\n", + "Requirement already satisfied: networkx in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (3.2.1)\n", + "Requirement already satisfied: jinja2 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (3.1.5)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.4.127 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (12.4.127)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.4.127 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (12.4.127)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.4.127 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (12.4.127)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (9.1.0.70)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.4.5.8 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (12.4.5.8)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.2.1.3 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (11.2.1.3)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.5.147 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (10.3.5.147)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.6.1.9 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (11.6.1.9)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.3.1.170 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (12.3.1.170)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (0.6.2)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (12.4.127)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.4.127 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (12.4.127)\n", + "Requirement already satisfied: triton==3.2.0 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from torch>=1.11->optimum) (3.2.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from sympy->onnxruntime) (1.3.0)\n", + "Requirement already satisfied: regex!=2019.12.17 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from transformers>=4.29->optimum) (2024.11.6)\n", + "Requirement already satisfied: humanfriendly>=9.1 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from coloredlogs->onnxruntime) (10.0)\n", + "Collecting zipp>=3.1.0 (from importlib_resources->ai2-olmo)\n", + " Downloading zipp-3.21.0-py3-none-any.whl.metadata (3.7 kB)\n", + "Collecting antlr4-python3-runtime==4.9.* (from omegaconf->ai2-olmo)\n", + " Using cached antlr4_python3_runtime-4.9.3-py3-none-any.whl\n", + "Requirement already satisfied: python-dateutil<3.0.0,>=2.1 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from botocore<1.37.0,>=1.36.18->boto3->ai2-olmo) (2.9.0.post0)\n", + "Collecting urllib3<1.27,>=1.25.4 (from botocore<1.37.0,>=1.36.18->boto3->ai2-olmo)\n", + " Downloading urllib3-1.26.20-py2.py3-none-any.whl.metadata (50 kB)\n", + "Collecting googleapis-common-protos<2.0.dev0,>=1.56.2 (from google-api-core<3.0.0dev,>=2.15.0->google-cloud-storage->ai2-olmo)\n", + " Downloading googleapis_common_protos-1.67.0rc1-py2.py3-none-any.whl.metadata (5.1 kB)\n", + "Collecting proto-plus<2.0.0dev,>=1.22.3 (from google-api-core<3.0.0dev,>=2.15.0->google-cloud-storage->ai2-olmo)\n", + " Downloading proto_plus-1.26.0-py3-none-any.whl.metadata (2.2 kB)\n", + "Collecting cachetools<6.0,>=2.0.0 (from google-auth<3.0dev,>=2.26.1->google-cloud-storage->ai2-olmo)\n", + " Downloading cachetools-5.5.1-py3-none-any.whl.metadata (5.4 kB)\n", + "Collecting pyasn1-modules>=0.2.1 (from google-auth<3.0dev,>=2.26.1->google-cloud-storage->ai2-olmo)\n", + " Downloading pyasn1_modules-0.4.1-py3-none-any.whl.metadata (3.5 kB)\n", + "Collecting rsa<5,>=3.1.4 (from google-auth<3.0dev,>=2.26.1->google-cloud-storage->ai2-olmo)\n", + " Using cached rsa-4.9-py3-none-any.whl.metadata (4.2 kB)\n", + "Collecting mdurl~=0.1 (from markdown-it-py>=2.2.0->rich->ai2-olmo)\n", + " Using cached mdurl-0.1.2-py3-none-any.whl.metadata (1.6 kB)\n", + "Collecting annotated-types>=0.6.0 (from pydantic<3.0,>=2.0->ai2-olmo-core==0.1.0->ai2-olmo)\n", + " Using cached annotated_types-0.7.0-py3-none-any.whl.metadata (15 kB)\n", + "Collecting pydantic-core==2.27.2 (from pydantic<3.0,>=2.0->ai2-olmo-core==0.1.0->ai2-olmo)\n", + " Downloading pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from requests->ai2-olmo-core==0.1.0->ai2-olmo) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from requests->ai2-olmo-core==0.1.0->ai2-olmo) (3.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from requests->ai2-olmo-core==0.1.0->ai2-olmo) (2025.1.31)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from jinja2->torch>=1.11->optimum) (3.0.2)\n", + "Collecting pyasn1<0.7.0,>=0.4.6 (from pyasn1-modules>=0.2.1->google-auth<3.0dev,>=2.26.1->google-cloud-storage->ai2-olmo)\n", + " Downloading pyasn1-0.6.1-py3-none-any.whl.metadata (8.4 kB)\n", + "Requirement already satisfied: six>=1.5 in /home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages (from python-dateutil<3.0.0,>=2.1->botocore<1.37.0,>=1.36.18->boto3->ai2-olmo) (1.17.0)\n", + "Downloading ai2_olmo-0.6.0-py3-none-any.whl (144.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m144.9/144.9 MB\u001b[0m \u001b[31m14.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hDownloading ai2_olmo_core-0.1.0-py3-none-any.whl (56 kB)\n", + "Downloading cached_path-1.6.7-py3-none-any.whl (35 kB)\n", + "Downloading boto3-1.36.18-py3-none-any.whl (139 kB)\n", + "Downloading google_cloud_storage-2.19.0-py2.py3-none-any.whl (131 kB)\n", + "Downloading huggingface_hub-0.27.1-py3-none-any.whl (450 kB)\n", + "Using cached numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.2 MB)\n", + "Downloading rich-13.9.4-py3-none-any.whl (242 kB)\n", + "Downloading importlib_resources-6.5.2-py3-none-any.whl (37 kB)\n", + "Downloading omegaconf-2.3.0-py3-none-any.whl (79 kB)\n", + "Downloading botocore-1.36.18-py3-none-any.whl (13.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m36.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hDownloading google_api_core-2.24.1-py3-none-any.whl (160 kB)\n", + "Downloading google_auth-2.38.0-py2.py3-none-any.whl (210 kB)\n", + "Downloading google_cloud_core-2.4.1-py2.py3-none-any.whl (29 kB)\n", + "Downloading google_crc32c-1.6.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (37 kB)\n", + "Downloading google_resumable_media-2.7.2-py2.py3-none-any.whl (81 kB)\n", + "Downloading jmespath-1.0.1-py3-none-any.whl (20 kB)\n", + "Using cached markdown_it_py-3.0.0-py3-none-any.whl (87 kB)\n", + "Downloading pydantic-2.10.6-py3-none-any.whl (431 kB)\n", + "Downloading pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m35.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading s3transfer-0.11.2-py3-none-any.whl (84 kB)\n", + "Downloading zipp-3.21.0-py3-none-any.whl (9.6 kB)\n", + "Using cached annotated_types-0.7.0-py3-none-any.whl (13 kB)\n", + "Downloading cachetools-5.5.1-py3-none-any.whl (9.5 kB)\n", + "Downloading googleapis_common_protos-1.67.0rc1-py2.py3-none-any.whl (165 kB)\n", + "Using cached mdurl-0.1.2-py3-none-any.whl (10.0 kB)\n", + "Downloading proto_plus-1.26.0-py3-none-any.whl (50 kB)\n", + "Downloading pyasn1_modules-0.4.1-py3-none-any.whl (181 kB)\n", + "Using cached rsa-4.9-py3-none-any.whl (34 kB)\n", + "Downloading urllib3-1.26.20-py2.py3-none-any.whl (144 kB)\n", + "Downloading pyasn1-0.6.1-py3-none-any.whl (83 kB)\n", + "Installing collected packages: antlr4-python3-runtime, zipp, urllib3, pydantic-core, pyasn1, proto-plus, omegaconf, numpy, mdurl, jmespath, googleapis-common-protos, google-crc32c, cachetools, annotated-types, rsa, pydantic, pyasn1-modules, markdown-it-py, importlib_resources, google-resumable-media, botocore, s3transfer, rich, huggingface-hub, google-auth, google-api-core, boto3, google-cloud-core, google-cloud-storage, cached_path, ai2-olmo-core, ai2-olmo\n", + " Attempting uninstall: urllib3\n", + " Found existing installation: urllib3 2.3.0\n", + " Uninstalling urllib3-2.3.0:\n", + " Successfully uninstalled urllib3-2.3.0\n", + " Attempting uninstall: numpy\n", + " Found existing installation: numpy 2.0.2\n", + " Uninstalling numpy-2.0.2:\n", + " Successfully uninstalled numpy-2.0.2\n", + " Attempting uninstall: huggingface-hub\n", + " Found existing installation: huggingface-hub 0.28.1\n", + " Uninstalling huggingface-hub-0.28.1:\n", + " Successfully uninstalled huggingface-hub-0.28.1\n", + "Successfully installed ai2-olmo-0.6.0 ai2-olmo-core-0.1.0 annotated-types-0.7.0 antlr4-python3-runtime-4.9.3 boto3-1.36.18 botocore-1.36.18 cached_path-1.6.7 cachetools-5.5.1 google-api-core-2.24.1 google-auth-2.38.0 google-cloud-core-2.4.1 google-cloud-storage-2.19.0 google-crc32c-1.6.0 google-resumable-media-2.7.2 googleapis-common-protos-1.67.0rc1 huggingface-hub-0.27.1 importlib_resources-6.5.2 jmespath-1.0.1 markdown-it-py-3.0.0 mdurl-0.1.2 numpy-1.26.4 omegaconf-2.3.0 proto-plus-1.26.0 pyasn1-0.6.1 pyasn1-modules-0.4.1 pydantic-2.10.6 pydantic-core-2.27.2 rich-13.9.4 rsa-4.9 s3transfer-0.11.2 urllib3-1.26.20 zipp-3.21.0\n" + ] + } + ], + "source": [ + "!pip install -q --upgrade transformers[onnx]==4.41.0\n", + "!pip install optimum sentencepiece onnx onnxruntime ai2-olmo" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GX1TUzkhS-JK" + }, + "source": [ + "- HuggingFace has an extension called Optimum which offers specialized model inference, including ONNX. We can use this to import and export ONNX models with `from_pretrained` and `save_pretrained`.\n", + "- We'll use [allenai/OLMo-1B-hf](https://huggingface.co/allenai/OLMo-1B-hf) model from HuggingFace as an example\n", + "- In addition to `OLMO` we also need to save the tokenizer. This is the same for every model, these are assets needed for tokenization inside Spark NLP.\n", + "- If we want to optimize the model, a GPU will be needed. Make sure to select the correct runtime.\n", + "0" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "-ibF3eK_S-JK" + }, + "outputs": [], + "source": [ + "import transformers\n", + "MODEL_NAME = \"allenai/OLMo-1B-hf\"\n", + "\n", + "\n", + "# Path to store the exported models\n", + "EXPORT_PATH = f\"onnx_models/{MODEL_NAME}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "kDH5EpwnS-JK", + "outputId": "e32328ad-45b3-4d6c-d5d6-d2da88dbbd4a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages/huggingface_hub/file_download.py:795: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\n", + "config.json: 100%|█████████████████████████████| 632/632 [00:00<00:00, 38.6kB/s]\n", + "model.safetensors: 100%|███████████████████| 4.71G/4.71G [03:24<00:00, 23.1MB/s]\n", + "generation_config.json: 100%|██████████████████| 116/116 [00:00<00:00, 12.9kB/s]\n", + "tokenizer_config.json: 100%|████████████████| 5.37k/5.37k [00:00<00:00, 698kB/s]\n", + "tokenizer.json: 100%|██████████████████████| 2.12M/2.12M [00:00<00:00, 2.45MB/s]\n", + "special_tokens_map.json: 100%|███████████████| 65.0/65.0 [00:00<00:00, 25.5kB/s]\n", + "/home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages/huggingface_hub/file_download.py:795: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\n", + "/home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages/transformers/models/olmo/modeling_olmo.py:1039: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n", + " if sequence_length != 1:\n", + "Weight deduplication check in the ONNX export requires accelerate. Please install accelerate to run it.\n", + "\t\t-[x] values not close enough, max diff: 0.0007228851318359375 (atol: 0.0001)\n", + "The ONNX export succeeded with the warning: The maximum absolute difference between the output of the reference model and the ONNX exported model is not within the set tolerance 0.0001:\n", + "- logits: max diff = 0.0007228851318359375.\n", + " The exported model was saved at: onnx_models/allenai/OLMo-1B-hf\n" + ] + } + ], + "source": [ + "!optimum-cli export onnx --trust-remote-code --task text-generation --model {MODEL_NAME} {EXPORT_PATH} " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oDAyLDCcS-JL" + }, + "source": [ + "Let's have a look inside these two directories and see what we are dealing with:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "jp2ssmF2S-JL", + "outputId": "7c3379db-18cd-4990-de7e-51e9b4eada8c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 5001720\n", + "-rw-rw-r-- 1 prabod prabod 646 Feb 12 03:51 config.json\n", + "-rw-rw-r-- 1 prabod prabod 111 Feb 12 03:51 generation_config.json\n", + "-rw-rw-r-- 1 prabod prabod 468660 Feb 12 03:52 model.onnx\n", + "-rw-rw-r-- 1 prabod prabod 5119148032 Feb 12 03:52 model.onnx_data\n", + "-rw-rw-r-- 1 prabod prabod 293 Feb 12 03:51 special_tokens_map.json\n", + "-rw-rw-r-- 1 prabod prabod 5372 Feb 12 03:51 tokenizer_config.json\n", + "-rw-rw-r-- 1 prabod prabod 2115417 Feb 12 03:51 tokenizer.json\n" + ] + } + ], + "source": [ + "!ls -l {EXPORT_PATH}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TJ-z0eSzS-JL" + }, + "source": [ + "- As you can see, we need to move the sentence piece models `spiece.model` from the tokenizer to assets folder which Spark NLP will look for" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/prabod/anaconda3/envs/olmo/lib/python3.9/site-packages/huggingface_hub/file_download.py:795: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "('onnx_models/allenai/OLMo-1B-hf/assets/tokenizer_config.json',\n", + " 'onnx_models/allenai/OLMo-1B-hf/assets/special_tokens_map.json',\n", + " 'onnx_models/allenai/OLMo-1B-hf/assets/tokenizer.json')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig\n", + "from pathlib import Path\n", + "model_id = 'allenai/OLMo-1B-hf'\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(model_id,trust_remote_code=True)\n", + "config = AutoConfig.from_pretrained(model_id,trust_remote_code=True)\n", + "\n", + "\n", + "ASSETS_PATH = f\"{EXPORT_PATH}/assets\"\n", + "\n", + "\n", + "\n", + "# make sure the directory exists\n", + "Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)\n", + "\n", + "config.save_pretrained(ASSETS_PATH)\n", + "tokenizer.save_vocabulary(ASSETS_PATH)\n", + "\n", + "tokenizer.save_pretrained(ASSETS_PATH)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "062OnFBIS-JL" + }, + "outputs": [], + "source": [ + "! mkdir -p {EXPORT_PATH}/assets\n", + "! mv -t {EXPORT_PATH}/assets {EXPORT_PATH}/merges.txt" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "xZMCq14PUdrG" + }, + "outputs": [], + "source": [ + "import json\n", + "with open(f\"{ASSETS_PATH}/vocab.json\", \"r\") as F:\n", + " vocab_json = json.load(F)\n", + " vocab = [\"\" for i in range(len(vocab_json))]\n", + " for word in vocab_json:\n", + " vocab[vocab_json[word]] = word\n", + " with open(f\"{ASSETS_PATH}/vocab.txt\", \"w\") as F2:\n", + " F2.writelines(map(lambda x: str(x) + \"\\n\", vocab))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "3fbDIHVFS-JL", + "outputId": "ebe0a435-3c5c-4c20-df51-534397802fbd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 3716\n", + "-rw-rw-r-- 1 prabod prabod 673 Feb 12 03:59 config.json\n", + "-rw-rw-r-- 1 prabod prabod 456598 Feb 12 03:59 merges.txt\n", + "-rw-rw-r-- 1 prabod prabod 293 Feb 12 03:59 special_tokens_map.json\n", + "-rw-rw-r-- 1 prabod prabod 5372 Feb 12 03:59 tokenizer_config.json\n", + "-rw-rw-r-- 1 prabod prabod 2115417 Feb 12 03:59 tokenizer.json\n", + "-rw-rw-r-- 1 prabod prabod 799451 Feb 12 03:59 vocab.json\n", + "-rw-rw-r-- 1 prabod prabod 407614 Feb 12 04:00 vocab.txt\n" + ] + } + ], + "source": [ + "!ls -l {EXPORT_PATH}/assets" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-02-12 04:30:03,971 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:03,994 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.0/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:03,995 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:04,016 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.0/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:04,017 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:04,039 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.0/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:04,041 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/self_attn/rotary_emb/MatMul ...\n", + "2025-02-12 04:30:04,042 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:04,043 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/self_attn/MatMul ...\n", + "2025-02-12 04:30:04,045 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:04,046 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:04,047 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:04,048 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:04,073 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.0/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:04,074 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:04,186 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.0/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:04,192 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:04,279 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.0/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:04,283 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.0/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:04,370 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.0/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:04,373 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:04,402 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.1/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:04,403 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:04,422 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.1/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:04,423 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:04,442 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.1/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:04,444 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/self_attn/MatMul ...\n", + "2025-02-12 04:30:04,445 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:04,446 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:04,447 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:04,448 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:04,470 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.1/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:04,471 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:04,569 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.1/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:04,573 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:04,672 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.1/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:04,676 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.1/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:04,775 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.1/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:04,779 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:04,807 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.2/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:04,808 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:04,827 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.2/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:04,828 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:04,848 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.2/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:04,849 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/self_attn/MatMul ...\n", + "2025-02-12 04:30:04,850 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:04,851 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:04,852 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:04,855 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:04,874 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.2/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:04,875 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:04,964 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.2/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:04,968 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:05,057 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.2/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:05,060 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.2/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:05,151 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.2/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:05,155 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:05,183 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.3/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:05,184 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:05,203 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.3/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:05,204 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:05,223 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.3/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:05,224 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/self_attn/MatMul ...\n", + "2025-02-12 04:30:05,225 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:05,226 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:05,227 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:05,228 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:05,250 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.3/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:05,251 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:05,348 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.3/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:05,352 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:05,459 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.3/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:05,464 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.3/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:05,564 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.3/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:05,568 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:05,601 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.4/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:05,602 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:05,623 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.4/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:05,624 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:05,645 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.4/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:05,646 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/self_attn/MatMul ...\n", + "2025-02-12 04:30:05,647 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:05,649 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:05,650 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:05,651 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:05,671 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.4/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:05,672 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:05,768 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.4/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:05,772 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:05,859 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.4/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:05,863 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.4/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:05,952 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.4/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:05,956 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:05,989 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.5/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:05,990 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:06,010 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.5/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:06,011 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:06,032 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.5/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:06,033 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/self_attn/MatMul ...\n", + "2025-02-12 04:30:06,034 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:06,036 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:06,037 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:06,038 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:06,061 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.5/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:06,062 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:06,175 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.5/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:06,182 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:06,268 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.5/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:06,272 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.5/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:06,368 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.5/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:06,375 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:06,403 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.6/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:06,404 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:06,423 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.6/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:06,424 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:06,443 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.6/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:06,445 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/self_attn/MatMul ...\n", + "2025-02-12 04:30:06,446 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:06,447 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:06,448 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:06,449 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:06,469 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.6/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:06,470 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:06,555 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.6/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:06,559 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:06,652 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.6/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:06,655 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.6/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:06,743 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.6/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:06,747 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:06,775 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.7/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:06,776 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:06,795 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.7/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:06,796 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:06,815 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.7/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:06,816 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/self_attn/MatMul ...\n", + "2025-02-12 04:30:06,818 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:06,819 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:06,820 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:06,821 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:06,844 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.7/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:06,846 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:06,947 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.7/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:06,952 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:07,053 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.7/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:07,058 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.7/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:07,161 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.7/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:07,166 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:07,198 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.8/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:07,199 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:07,220 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.8/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:07,221 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:07,241 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.8/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:07,243 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/self_attn/MatMul ...\n", + "2025-02-12 04:30:07,244 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:07,245 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:07,246 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:07,247 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:07,268 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.8/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:07,269 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:07,356 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.8/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:07,360 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:07,445 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.8/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:07,449 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.8/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:07,540 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.8/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:07,544 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:07,571 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.9/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:07,572 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:07,591 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.9/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:07,592 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:07,613 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.9/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:07,615 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/self_attn/MatMul ...\n", + "2025-02-12 04:30:07,616 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:07,617 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:07,618 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:07,619 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:07,640 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.9/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:07,641 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:07,734 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.9/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:07,739 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:07,844 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.9/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:07,849 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.9/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:07,948 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.9/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:07,951 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:07,980 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.10/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:07,981 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:08,001 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.10/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:08,002 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:08,022 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.10/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:08,023 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/self_attn/MatMul ...\n", + "2025-02-12 04:30:08,025 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:08,026 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:08,027 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:08,028 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:08,047 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.10/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:08,048 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:08,135 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.10/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:08,141 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:08,226 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.10/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:08,230 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.10/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:08,315 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.10/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:08,319 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:08,348 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.11/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:08,349 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:08,368 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.11/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:08,369 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:08,388 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.11/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:08,389 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/self_attn/MatMul ...\n", + "2025-02-12 04:30:08,391 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:08,392 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:08,393 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:08,394 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:08,415 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.11/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:08,416 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:08,521 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.11/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:08,525 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:08,630 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.11/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:08,634 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.11/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:08,738 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.11/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:08,742 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:08,775 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.12/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:08,776 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:08,797 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.12/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:08,798 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:08,818 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.12/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:08,820 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/self_attn/MatMul ...\n", + "2025-02-12 04:30:08,821 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:08,822 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:08,823 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:08,824 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:08,846 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.12/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:08,847 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:08,929 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.12/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:08,933 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:09,025 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.12/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:09,029 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.12/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:09,118 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.12/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:09,122 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:09,151 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.13/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:09,152 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:09,171 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.13/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:09,172 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:09,191 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.13/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:09,193 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/self_attn/MatMul ...\n", + "2025-02-12 04:30:09,194 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:09,195 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:09,197 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:09,198 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:09,219 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.13/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:09,220 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:09,308 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.13/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:09,311 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:09,399 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.13/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:09,402 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.13/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:09,489 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.13/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:09,492 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:09,520 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.14/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:09,521 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:09,540 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.14/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:09,541 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:09,560 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.14/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:09,561 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/self_attn/MatMul ...\n", + "2025-02-12 04:30:09,563 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:09,564 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:09,565 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:09,566 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:09,587 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.14/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:09,588 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:09,713 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.14/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:09,717 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:09,842 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.14/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:09,847 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.14/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:09,973 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.14/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:09,976 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:10,004 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.15/self_attn/q_proj/MatMul ...\n", + "2025-02-12 04:30:10,005 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:10,024 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.15/self_attn/k_proj/MatMul ...\n", + "2025-02-12 04:30:10,025 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:10,044 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.15/self_attn/v_proj/MatMul ...\n", + "2025-02-12 04:30:10,046 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/self_attn/MatMul ...\n", + "2025-02-12 04:30:10,047 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:10,048 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/self_attn/MatMul_1 ...\n", + "2025-02-12 04:30:10,050 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - MatMul doesn't have const weight. Skip to quantize\n", + "2025-02-12 04:30:10,051 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:10,072 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.15/self_attn/o_proj/MatMul ...\n", + "2025-02-12 04:30:10,073 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:10,193 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.15/mlp/gate_proj/MatMul ...\n", + "2025-02-12 04:30:10,198 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:10,326 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.15/mlp/up_proj/MatMul ...\n", + "2025-02-12 04:30:10,331 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /model/layers.15/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:10,456 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /model/layers.15/mlp/down_proj/MatMul ...\n", + "2025-02-12 04:30:10,462 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - start to quantize /lm_head/MatMul ...\n", + "2025-02-12 04:30:11,248 onnxruntime.quantization.matmul_4bits_quantizer [INFO] - complete quantization of /lm_head/MatMul ...\n" + ] + } + ], + "source": [ + "import onnx\n", + "# from onnxruntime import quantization as ort_quantization\n", + "from onnxruntime.quantization.matmul_4bits_quantizer import MatMul4BitsQuantizer\n", + "\n", + "Path(f'onnx_models/{model_id}_int4').mkdir(parents=True, exist_ok=True)\n", + "\n", + "model = onnx.load_model(f\"onnx_models/{model_id}/model.onnx\", load_external_data=True)\n", + "quant = MatMul4BitsQuantizer(\n", + " model=model,\n", + " block_size=32,\n", + " is_symmetric=True,\n", + " nodes_to_exclude=[],\n", + ")\n", + "quant.process()\n", + "quant.model.save_model_to_file(f'onnx_models/{model_id}_int4/model.onnx', use_external_data_format=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "model_id = 'allenai/OLMo-1B-hf'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import onnx\n", + "model = onnx.load(f\"onnx_models/{model_id}_int4/model.onnx\")\n", + "EXPORT_PATH = f\"onnx_models/{model_id}_int4\"\n", + "onnx.save_model(model, f\"{EXPORT_PATH}/decoder_model.onnx\", save_as_external_data=True, all_tensors_to_one_file=True, location=\"_olmo_decoder_model.onnx_data\", size_threshold=1024, convert_attribute=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!rm -rf {EXPORT_PATH}/model.onnx {EXPORT_PATH}/model.onnx_data" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#copy the assets\n", + "!cp -r onnx_models/{model_id}/assets onnx_models/{model_id}_int4/assets" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing /home/prabod/Projects/spark-nlp/python/dist/spark_nlp-5.5.3-py2.py3-none-any.whl\n", + "Collecting pyspark==3.2.3\n", + " Using cached pyspark-3.2.3.tar.gz (281.5 MB)\n", + " Preparing metadata (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25hCollecting py4j==0.10.9.5 (from pyspark==3.2.3)\n", + " Using cached py4j-0.10.9.5-py2.py3-none-any.whl.metadata (1.5 kB)\n", + "spark-nlp is already installed with the same version as the provided wheel. Use --force-reinstall to force an installation of the wheel.\n", + "Using cached py4j-0.10.9.5-py2.py3-none-any.whl (199 kB)\n", + "Building wheels for collected packages: pyspark\n", + " Building wheel for pyspark (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for pyspark: filename=pyspark-3.2.3-py2.py3-none-any.whl size=281990715 sha256=ec075358b0ed3cc8cae95e6699c93f9e9949e54045ca13ced0d05052e0143361\n", + " Stored in directory: /home/prabod/.cache/pip/wheels/cc/f4/8d/dfbbd536587311afde33711613a0c193f18e7d90b120801108\n", + "Successfully built pyspark\n", + "Installing collected packages: py4j, pyspark\n", + "Successfully installed py4j-0.10.9.5 pyspark-3.2.3\n" + ] + } + ], + "source": [ + "!pip install /home/prabod/Projects/spark-nlp/python/dist/spark_nlp-5.5.3-py2.py3-none-any.whl pyspark==3.2.3" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NZZqEbvvS-JM" + }, + "source": [ + "## Import and Save OLMO in Spark NLP\n", + "\n", + "- Let's install and setup Spark NLP in Google Colab\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "SLlypPRaS-JM", + "outputId": "54ab8af5-a1cb-4c29-f982-2f5aac5e6e35" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installing PySpark 3.2.3 and Spark NLP 5.4.2\n", + "setup Colab for PySpark 3.2.3 and Spark NLP 5.4.2\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m281.5/281.5 MB\u001b[0m \u001b[31m5.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.6/55.6 kB\u001b[0m \u001b[31m3.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m579.5/579.5 kB\u001b[0m \u001b[31m29.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.7/199.7 kB\u001b[0m \u001b[31m14.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Building wheel for pyspark (setup.py) ... \u001b[?25l\u001b[?25hdone\n" + ] + } + ], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QEy-zFjnS-JM" + }, + "source": [ + "Let's start Spark with Spark NLP included via our simple `start()` function" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "0KOd7hwNS-JM", + "outputId": "8e408b69-db08-42f5-9d14-c163034f9c04" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting spark-nlp==5.5.0rc1\n", + " Downloading spark_nlp-5.5.0rc1-py2.py3-none-any.whl.metadata (55 kB)\n", + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/55.8 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.8/55.8 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading spark_nlp-5.5.0rc1-py2.py3-none-any.whl (629 kB)\n", + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/629.6 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m624.6/629.6 kB\u001b[0m \u001b[31m25.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m629.6/629.6 kB\u001b[0m \u001b[31m17.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: spark-nlp\n", + " Attempting uninstall: spark-nlp\n", + " Found existing installation: spark-nlp 5.4.2\n", + " Uninstalling spark-nlp-5.4.2:\n", + " Successfully uninstalled spark-nlp-5.4.2\n", + "Successfully installed spark-nlp-5.5.0rc1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.10/subprocess.py:1796: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = _posixsubprocess.fork_exec(\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "# let's start Spark with Spark NLP\n", + "spark = sparknlp.start()\n", + "print(\"Apache Spark version: {}\".format(spark.version))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Qgl_T39AS-JM" + }, + "source": [ + "- Let's use `loadSavedModel` functon in `OLMOTransformer` which allows us to load the ONNX model\n", + "- Most params will be set automatically. They can also be set later after loading the model in `OLMOTransformer` during runtime, so don't worry about setting them now\n", + "- `loadSavedModel` accepts two params, first is the path to the exported model. The second is the SparkSession that is `spark` variable we previously started via `sparknlp.start()`\n", + "- NOTE: `loadSavedModel` accepts local paths in addition to distributed file systems such as `HDFS`, `S3`, `DBFS`, etc. This feature was introduced in Spark NLP 4.2.2 release. Keep in mind the best and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively.st and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "Ij_8ZwLxS-JM" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Could not extract bos_token_id from config.json, assigning default value -1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: An illegal reflective access operation has occurred\n", + "WARNING: Illegal reflective access by org.apache.spark.util.SizeEstimator$ (file:/home/prabod/spark/jars/spark-core_2.12-3.3.2.jar) to field java.util.regex.Pattern.pattern\n", + "WARNING: Please consider reporting this to the maintainers of org.apache.spark.util.SizeEstimator$\n", + "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n", + "WARNING: All illegal access operations will be denied in a future release\n" + ] + } + ], + "source": [ + "from sparknlp.annotator import *\n", + "\n", + "olmo = OLMoTransformer.loadSavedModel(EXPORT_PATH, spark)\\\n", + " .setInputCols([\"documents\"])\\\n", + " .setMaxOutputLength(100)\\\n", + " .setDoSample(False)\\\n", + " .setOutputCol(\"generation\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "v_eeGHNZS-JM" + }, + "source": [ + "Let's save it on disk so it is easier to be moved around and also be used later via `.load` function" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "0rmW0bXLS-JM" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "olmo.write().overwrite().save(f\"/tmp/{MODEL_NAME}_spark_nlp_int4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VnmGJlakS-JM" + }, + "source": [ + "Let's clean up stuff we don't need anymore" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "kWkdSCjIS-JN" + }, + "outputs": [], + "source": [ + "!rm -rf {EXPORT_PATH}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "I9YtKl-aS-JN" + }, + "source": [ + "Awesome 😎 !\n", + "\n", + "This is your ONNX OLMO model from HuggingFace 🤗 loaded and saved by Spark NLP 🚀" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "9nbzEjwWS-JN", + "outputId": "4b20ba7c-41c5-440f-89c8-fd4e6a0ec541" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 1121168\n", + "-rw-r--r-- 1 prabod prabod 496159 Feb 12 11:54 decoder_model.onnx\n", + "drwxr-xr-x 5 prabod prabod 4096 Feb 12 11:54 fields\n", + "drwxr-xr-x 2 prabod prabod 4096 Feb 12 11:54 metadata\n", + "-rw-r--r-- 1 prabod prabod 1147568128 Feb 12 11:54 _olmo_decoder_model.onnx_data\n" + ] + } + ], + "source": [ + "! ls -l /tmp/{MODEL_NAME}_spark_nlp_int4" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lcNqKR7mS-JN" + }, + "source": [ + "Now let's see how we can use it on other machines, clusters, or any place you wish to use your new and shiny OLMO model 😊" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "DZyaiumUS-JN", + "outputId": "d7db52cb-b85d-4d9a-fd94-24e5b0af7f4b" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using CPUs\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Stage 21:======================================================> (30 + 1) / 31]\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|text |document |generation |\n", + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|Transfer learning, where a model is first pre-trained on a data-rich task before being fine-tuned on a downstream task, has emerged as a powerful technique in natural language processing (NLP). The effectiveness of transfer learning has given rise to a diversity of approaches, methodology, and practice. In this paper, we explore the landscape of transfer learning techniques for NLP by introducing a unified framework that converts all text-based language problems into a text-to-text format. Our systematic study compares pre-training objectives, architectures, unlabeled data sets, transfer approaches, and other factors on dozens of language understanding tasks. By combining the insights from our exploration with scale and our new Colossal Clean Crawled Corpus, we achieve state-of-the-art results on many benchmarks covering summarization, question answering, text classification, and more. To facilitate future work on transfer learning for NLP, we release our data set, pre-trained models, and code.|[{document, 0, 1008, Transfer learning, where a model is first pre-trained on a data-rich task before being fine-tuned on a downstream task, has emerged as a powerful technique in natural language processing (NLP). The effectiveness of transfer learning has given rise to a diversity of approaches, methodology, and practice. In this paper, we explore the landscape of transfer learning techniques for NLP by introducing a unified framework that converts all text-based language problems into a text-to-text format. Our systematic study compares pre-training objectives, architectures, unlabeled data sets, transfer approaches, and other factors on dozens of language understanding tasks. By combining the insights from our exploration with scale and our new Colossal Clean Crawled Corpus, we achieve state-of-the-art results on many benchmarks covering summarization, question answering, text classification, and more. To facilitate future work on transfer learning for NLP, we release our data set, pre-trained models, and code., {sentence -> 0}, []}]|[{document, 0, 1195, Transfer learning , where a model is first pre - trained on a data - rich task before being fine - tuned on a downstream task , has emerged as a powerful technique in natural language processing ( NLP ). The effectiveness of transfer learning has given rise to a diversity of approaches , methodology , and practice . In this paper , we explore the landscape of transfer learning techniques for NLP by introducing a unified framework that converts all text - based language problems into a text - to - text format . Our systematic study compares pre - training objectives , architectures , unlabeled data sets , transfer approaches , and other factors on dozens of language understanding tasks . By combining the insights from our exploration with scale and our new Colossal Clean Crawled Corpus , we achieve state - of - the - art results on many benchmarks covering summarization , question answering , text classification , and more . To facilitate future work on transfer learning for NLP , we release our data set , pre - trained models , and code . We also release the Colossala testset and a full report on our results , which we provide for researchers . The paper is available at https ., {sentence -> 0}, []}]|\n", + "+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "import sparknlp\n", + "from sparknlp.base import *\n", + "from sparknlp.annotator import *\n", + "from pyspark.ml import Pipeline\n", + "\n", + "test_data = spark.createDataFrame([\n", + " [\"Transfer learning, where a model is first pre-trained on a data-rich task before being fine-tuned on a \" +\n", + " \"downstream task, has emerged as a powerful technique in natural language processing (NLP). The effectiveness\" +\n", + " \" of transfer learning has given rise to a diversity of approaches, methodology, and practice. In this \" +\n", + " \"paper, we explore the landscape of transfer learning techniques for NLP by introducing a unified framework \" +\n", + " \"that converts all text-based language problems into a text-to-text format. Our systematic study compares \" +\n", + " \"pre-training objectives, architectures, unlabeled data sets, transfer approaches, and other factors on dozens \" +\n", + " \"of language understanding tasks. By combining the insights from our exploration with scale and our new \" +\n", + " \"Colossal Clean Crawled Corpus, we achieve state-of-the-art results on many benchmarks covering \" +\n", + " \"summarization, question answering, text classification, and more. To facilitate future work on transfer \" +\n", + " \"learning for NLP, we release our data set, pre-trained models, and code.\"]\n", + "]).toDF(\"text\")\n", + "\n", + "\n", + "document_assembler = DocumentAssembler() \\\n", + " .setInputCol(\"text\")\\\n", + " .setOutputCol(\"document\")\n", + "\n", + "olmo = OLMoTransformer.load(f\"file:///tmp/{MODEL_NAME}_spark_nlp_int4\")\\\n", + " .setInputCols([\"document\"])\\\n", + " .setMaxOutputLength(50)\\\n", + " .setDoSample(True)\\\n", + " .setTopK(50)\\\n", + " .setTemperature(0)\\\n", + " .setBatchSize(5)\\\n", + " .setNoRepeatNgramSize(3)\\\n", + " .setOutputCol(\"generation\")\n", + "\n", + "pipeline = Pipeline().setStages([document_assembler, olmo])\n", + "\n", + "result = pipeline.fit(test_data).transform(test_data)\n", + "result.show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uTnIQ3HKS-JN" + }, + "source": [ + "That's it! You can now go wild and use hundreds of OLMO models from HuggingFace 🤗 in Spark NLP 🚀\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "olmo", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.21" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_RoBERTaForMultipleChoice.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_RoBERTaForMultipleChoice.ipynb new file mode 100644 index 00000000000000..9cf14051be447e --- /dev/null +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_RoBERTaForMultipleChoice.ipynb @@ -0,0 +1,3137 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "PAsu8UVGoLVf" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_RoBERTaForMultipleChoice.ipynb)\n", + "\n", + "## Import ONNX RoBERTaForMultipleChoice models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- ONNX support was introduced in `Spark NLP 5.0.0`, enabling high performance inference for models.\n", + "- `RoBertaForMultipleChoice` is only available since in `Spark NLP 5.6.0` and after. So please make sure you have upgraded to the latest Spark NLP release\n", + "- You can import BERT models trained/fine-tuned for question answering via `RoBertaForMultipleChoice` or `TFRobertaForMultipleChoice`. These models are usually under `Multiple Choice` category and have `bert` in their labels\n", + "- Reference: [RoBertaForMultipleChoice](https://huggingface.co/docs/transformers/en/model_doc/roberta#transformers.RobertaForMultipleChoice)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OzijcdtQpOx9" + }, + "source": [ + "## Export and Save HuggingFace model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MlgoClMXpSg4" + }, + "source": [ + "- Let's install `transformers` package with the `onnx` extension and it's dependencies. You don't need `onnx` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cJWbob-kHICU", + "outputId": "a32c5445-116e-4724-cc0f-31179dd52df9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m424.1/424.1 kB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m98.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m212.7/212.7 kB\u001b[0m \u001b[31m15.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m480.6/480.6 kB\u001b[0m \u001b[31m37.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m84.5/84.5 kB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m51.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m455.8/455.8 kB\u001b[0m \u001b[31m32.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m9.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.3/179.3 kB\u001b[0m \u001b[31m14.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m13.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m89.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.5/55.5 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m15.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\n", + "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install -q --upgrade transformers[onnx] optimum" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XtewR2xdOa5s" + }, + "source": [ + "- HuggingFace has an extension called Optimum which offers specialized model inference, including ONNX. We can use this to import and export ONNX models with `from_pretrained` and `save_pretrained`.\n", + "- We'll use the treained model above as an example and load it as a `ORTModelForMultipleChoice`, representing an ONNX model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 345, + "referenced_widgets": [ + "b81b575abe25438882c4feefa49c548c", + "fc0e47ce50d242949480bdb27cb03fb2", + "6af58f364683458ca7a126eac79f8e4e", + "f2ff9dc3293e435ab8d8711d4e342502", + "d7e0fbb281654ed5aa19722d67a3e3e2", + "32eed337efda46de976f35e70416f1f7", + "f2150b9b3ebd4823ac3dcb5667e2a805", + "2e05bd110c75401b82a4840753483aab", + "ed5a2963cb1246018d5a86c8fdd184e4", + "dd079c8f52b24568a504800fe0f5d173", + "da38ec87d6d047e2b89ab6e0dff906b0", + "449e0c145e43403d855dfea64dc21088", + "a0a8c669cdec4bb3ab9ee72a17d7aa04", + "1aa8f9eca530473a817456f381d27428", + "4d2302d612e044cd82471c524f088385", + "2b887e873088471db583b3e3fe1b434c", + "00d30d42d577493595bca3c2212b6c0b", + "c826b3ae19644a78800de8351d5eb273", + "4134a81ea32b45cd8fb156c7ff9ce81a", + "5e6e38a8b70e4b0b99645e6a6ec70d1e", + "c20ed60171494bd282f825390a3c22f4", + "69f4a07a5a2f445ea17d22a2d194265a", + "b5e3e91432ec4c618ffdaff327a7741e", + "25b2eeed37024a3ea5bc15fedccd2b6c", + "3e3ec4ef29ea429f87c08ad9a1a6dae4", + "5d6dbd8e5560416b82e68b88e4c98228", + "a274e9d62bf640069a009b106bbe6285", + "b5366c8ca6b54a43a7ebd3f1f5ed4314", + "f326f3da6db044ba8eb30fbfdebfcf1a", + "af141091f1954d61821d591decec6fb7", + "3c368fe097024cbfa4831776bf76decd", + "1bf90b3c45ba4da2937474099359145c", + "adbd551d077642c4940deb5a8bdeea1e", + "635310df3a1d446cba12efcc05ebf193", + "76d9c74da20446589200261c39fe2d3c", + "d5a03993410642f3ae2e6f93fb9ac2aa", + "631be0307e8346f9932603b83f930ace", + "5a1d396c945a48f68f64659ba1047c90", + "90d9046b9ae6424dafb432b35fa58c61", + "873e1debde344c3196b8febb043fce64", + "dbfb4dba9ce148b8afbcad9f91e2e313", + "e4bb3112696944ccbe6e4478896fa37e", + "738d08c4f4f04513ac68689a392f9d83", + "ff4d9baed90c4d088b0690206b79e9cf", + "0588f69af8254964bb99302965d4d1ee", + "e2854b15d44c42ca97e80e2ee5d85277", + "e34b0ebc070d4e2f9b5ec1f7888aaf48", + "07d3f10c53044e44aa98658511dfb833", + "39e33232acef40f29cbe5f1d6356812f", + "e44edfab662947f58b785df9ee6cc3f8", + "07688d751836418d8fec6ab31b44d09e", + "fbcfa2c5c6104b2b8dac3d8cbaae6582", + "dec95a9617d8450d990f275785b7050a", + "bd224ffc05544aaea000116468606db8", + "45fe0f6b87b941b59bd308dca280e2a3", + "e924f9c94be24a0a9a41a6c095403839", + "d5cda9d5599747f5befbff3f680621f7", + "5f13284caf47472ab58a33184227b343", + "284ea88ad9bf471c995e637d78c0415c", + "4534f75337d2443fbf72adeae69c7111", + "3b8ef54f86a04e4e8ff124183ed45c16", + "1c9db5477dd442f2b33f4c0b847ccbb3", + "202ea48a63274ce9b76efa7c6cc2f2a8", + "7f43484ba57d43f395f9366af29880ac", + "c13de8f46773462aad80071ff4bc8116", + "afa26d6167b34e8dae01e122dd9f72ed", + "2e1b3919d89c47129fafd48c11baba71", + "b0cebdeef06c4821922ac6a76280b49d", + "76d223708bb744758176a2c44163aa81", + "b18f3bc006ce4e8684e8b34a65adfd28", + "16e4af9b9428496484eb30b6a3bfe6c8", + "e5e4fcd42f524c85b2e75a4a4c9ac316", + "645f1cf979b7447fb0cd836589797f10", + "3bd998b830554952806a8aee69c9441f", + "7afb04b69be64f21ad5d4a2e6ee02baf", + "0d3326cfa7a245c191d8cc6283e06c88", + "13afc16acf4b4ac3a87b13050daadf5a" + ] + }, + "id": "Id33annImYM8", + "outputId": "b4c0f6fa-2c09-40d7-a235-37df49d7edcd" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n", + "The secret `HF_TOKEN` does not exist in your Colab secrets.\n", + "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n", + "You will be able to reuse this secret in all of your notebooks.\n", + "Please note that authentication is recommended but still optional to access public models or datasets.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b81b575abe25438882c4feefa49c548c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "config.json: 0%| | 0.00/728 [00:00 0, chunk -> 0, score -> 0.6444231}, []}]|\n", + "|[{chunk, 0, 6, France, {sentence -> 0, chunk -> 0, score -> 0.37822443}, []}] |\n", + "|[{chunk, 0, 8, Elephant, {sentence -> 0, chunk -> 0, score -> 0.3064313}, []}] |\n", + "|[{chunk, 0, 3, 90°C, {sentence -> 0, chunk -> 0, score -> 0.4218395}, []}] |\n", + "|[{chunk, 0, 5, Venus, {sentence -> 0, chunk -> 0, score -> 0.47263265}, []}] |\n", + "|[{chunk, 0, 7, English, {sentence -> 0, chunk -> 0, score -> 0.38427573}, []}] |\n", + "|[{chunk, 0, 10, The Romans, {sentence -> 0, chunk -> 0, score -> 0.310014}, []}] |\n", + "|[{chunk, 0, 5, Ozone, {sentence -> 0, chunk -> 0, score -> 0.5966889}, []}] |\n", + "|[{chunk, 0, 3, Asia, {sentence -> 0, chunk -> 0, score -> 0.4309402}, []}] |\n", + "|[{chunk, 0, 15, Vincent van Gogh, {sentence -> 0, chunk -> 0, score -> 0.38662443}, []}] |\n", + "+----------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "document_assembler = MultiDocumentAssembler() \\\n", + " .setInputCols([\"question\", \"choices\"]) \\\n", + " .setOutputCols([\"document_question\", \"document_choices\"])\n", + "\n", + "roberta_for_multiple_choice = RoBertaForMultipleChoice() \\\n", + " .load(\"./{}_spark_nlp_onnx\".format(MODEL_NAME)) \\\n", + " .setInputCols([\"document_question\", \"document_choices\"])\\\n", + " .setOutputCol(\"answer\") \\\n", + " .setBatchSize(4)\n", + "\n", + "pipeline = Pipeline(stages=[document_assembler, roberta_for_multiple_choice])\n", + "pipeline_model = pipeline.fit(testing_df)\n", + "\n", + "pipeline_df = pipeline_model.transform(testing_df)\n", + "\n", + "pipeline_df.select(\"answer\").show(truncate=False)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "00d30d42d577493595bca3c2212b6c0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0588f69af8254964bb99302965d4d1ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e2854b15d44c42ca97e80e2ee5d85277", + "IPY_MODEL_e34b0ebc070d4e2f9b5ec1f7888aaf48", + "IPY_MODEL_07d3f10c53044e44aa98658511dfb833" + ], + "layout": "IPY_MODEL_39e33232acef40f29cbe5f1d6356812f" + } + }, + "07688d751836418d8fec6ab31b44d09e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "07d3f10c53044e44aa98658511dfb833": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bd224ffc05544aaea000116468606db8", + "placeholder": "​", + "style": "IPY_MODEL_45fe0f6b87b941b59bd308dca280e2a3", + "value": " 1.15M/1.15M [00:00<00:00, 1.94MB/s]" + } + }, + "0d3326cfa7a245c191d8cc6283e06c88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "13afc16acf4b4ac3a87b13050daadf5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "16e4af9b9428496484eb30b6a3bfe6c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1aa8f9eca530473a817456f381d27428": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4134a81ea32b45cd8fb156c7ff9ce81a", + "max": 503987181, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5e6e38a8b70e4b0b99645e6a6ec70d1e", + "value": 503987181 + } + }, + "1bf90b3c45ba4da2937474099359145c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c9db5477dd442f2b33f4c0b847ccbb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "202ea48a63274ce9b76efa7c6cc2f2a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "25b2eeed37024a3ea5bc15fedccd2b6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b5366c8ca6b54a43a7ebd3f1f5ed4314", + "placeholder": "​", + "style": "IPY_MODEL_f326f3da6db044ba8eb30fbfdebfcf1a", + "value": "tokenizer_config.json: 100%" + } + }, + "284ea88ad9bf471c995e637d78c0415c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c13de8f46773462aad80071ff4bc8116", + "placeholder": "​", + "style": "IPY_MODEL_afa26d6167b34e8dae01e122dd9f72ed", + "value": " 3.54M/3.54M [00:00<00:00, 57.9MB/s]" + } + }, + "2b887e873088471db583b3e3fe1b434c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e05bd110c75401b82a4840753483aab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e1b3919d89c47129fafd48c11baba71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b0cebdeef06c4821922ac6a76280b49d", + "IPY_MODEL_76d223708bb744758176a2c44163aa81", + "IPY_MODEL_b18f3bc006ce4e8684e8b34a65adfd28" + ], + "layout": "IPY_MODEL_16e4af9b9428496484eb30b6a3bfe6c8" + } + }, + "32eed337efda46de976f35e70416f1f7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39e33232acef40f29cbe5f1d6356812f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b8ef54f86a04e4e8ff124183ed45c16": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3bd998b830554952806a8aee69c9441f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c368fe097024cbfa4831776bf76decd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3e3ec4ef29ea429f87c08ad9a1a6dae4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af141091f1954d61821d591decec6fb7", + "max": 1385, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3c368fe097024cbfa4831776bf76decd", + "value": 1385 + } + }, + "4134a81ea32b45cd8fb156c7ff9ce81a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "449e0c145e43403d855dfea64dc21088": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a0a8c669cdec4bb3ab9ee72a17d7aa04", + "IPY_MODEL_1aa8f9eca530473a817456f381d27428", + "IPY_MODEL_4d2302d612e044cd82471c524f088385" + ], + "layout": "IPY_MODEL_2b887e873088471db583b3e3fe1b434c" + } + }, + "4534f75337d2443fbf72adeae69c7111": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "45fe0f6b87b941b59bd308dca280e2a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4d2302d612e044cd82471c524f088385": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c20ed60171494bd282f825390a3c22f4", + "placeholder": "​", + "style": "IPY_MODEL_69f4a07a5a2f445ea17d22a2d194265a", + "value": " 504M/504M [00:02<00:00, 230MB/s]" + } + }, + "5a1d396c945a48f68f64659ba1047c90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5d6dbd8e5560416b82e68b88e4c98228": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1bf90b3c45ba4da2937474099359145c", + "placeholder": "​", + "style": "IPY_MODEL_adbd551d077642c4940deb5a8bdeea1e", + "value": " 1.39k/1.39k [00:00<00:00, 92.0kB/s]" + } + }, + "5e6e38a8b70e4b0b99645e6a6ec70d1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5f13284caf47472ab58a33184227b343": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_202ea48a63274ce9b76efa7c6cc2f2a8", + "max": 3537507, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7f43484ba57d43f395f9366af29880ac", + "value": 3537507 + } + }, + "631be0307e8346f9932603b83f930ace": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_738d08c4f4f04513ac68689a392f9d83", + "placeholder": "​", + "style": "IPY_MODEL_ff4d9baed90c4d088b0690206b79e9cf", + "value": " 1.50M/1.50M [00:00<00:00, 18.5MB/s]" + } + }, + "635310df3a1d446cba12efcc05ebf193": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_76d9c74da20446589200261c39fe2d3c", + "IPY_MODEL_d5a03993410642f3ae2e6f93fb9ac2aa", + "IPY_MODEL_631be0307e8346f9932603b83f930ace" + ], + "layout": "IPY_MODEL_5a1d396c945a48f68f64659ba1047c90" + } + }, + "645f1cf979b7447fb0cd836589797f10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "69f4a07a5a2f445ea17d22a2d194265a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6af58f364683458ca7a126eac79f8e4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2e05bd110c75401b82a4840753483aab", + "max": 728, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ed5a2963cb1246018d5a86c8fdd184e4", + "value": 728 + } + }, + "738d08c4f4f04513ac68689a392f9d83": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "76d223708bb744758176a2c44163aa81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3bd998b830554952806a8aee69c9441f", + "max": 957, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7afb04b69be64f21ad5d4a2e6ee02baf", + "value": 957 + } + }, + "76d9c74da20446589200261c39fe2d3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_90d9046b9ae6424dafb432b35fa58c61", + "placeholder": "​", + "style": "IPY_MODEL_873e1debde344c3196b8febb043fce64", + "value": "vocab.json: 100%" + } + }, + "7afb04b69be64f21ad5d4a2e6ee02baf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7f43484ba57d43f395f9366af29880ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "873e1debde344c3196b8febb043fce64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "90d9046b9ae6424dafb432b35fa58c61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0a8c669cdec4bb3ab9ee72a17d7aa04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00d30d42d577493595bca3c2212b6c0b", + "placeholder": "​", + "style": "IPY_MODEL_c826b3ae19644a78800de8351d5eb273", + "value": "pytorch_model.bin: 100%" + } + }, + "a274e9d62bf640069a009b106bbe6285": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "adbd551d077642c4940deb5a8bdeea1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "af141091f1954d61821d591decec6fb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afa26d6167b34e8dae01e122dd9f72ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b0cebdeef06c4821922ac6a76280b49d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5e4fcd42f524c85b2e75a4a4c9ac316", + "placeholder": "​", + "style": "IPY_MODEL_645f1cf979b7447fb0cd836589797f10", + "value": "special_tokens_map.json: 100%" + } + }, + "b18f3bc006ce4e8684e8b34a65adfd28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d3326cfa7a245c191d8cc6283e06c88", + "placeholder": "​", + "style": "IPY_MODEL_13afc16acf4b4ac3a87b13050daadf5a", + "value": " 957/957 [00:00<00:00, 60.0kB/s]" + } + }, + "b5366c8ca6b54a43a7ebd3f1f5ed4314": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b5e3e91432ec4c618ffdaff327a7741e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_25b2eeed37024a3ea5bc15fedccd2b6c", + "IPY_MODEL_3e3ec4ef29ea429f87c08ad9a1a6dae4", + "IPY_MODEL_5d6dbd8e5560416b82e68b88e4c98228" + ], + "layout": "IPY_MODEL_a274e9d62bf640069a009b106bbe6285" + } + }, + "b81b575abe25438882c4feefa49c548c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fc0e47ce50d242949480bdb27cb03fb2", + "IPY_MODEL_6af58f364683458ca7a126eac79f8e4e", + "IPY_MODEL_f2ff9dc3293e435ab8d8711d4e342502" + ], + "layout": "IPY_MODEL_d7e0fbb281654ed5aa19722d67a3e3e2" + } + }, + "bd224ffc05544aaea000116468606db8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c13de8f46773462aad80071ff4bc8116": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c20ed60171494bd282f825390a3c22f4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c826b3ae19644a78800de8351d5eb273": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d5a03993410642f3ae2e6f93fb9ac2aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dbfb4dba9ce148b8afbcad9f91e2e313", + "max": 1503982, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e4bb3112696944ccbe6e4478896fa37e", + "value": 1503982 + } + }, + "d5cda9d5599747f5befbff3f680621f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3b8ef54f86a04e4e8ff124183ed45c16", + "placeholder": "​", + "style": "IPY_MODEL_1c9db5477dd442f2b33f4c0b847ccbb3", + "value": "tokenizer.json: 100%" + } + }, + "d7e0fbb281654ed5aa19722d67a3e3e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da38ec87d6d047e2b89ab6e0dff906b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dbfb4dba9ce148b8afbcad9f91e2e313": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd079c8f52b24568a504800fe0f5d173": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dec95a9617d8450d990f275785b7050a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e2854b15d44c42ca97e80e2ee5d85277": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e44edfab662947f58b785df9ee6cc3f8", + "placeholder": "​", + "style": "IPY_MODEL_07688d751836418d8fec6ab31b44d09e", + "value": "merges.txt: 100%" + } + }, + "e34b0ebc070d4e2f9b5ec1f7888aaf48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fbcfa2c5c6104b2b8dac3d8cbaae6582", + "max": 1150157, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dec95a9617d8450d990f275785b7050a", + "value": 1150157 + } + }, + "e44edfab662947f58b785df9ee6cc3f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4bb3112696944ccbe6e4478896fa37e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e5e4fcd42f524c85b2e75a4a4c9ac316": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e924f9c94be24a0a9a41a6c095403839": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d5cda9d5599747f5befbff3f680621f7", + "IPY_MODEL_5f13284caf47472ab58a33184227b343", + "IPY_MODEL_284ea88ad9bf471c995e637d78c0415c" + ], + "layout": "IPY_MODEL_4534f75337d2443fbf72adeae69c7111" + } + }, + "ed5a2963cb1246018d5a86c8fdd184e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f2150b9b3ebd4823ac3dcb5667e2a805": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f2ff9dc3293e435ab8d8711d4e342502": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd079c8f52b24568a504800fe0f5d173", + "placeholder": "​", + "style": "IPY_MODEL_da38ec87d6d047e2b89ab6e0dff906b0", + "value": " 728/728 [00:00<00:00, 62.0kB/s]" + } + }, + "f326f3da6db044ba8eb30fbfdebfcf1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fbcfa2c5c6104b2b8dac3d8cbaae6582": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc0e47ce50d242949480bdb27cb03fb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_32eed337efda46de976f35e70416f1f7", + "placeholder": "​", + "style": "IPY_MODEL_f2150b9b3ebd4823ac3dcb5667e2a805", + "value": "config.json: 100%" + } + }, + "ff4d9baed90c4d088b0690206b79e9cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_XlmRoBERTaForMultipleChoice.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_XlmRoBERTaForMultipleChoice.ipynb new file mode 100644 index 00000000000000..53f3cac18526c5 --- /dev/null +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_XlmRoBERTaForMultipleChoice.ipynb @@ -0,0 +1,2752 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "PAsu8UVGoLVf" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_XlmRoBERTaForMultipleChoice.ipynb)\n", + "\n", + "## Import ONNX XlmRoBERTaForMultipleChoice models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- ONNX support was introduced in `Spark NLP 5.0.0`, enabling high performance inference for models.\n", + "- `XlmRoBertaForMultipleChoice` is only available since in `Spark NLP 5.6.0` and after. So please make sure you have upgraded to the latest Spark NLP release\n", + "- You can import BERT models trained/fine-tuned for question answering via `XlmRoBertaForMultipleChoice` or `TFXlmRobertaForMultipleChoice`. These models are usually under `Multiple Choice` category and have `bert` in their labels\n", + "- Reference: [XlmRoBertaForMultipleChoice](https://huggingface.co/docs/transformers/en/model_doc/xlm-roberta#transformers.XLMRobertaModel)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OzijcdtQpOx9" + }, + "source": [ + "## Export and Save HuggingFace model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MlgoClMXpSg4" + }, + "source": [ + "- Let's install `transformers` package with the `onnx` extension and it's dependencies. You don't need `onnx` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cJWbob-kHICU", + "outputId": "8fcc8341-d9a9-4a60-fc0e-d0e66724f5da" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/424.1 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m424.1/424.1 kB\u001b[0m \u001b[31m14.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/13.3 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.1/13.3 MB\u001b[0m \u001b[31m183.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m213.9 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m213.9 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m108.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/212.7 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m212.7/212.7 kB\u001b[0m \u001b[31m19.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/46.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m480.6/480.6 kB\u001b[0m \u001b[31m30.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m84.5/84.5 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m62.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m455.8/455.8 kB\u001b[0m \u001b[31m35.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m10.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.3/179.3 kB\u001b[0m \u001b[31m16.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m8.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m13.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m104.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.5/55.5 kB\u001b[0m \u001b[31m5.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m17.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\n", + "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install -q --upgrade transformers[onnx] optimum" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XtewR2xdOa5s" + }, + "source": [ + "- HuggingFace has an extension called Optimum which offers specialized model inference, including ONNX. We can use this to import and export ONNX models with `from_pretrained` and `save_pretrained`.\n", + "- We'll use the treained model above as an example and load it as a `ORTModelForMultipleChoice`, representing an ONNX model." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 313, + "referenced_widgets": [ + "5a6b55c5428a495fad1ebaf11e9cba47", + "3087b40bfe6149ac87b25ca3cbd58c27", + "56c5db9764cf4812b7501803526ab6dd", + "c33c6f4ef9f34a59a76c7e35e27fd921", + "31fb13ffe1f64352bf6d0d13715f69dc", + "5614b155b63a481b8009e928a6b51e73", + "ff89cbd6d6534f9fb96cfd69065cd1d6", + "45b4a7ea9a344191a230c4ec56d49e49", + "364a58a194e0463a9a0fc1faaab5d3c2", + "37ad21890bbe42d2a5f9e524f63e25e4", + "04121aeaee374bb2aebd0a9e9e6f4fd8", + "8ac75b3dd140441991638576845ad0f3", + "8e536244d11e4beea9b689ac243ec418", + "76580904cca24de4b1277a72d7daddb8", + "e4579cd2435e4401920668c8ef5d5322", + "7277188688b14f47bef757a654c054c4", + "64d7562ef76448e88c7a306714435f93", + "3e703a4c56ee4f54a82fe350d603bf2c", + "db6e39b8eff34362b47485ee484560d8", + "b243a50b92de46e5bf3243a7f4d9e16e", + "197a9551cefe4fcc9b2314d85eea345b", + "e40c294c089e495fa8055c16d0f6827c", + "8dec1b2a2a7442d48e15a4989e89933b", + "acd21c1df95a41e9bf90982cfab40129", + "3756efb5c9e840cd8af48155497e7270", + "37eb824221a04a0b961f108cb23a2d5e", + "a7f24884108a4babbd88ba540e3f573a", + "15f7b099fd02413ea521bfcb9fede6f3", + "908c4aaa27774616be0a7def88f439f5", + "ac09bb5b12554915985c7b617e668de3", + "bbee9192025a4e1a9fbafa75c35a873e", + "62d3d544279a454aacce6c1d868ac582", + "92901f444e044fceb0a114cd5ce7aae0", + "74d44d52ad0545a683513bc9f69eb9a7", + "3eaa9f403b3e4a8d9fef7003131a3b77", + "748ab8cd53504a86a3cf5554fe781b6d", + "ec8ff0112bbd4f3b904c494483efa473", + "879b75200c3d46b08b22f5a5d657b6e7", + "a95e5256f2574f6b8ab125ca4306f149", + "d7d50a233797471aa428e32e9f796468", + "a136ee42b30f4603b62404592c69bbe9", + "e7151d48447441e693aa5051bf24225a", + "87b4325c8fea4258af27529d1c6c0176", + "e776a0aaf785427d82337d9c279e4979", + "305b5d1b52764db3ab08dc97e56111e5", + "fd3f34046aab42129e57890b533f976c", + "e64ac7a366e94de4a14c4d8737562012", + "8041c193e6d94356b83b034f3c44bffb", + "35b6d0c146ac4293b9d5a0351f2807a7", + "88dadd458e6c4bbeb0c24593e85ca01c", + "3f103bd3734c46eead675d345091b009", + "b7b96de11eb542aba27c181b80e56505", + "041a2ee1d1c249ecbac68256c2a0caad", + "666bc5c554c046468ef76ce7ad441e71", + "3de3fe32225f460ebed6ee66bb89af79", + "83dc9a8e7f4f4d81b731a31b8e074016", + "bb8f25d6c60d42bc939f62c3faab42c1", + "3bc2e0cd17044bcaa167616c8c3c8d70", + "9031defef8e84e48bdc62ef5993ff74a", + "37f1ddd9de8643418e9b3ae4130a7196", + "70082d1423dd4544a9fdadb86993aee5", + "120471595cb9489db1dec89359b8a870", + "dc364663e67d43e59231ef681664e229", + "a91a509b63f2491a99ff27b58faca8c3", + "ad80b6c1cfef4b24a6f105c51bd32950", + "4040643bd80349bc964be44fccf38d40" + ] + }, + "id": "Id33annImYM8", + "outputId": "162790f0-6ed1-43ef-d0ce-d09fa9f65418" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n", + "The secret `HF_TOKEN` does not exist in your Colab secrets.\n", + "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n", + "You will be able to reuse this secret in all of your notebooks.\n", + "Please note that authentication is recommended but still optional to access public models or datasets.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5a6b55c5428a495fad1ebaf11e9cba47", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "config.json: 0%| | 0.00/714 [00:00 0, chunk -> 0, score -> 0.5}, []}]|\n", + "|[{chunk, 0, 6, Germany, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}] |\n", + "|[{chunk, 0, 8, Elephant, {sentence -> 0, chunk -> 0, score -> 0.25000012}, []}] |\n", + "|[{chunk, 0, 5, 100°C, {sentence -> 0, chunk -> 0, score -> 0.33333355}, []}] |\n", + "|[{chunk, 0, 6, Jupiter, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}] |\n", + "|[{chunk, 0, 6, Spanish, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}] |\n", + "|[{chunk, 0, 9, The Greeks, {sentence -> 0, chunk -> 0, score -> 0.25}, []}] |\n", + "|[{chunk, 0, 6, Oxygenm, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}] |\n", + "|[{chunk, 0, 3, Asia, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}] |\n", + "|[{chunk, 0, 15, Vincent van Gogh, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}] |\n", + "+----------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "document_assembler = MultiDocumentAssembler() \\\n", + " .setInputCols([\"question\", \"choices\"]) \\\n", + " .setOutputCols([\"document_question\", \"document_choices\"])\n", + "\n", + "xlm_roberta_for_multiple_choice = XlmRoBertaForMultipleChoice() \\\n", + " .load(\"./{}_spark_nlp_onnx\".format(MODEL_NAME)) \\\n", + " .setInputCols([\"document_question\", \"document_choices\"])\\\n", + " .setOutputCol(\"answer\") \\\n", + " .setBatchSize(4)\n", + "\n", + "pipeline = Pipeline(stages=[document_assembler, xlm_roberta_for_multiple_choice])\n", + "pipeline_model = pipeline.fit(testing_df)\n", + "\n", + "pipeline_df = pipeline_model.transform(testing_df)\n", + "\n", + "pipeline_df.select(\"answer\").show(truncate=False)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "L4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "04121aeaee374bb2aebd0a9e9e6f4fd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "041a2ee1d1c249ecbac68256c2a0caad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "120471595cb9489db1dec89359b8a870": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "15f7b099fd02413ea521bfcb9fede6f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "197a9551cefe4fcc9b2314d85eea345b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "305b5d1b52764db3ab08dc97e56111e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fd3f34046aab42129e57890b533f976c", + "IPY_MODEL_e64ac7a366e94de4a14c4d8737562012", + "IPY_MODEL_8041c193e6d94356b83b034f3c44bffb" + ], + "layout": "IPY_MODEL_35b6d0c146ac4293b9d5a0351f2807a7" + } + }, + "3087b40bfe6149ac87b25ca3cbd58c27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5614b155b63a481b8009e928a6b51e73", + "placeholder": "​", + "style": "IPY_MODEL_ff89cbd6d6534f9fb96cfd69065cd1d6", + "value": "config.json: 100%" + } + }, + "31fb13ffe1f64352bf6d0d13715f69dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35b6d0c146ac4293b9d5a0351f2807a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "364a58a194e0463a9a0fc1faaab5d3c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3756efb5c9e840cd8af48155497e7270": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ac09bb5b12554915985c7b617e668de3", + "max": 1147, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bbee9192025a4e1a9fbafa75c35a873e", + "value": 1147 + } + }, + "37ad21890bbe42d2a5f9e524f63e25e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37eb824221a04a0b961f108cb23a2d5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_62d3d544279a454aacce6c1d868ac582", + "placeholder": "​", + "style": "IPY_MODEL_92901f444e044fceb0a114cd5ce7aae0", + "value": " 1.15k/1.15k [00:00<00:00, 103kB/s]" + } + }, + "37f1ddd9de8643418e9b3ae4130a7196": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3bc2e0cd17044bcaa167616c8c3c8d70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dc364663e67d43e59231ef681664e229", + "max": 280, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a91a509b63f2491a99ff27b58faca8c3", + "value": 280 + } + }, + "3de3fe32225f460ebed6ee66bb89af79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3e703a4c56ee4f54a82fe350d603bf2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3eaa9f403b3e4a8d9fef7003131a3b77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a95e5256f2574f6b8ab125ca4306f149", + "placeholder": "​", + "style": "IPY_MODEL_d7d50a233797471aa428e32e9f796468", + "value": "sentencepiece.bpe.model: 100%" + } + }, + "3f103bd3734c46eead675d345091b009": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4040643bd80349bc964be44fccf38d40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "45b4a7ea9a344191a230c4ec56d49e49": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5614b155b63a481b8009e928a6b51e73": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "56c5db9764cf4812b7501803526ab6dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_45b4a7ea9a344191a230c4ec56d49e49", + "max": 714, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_364a58a194e0463a9a0fc1faaab5d3c2", + "value": 714 + } + }, + "5a6b55c5428a495fad1ebaf11e9cba47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3087b40bfe6149ac87b25ca3cbd58c27", + "IPY_MODEL_56c5db9764cf4812b7501803526ab6dd", + "IPY_MODEL_c33c6f4ef9f34a59a76c7e35e27fd921" + ], + "layout": "IPY_MODEL_31fb13ffe1f64352bf6d0d13715f69dc" + } + }, + "62d3d544279a454aacce6c1d868ac582": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64d7562ef76448e88c7a306714435f93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "666bc5c554c046468ef76ce7ad441e71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70082d1423dd4544a9fdadb86993aee5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7277188688b14f47bef757a654c054c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "748ab8cd53504a86a3cf5554fe781b6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a136ee42b30f4603b62404592c69bbe9", + "max": 5069051, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e7151d48447441e693aa5051bf24225a", + "value": 5069051 + } + }, + "74d44d52ad0545a683513bc9f69eb9a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3eaa9f403b3e4a8d9fef7003131a3b77", + "IPY_MODEL_748ab8cd53504a86a3cf5554fe781b6d", + "IPY_MODEL_ec8ff0112bbd4f3b904c494483efa473" + ], + "layout": "IPY_MODEL_879b75200c3d46b08b22f5a5d657b6e7" + } + }, + "76580904cca24de4b1277a72d7daddb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_db6e39b8eff34362b47485ee484560d8", + "max": 1112201908, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b243a50b92de46e5bf3243a7f4d9e16e", + "value": 1112201908 + } + }, + "8041c193e6d94356b83b034f3c44bffb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_666bc5c554c046468ef76ce7ad441e71", + "placeholder": "​", + "style": "IPY_MODEL_3de3fe32225f460ebed6ee66bb89af79", + "value": " 17.1M/17.1M [00:00<00:00, 37.1MB/s]" + } + }, + "83dc9a8e7f4f4d81b731a31b8e074016": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bb8f25d6c60d42bc939f62c3faab42c1", + "IPY_MODEL_3bc2e0cd17044bcaa167616c8c3c8d70", + "IPY_MODEL_9031defef8e84e48bdc62ef5993ff74a" + ], + "layout": "IPY_MODEL_37f1ddd9de8643418e9b3ae4130a7196" + } + }, + "879b75200c3d46b08b22f5a5d657b6e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87b4325c8fea4258af27529d1c6c0176": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "88dadd458e6c4bbeb0c24593e85ca01c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ac75b3dd140441991638576845ad0f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8e536244d11e4beea9b689ac243ec418", + "IPY_MODEL_76580904cca24de4b1277a72d7daddb8", + "IPY_MODEL_e4579cd2435e4401920668c8ef5d5322" + ], + "layout": "IPY_MODEL_7277188688b14f47bef757a654c054c4" + } + }, + "8dec1b2a2a7442d48e15a4989e89933b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_acd21c1df95a41e9bf90982cfab40129", + "IPY_MODEL_3756efb5c9e840cd8af48155497e7270", + "IPY_MODEL_37eb824221a04a0b961f108cb23a2d5e" + ], + "layout": "IPY_MODEL_a7f24884108a4babbd88ba540e3f573a" + } + }, + "8e536244d11e4beea9b689ac243ec418": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_64d7562ef76448e88c7a306714435f93", + "placeholder": "​", + "style": "IPY_MODEL_3e703a4c56ee4f54a82fe350d603bf2c", + "value": "model.safetensors: 100%" + } + }, + "9031defef8e84e48bdc62ef5993ff74a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad80b6c1cfef4b24a6f105c51bd32950", + "placeholder": "​", + "style": "IPY_MODEL_4040643bd80349bc964be44fccf38d40", + "value": " 280/280 [00:00<00:00, 23.1kB/s]" + } + }, + "908c4aaa27774616be0a7def88f439f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "92901f444e044fceb0a114cd5ce7aae0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a136ee42b30f4603b62404592c69bbe9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a7f24884108a4babbd88ba540e3f573a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a91a509b63f2491a99ff27b58faca8c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a95e5256f2574f6b8ab125ca4306f149": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac09bb5b12554915985c7b617e668de3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "acd21c1df95a41e9bf90982cfab40129": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_15f7b099fd02413ea521bfcb9fede6f3", + "placeholder": "​", + "style": "IPY_MODEL_908c4aaa27774616be0a7def88f439f5", + "value": "tokenizer_config.json: 100%" + } + }, + "ad80b6c1cfef4b24a6f105c51bd32950": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b243a50b92de46e5bf3243a7f4d9e16e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b7b96de11eb542aba27c181b80e56505": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb8f25d6c60d42bc939f62c3faab42c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_70082d1423dd4544a9fdadb86993aee5", + "placeholder": "​", + "style": "IPY_MODEL_120471595cb9489db1dec89359b8a870", + "value": "special_tokens_map.json: 100%" + } + }, + "bbee9192025a4e1a9fbafa75c35a873e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c33c6f4ef9f34a59a76c7e35e27fd921": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_37ad21890bbe42d2a5f9e524f63e25e4", + "placeholder": "​", + "style": "IPY_MODEL_04121aeaee374bb2aebd0a9e9e6f4fd8", + "value": " 714/714 [00:00<00:00, 62.4kB/s]" + } + }, + "d7d50a233797471aa428e32e9f796468": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "db6e39b8eff34362b47485ee484560d8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc364663e67d43e59231ef681664e229": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e40c294c089e495fa8055c16d0f6827c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e4579cd2435e4401920668c8ef5d5322": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_197a9551cefe4fcc9b2314d85eea345b", + "placeholder": "​", + "style": "IPY_MODEL_e40c294c089e495fa8055c16d0f6827c", + "value": " 1.11G/1.11G [00:26<00:00, 42.9MB/s]" + } + }, + "e64ac7a366e94de4a14c4d8737562012": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b7b96de11eb542aba27c181b80e56505", + "max": 17082832, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_041a2ee1d1c249ecbac68256c2a0caad", + "value": 17082832 + } + }, + "e7151d48447441e693aa5051bf24225a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e776a0aaf785427d82337d9c279e4979": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ec8ff0112bbd4f3b904c494483efa473": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_87b4325c8fea4258af27529d1c6c0176", + "placeholder": "​", + "style": "IPY_MODEL_e776a0aaf785427d82337d9c279e4979", + "value": " 5.07M/5.07M [00:00<00:00, 15.7MB/s]" + } + }, + "fd3f34046aab42129e57890b533f976c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88dadd458e6c4bbeb0c24593e85ca01c", + "placeholder": "​", + "style": "IPY_MODEL_3f103bd3734c46eead675d345091b009", + "value": "tokenizer.json: 100%" + } + }, + "ff89cbd6d6534f9fb96cfd69065cd1d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_XlmRoBertaSentenceEmbeddings.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_XlmRoBertaSentenceEmbeddings.ipynb index 4cff73dd823aa2..269471933def9d 100644 --- a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_XlmRoBertaSentenceEmbeddings.ipynb +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_XlmRoBertaSentenceEmbeddings.ipynb @@ -421,10 +421,10 @@ "gpuType": "T4", "provenance": [] }, - "kernelspec": ,{ + "kernelspec": { "display_name": "Python 3", "name": "python3" - } + }, "language_info": { "codemirror_mode": { "name": "ipython", diff --git a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_mxbai.ipynb b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_mxbai.ipynb index c09cea1432b6ca..e8ae44495a6288 100644 --- a/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_mxbai.ipynb +++ b/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_mxbai.ipynb @@ -10,9 +10,9 @@ "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/onnx/HuggingFace_ONNX_in_Spark_NLP_mxbai.ipynb)\n", "\n", - "# Import ONNX mxbai models from HuggingFace \ud83e\udd17 into Spark NLP \ud83d\ude80\n", + "# Import ONNX mxbai models from HuggingFace 🤗 into Spark NLP 🚀\n", "\n", - "Let's keep in mind a few things before we start \ud83d\ude0a\n", + "Let's keep in mind a few things before we start 😊\n", "\n", "- ONNX support was introduced in `Spark NLP 5.0.0`, enabling high performance inference for models. Please make sure you have upgraded to the latest Spark NLP release.\n", "- You can import models for mxbai from HuggingFace and they have to be in `Fill Mask` category. Meaning, you cannot use mxbai models trained/fine-tuned on a specific task such as token/sequence classification." @@ -39,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "id": "faBcByOA-LBV", "outputId": "9d84ba9f-c8ac-4c2c-8bae-8068890262ab", @@ -52,23 +52,23 @@ "output_type": "stream", "name": "stdout", "text": [ - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m1.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m8.8/8.8 MB\u001b[0m \u001b[31m28.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m14.6/14.6 MB\u001b[0m \u001b[31m41.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m421.5/421.5 kB\u001b[0m \u001b[31m23.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m13.2/13.2 MB\u001b[0m \u001b[31m53.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m212.7/212.7 kB\u001b[0m \u001b[31m11.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m3.6/3.6 MB\u001b[0m \u001b[31m67.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m527.3/527.3 kB\u001b[0m \u001b[31m26.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m83.8/83.8 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m455.8/455.8 kB\u001b[0m \u001b[31m24.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m4.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m39.9/39.9 MB\u001b[0m \u001b[31m13.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m55.5/55.5 kB\u001b[0m \u001b[31m3.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m11.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m1.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.8/8.8 MB\u001b[0m \u001b[31m28.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.6/14.6 MB\u001b[0m \u001b[31m41.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m421.5/421.5 kB\u001b[0m \u001b[31m23.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.2/13.2 MB\u001b[0m \u001b[31m53.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m212.7/212.7 kB\u001b[0m \u001b[31m11.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.6/3.6 MB\u001b[0m \u001b[31m67.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m527.3/527.3 kB\u001b[0m \u001b[31m26.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m83.8/83.8 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m455.8/455.8 kB\u001b[0m \u001b[31m24.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m4.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m39.9/39.9 MB\u001b[0m \u001b[31m13.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.5/55.5 kB\u001b[0m \u001b[31m3.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m11.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", "cudf-cu12 24.4.1 requires pyarrow<15.0.0a0,>=14.0.1, but you have pyarrow 17.0.0 which is incompatible.\n", "ibis-framework 8.0.0 requires pyarrow<16,>=2, but you have pyarrow 17.0.0 which is incompatible.\u001b[0m\u001b[31m\n", @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "id": "NBrJz3Qt-LBX", "outputId": "1a2d3a70-b990-48fc-9208-385a0b5fff05", @@ -347,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "id": "o2wua50w-LBY", "outputId": "6a89e07d-a509-4d63-b983-576bf64cbf7d", @@ -376,7 +376,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "id": "97ScuGul-LBY", "outputId": "4a1d4520-2ab8-4dc4-f3a5-cc03ac2340c6", @@ -412,7 +412,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "id": "dxCEAixU-LBZ", "outputId": "fe6c7e6f-e793-45d7-9b44-0aa8a0ff1f4b", @@ -427,17 +427,18 @@ "text": [ "Installing PySpark 3.2.3 and Spark NLP 5.4.2\n", "setup Colab for PySpark 3.2.3 and Spark NLP 5.4.2\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m281.5/281.5 MB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m281.5/281.5 MB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m55.6/55.6 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m579.5/579.5 kB\u001b[0m \u001b[31m22.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m199.7/199.7 kB\u001b[0m \u001b[31m13.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.6/55.6 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m579.5/579.5 kB\u001b[0m \u001b[31m22.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.7/199.7 kB\u001b[0m \u001b[31m13.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25h Building wheel for pyspark (setup.py) ... \u001b[?25l\u001b[?25hdone\n" ] } ], "source": [ - "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash\n", + "!pip install pyspark==3.5.0" ] }, { @@ -451,7 +452,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "id": "tWzqJOSe-LBb", "outputId": "b5797072-fd37-4d41-ab22-d88007c74f60", @@ -466,9 +467,9 @@ "text": [ "Collecting spark-nlp==5.5.0rc1\n", " Downloading spark_nlp-5.5.0rc1-py2.py3-none-any.whl.metadata (55 kB)\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m55.8/55.8 kB\u001b[0m \u001b[31m891.3 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.8/55.8 kB\u001b[0m \u001b[31m891.3 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading spark_nlp-5.5.0rc1-py2.py3-none-any.whl (629 kB)\n", - "\u001b[2K \u001b[90m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m \u001b[32m629.6/629.6 kB\u001b[0m \u001b[31m4.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m629.6/629.6 kB\u001b[0m \u001b[31m4.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hInstalling collected packages: spark-nlp\n", " Attempting uninstall: spark-nlp\n", " Found existing installation: spark-nlp 5.4.2\n", @@ -486,7 +487,12 @@ ] } ], - "source": "import sparknlp\n# let's start Spark with Spark NLP\nspark = sparknlp.start()\"\n " + "source": [ + "import sparknlp\n", + "# let's start Spark with Spark NLP\n", + "spark = sparknlp.start()\n", + "" + ] }, { "cell_type": "markdown", @@ -497,7 +503,7 @@ "- Let's use `loadSavedModel` functon in `mxbaiEmbeddings` which allows us to load the ONNX model\n", "- Most params will be set automatically. They can also be set later after loading the model in `mxbaiEmbeddings` during runtime, so don't worry about setting them now\n", "- `loadSavedModel` accepts two params, first is the path to the exported model. The second is the SparkSession that is `spark` variable we previously started via `sparknlp.start()`\n", - "- `setStorageRef` is very important. When you are training a task like NER or any Text Classification, we use this reference to bound the trained model to this specific embeddings so you won't load a different embeddings by mistake and see terrible results \ud83d\ude0a\n", + "- `setStorageRef` is very important. When you are training a task like NER or any Text Classification, we use this reference to bound the trained model to this specific embeddings so you won't load a different embeddings by mistake and see terrible results 😊\n", "- It's up to you what you put in `setStorageRef` but it cannot be changed later on. We usually use the name of the model to be clear, but you can get creative if you want!\n", "- The `dimension` param is is purely cosmetic and won't change anything. It's mostly for you to know later via `.getDimension` what is the dimension of your model. So set this accordingly.\n", "- NOTE: `loadSavedModel` accepts local paths in addition to distributed file systems such as `HDFS`, `S3`, `DBFS`, etc. This feature was introduced in Spark NLP 4.2.2 release. Keep in mind the best and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively.st and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively.\n" @@ -505,7 +511,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { "id": "ZfRgnm5V-LBc" }, @@ -532,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "id": "thmPSatB-LBc" }, @@ -552,7 +558,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "id": "-GbJfqzE-LBc" }, @@ -567,14 +573,14 @@ "id": "CfhLgj1U-LBd" }, "source": [ - "Awesome \ud83d\ude0e !\n", + "Awesome 😎 !\n", "\n", - "This is your ONNX mxbai model from HuggingFace \ud83e\udd17 loaded and saved by Spark NLP \ud83d\ude80" + "This is your ONNX mxbai model from HuggingFace 🤗 loaded and saved by Spark NLP 🚀" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "id": "9irc4X-h-LBe", "colab": { @@ -604,12 +610,12 @@ "id": "q6kMLGGM-LBe" }, "source": [ - "Now let's see how we can use it on other machines, clusters, or any place you wish to use your new and shiny mxbai model \ud83d\ude0a" + "Now let's see how we can use it on other machines, clusters, or any place you wish to use your new and shiny mxbai model 😊" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "id": "EuxOV23j-LBf" }, @@ -648,12 +654,12 @@ "metadata": { "id": "d3LjIpizF06G" }, - "execution_count": 12, + "execution_count": null, "outputs": [] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "id": "ayJxQu9P-LBf", "colab": { @@ -685,7 +691,7 @@ "id": "5YWVcqLf-LBf" }, "source": [ - "That's it! You can now go wild and use hundreds of mxbai models from HuggingFace \ud83e\udd17 in Spark NLP \ud83d\ude80\n" + "That's it! You can now go wild and use hundreds of mxbai models from HuggingFace 🤗 in Spark NLP 🚀\n" ] } ], @@ -749,9 +755,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_3dad1fc16bec46a6b35a7a8525c0299f", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_f9e07397159b4aaea2bf2786823b714d", - "value": "config.json:\u2007100%" + "value": "config.json: 100%" } }, "378a2015d90d4545bf1ab75c5e8865e4": { @@ -794,9 +800,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_6f3acd55795f42d3a9eb2a65815653fd", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_b11059c67669456ca3e5c0861cc0a028", - "value": "\u2007677/677\u2007[00:00<00:00,\u200742.3kB/s]" + "value": " 677/677 [00:00<00:00, 42.3kB/s]" } }, "ed2d71aae52d4b0083cfeb46ec9ba48f": { @@ -1091,9 +1097,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_295a6e5a5e654dc18ce6e88b9567f383", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_c91e229854ce48478f218791ad762f5b", - "value": "model.safetensors:\u2007100%" + "value": "model.safetensors: 100%" } }, "03b23811c34d485c90ea47ae226ac851": { @@ -1136,9 +1142,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_73c126216e6d4dc1b5c2aa3492d364f7", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_0a89bb30a86948aca977f9c58a111011", - "value": "\u2007670M/670M\u2007[00:06<00:00,\u2007130MB/s]" + "value": " 670M/670M [00:06<00:00, 130MB/s]" } }, "66ca1e17db024917a7b0a6d08083eec3": { @@ -1433,9 +1439,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_56cea75abf754df7a69b7c7f170077d8", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_81fa13469d0a4979a42578e18cb853ff", - "value": "tokenizer_config.json:\u2007100%" + "value": "tokenizer_config.json: 100%" } }, "b619910c1842468b8fe68be4e6de5a78": { @@ -1478,9 +1484,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_60b45e155a12462e959c2233a89de214", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_387e0f0772b044c78cceb488ac04c030", - "value": "\u20071.24k/1.24k\u2007[00:00<00:00,\u200735.5kB/s]" + "value": " 1.24k/1.24k [00:00<00:00, 35.5kB/s]" } }, "039a16df2dc64a20be8ffd6c335d2c6a": { @@ -1775,9 +1781,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_ee50d01675ae4a3f88fe4d1a62afbc44", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_3f9d0d9adee04c7abccafa7ff21ae3e9", - "value": "vocab.txt:\u2007100%" + "value": "vocab.txt: 100%" } }, "a5741df93ecd40d280aa4404d32182d8": { @@ -1820,9 +1826,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_9464a43340ec4f83897268fa26556962", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_4e0fda0ee64b40d1bbe53db0a36df99e", - "value": "\u2007232k/232k\u2007[00:00<00:00,\u2007789kB/s]" + "value": " 232k/232k [00:00<00:00, 789kB/s]" } }, "7818b970edd246018514956dd60b5876": { @@ -2117,9 +2123,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_b252854d497746959f8a2446450f4e7b", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_1855b9a52d4440ba9bea4fd1924efff6", - "value": "tokenizer.json:\u2007100%" + "value": "tokenizer.json: 100%" } }, "aea9930e5a1449f98702cdcc276c20cd": { @@ -2162,9 +2168,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_0e52a746cdfa44708dc0bc6573266fd4", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_7e8c9d3dc32248269742f5fa6193dfef", - "value": "\u2007711k/711k\u2007[00:00<00:00,\u20076.81MB/s]" + "value": " 711k/711k [00:00<00:00, 6.81MB/s]" } }, "ee949690459545a2a3cac45986c3c75b": { @@ -2459,9 +2465,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_5536334d144c4b69a5daa9b23cebd6e6", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_cf6a5bac1e734decb1ec4777a14c30f8", - "value": "special_tokens_map.json:\u2007100%" + "value": "special_tokens_map.json: 100%" } }, "68562952ce664883afdce051240467a4": { @@ -2504,9 +2510,9 @@ "description": "", "description_tooltip": null, "layout": "IPY_MODEL_a375b3cbc1394df6bb4fd8b4045ab980", - "placeholder": "\u200b", + "placeholder": "​", "style": "IPY_MODEL_a5097fe765ff4af6865d0328986d233d", - "value": "\u2007695/695\u2007[00:00<00:00,\u200732.4kB/s]" + "value": " 695/695 [00:00<00:00, 32.4kB/s]" } }, "1a543a3eae694bfeab7b2a5f06f52431": { diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_AlbertForMultipleChoice.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_AlbertForMultipleChoice.ipynb new file mode 100644 index 00000000000000..26b152eeb84987 --- /dev/null +++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_AlbertForMultipleChoice.ipynb @@ -0,0 +1,2903 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "_V5XcDCnVgSi" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_AlbertForMultipleChoice..ipynb)\n", + "\n", + "# Import OpenVINO AlbertForMultipleChoice models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "This notebook provides a detailed walkthrough on optimizing and exporting AlbertForMultipleChoice models from HuggingFace for use in Spark NLP, leveraging the various tools provided in the [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html) ecosystem.\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- OpenVINO support was introduced in `Spark NLP 5.4.0`, enabling high performance inference for models. Please make sure you have upgraded to the latest Spark NLP release.\n", + "- You can import models for AlbertForMultipleChoice from ALBERT and they have to be in `For Multiple Choice` category." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aghasVppVgSk" + }, + "source": [ + "## 1. Export and Save the HuggingFace model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "be4HsTDMVgSk" + }, + "source": [ + "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n", + "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future releases, but we wanted you to know which versions have been tested successfully." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-7L-2ZWUVgSl", + "outputId": "132f54a4-06ec-42d1-a9ef-f1866d0ec6d9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.8/43.8 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9.1/9.1 MB\u001b[0m \u001b[31m76.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.6/3.6 MB\u001b[0m \u001b[31m66.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m38.7/38.7 MB\u001b[0m \u001b[31m23.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m215.7/215.7 kB\u001b[0m \u001b[31m18.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m480.6/480.6 kB\u001b[0m \u001b[31m40.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m424.1/424.1 kB\u001b[0m \u001b[31m31.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m102.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.3/179.3 kB\u001b[0m \u001b[31m16.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m12.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m17.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m9.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.1/13.1 MB\u001b[0m \u001b[31m30.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m57.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "google-ai-generativelanguage 0.6.10 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-api-core 2.19.2 requires protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0.dev0,>=3.19.5, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-aiplatform 1.74.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-bigquery-connection 1.17.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-bigquery-storage 2.27.0 requires protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-bigtable 2.27.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-datastore 2.20.2 requires protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-firestore 2.19.0 requires protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-functions 1.19.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-iam 2.17.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-language 2.16.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-pubsub 2.27.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-resource-manager 1.14.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-translate 3.19.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "googleapis-common-protos 1.66.0 requires protobuf!=3.20.0,!=3.20.1,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0.dev0,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "grpc-google-iam-v1 0.13.1 requires protobuf!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.1 which is incompatible.\n", + "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.1 which is incompatible.\n", + "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.1 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install -q --upgrade transformers==4.41.2\n", + "!pip install -q --upgrade openvino==2024.1\n", + "!pip install -q --upgrade optimum-intel==1.17.0\n", + "!pip install -q --upgrade onnx==1.12.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vI7uz_6hVgSl" + }, + "source": [ + "[Optimum Intel](https://github.com/huggingface/optimum-intel?tab=readme-ov-file#openvino) is the interface between the Transformers library and the various model optimization and acceleration tools provided by Intel. HuggingFace models loaded with optimum-intel are automatically optimized for OpenVINO, while being compatible with the Transformers API.\n", + "- Normally, to load a HuggingFace model directly for inference/export, just replace the `AutoModelForXxx` class with the corresponding `OVModelForXxx` class. However, ForMultipleChoice is not yet available so we will use `openvino.convert_model()` after exporting ONNX model\n", + "- We'll use [Ariffiq99/CRAB_COPA_KUCI_e_care_albert_Base_Finetuned](https://huggingface.co/Ariffiq99/CRAB_COPA_KUCI_e_care_albert_Base_Finetuned) model from HuggingFace as an example\n", + "- We also need the `spiece.model` for the Tokenizer. This is the same for every model, these are assets (saved in `/assets`) needed for tokenization inside Spark NLP." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TDapJ_09nqXQ", + "outputId": "80fd3e48-9a26-4b7a-8a77-fbcf263a4f41" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: pip in /usr/local/lib/python3.10/dist-packages (24.1.2)\n", + "Collecting pip\n", + " Downloading pip-24.3.1-py3-none-any.whl.metadata (3.7 kB)\n", + "Downloading pip-24.3.1-py3-none-any.whl (1.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m50.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: pip\n", + " Attempting uninstall: pip\n", + " Found existing installation: pip 24.1.2\n", + " Uninstalling pip-24.1.2:\n", + " Successfully uninstalled pip-24.1.2\n", + "Successfully installed pip-24.3.1\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m154.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.0/3.0 MB\u001b[0m \u001b[31m107.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.1/10.1 MB\u001b[0m \u001b[31m164.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m54.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.2 which is incompatible.\n", + "optimum-intel 1.17.0 requires transformers<4.42.0,>=4.36.0, but you have transformers 4.47.1 which is incompatible.\n", + "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install --upgrade pip\n", + "!pip install -q --upgrade transformers[onnx] optimum openvino==2024.1" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 313, + "referenced_widgets": [ + "b290505d643f4b55b53d321b7a3b7173", + "d5d0a4b4e6ec4930b7d9a63570c5f628", + "1227b58f17714176b3d4f214e9a9a6ab", + "37da5707cece4783b0156359e59855dd", + "812a25b979bc4fcdb16a4cfcf3edf514", + "532f8611f3874da8840129b2db849434", + "75a3920d9fbb4ce69c82d7188f1723fe", + "322472e75c82489f8fb60195d9b2423e", + "959d91379231457683a338e40433a622", + "7a47aefb34314b518f5d658dc7a43e95", + "04aa5c39a0de4890b0c2c1d896898980", + "a3087040ac924bc48d5c0f499e5fb013", + "7d16ef5ff9cb45738b582e813c8432c6", + "b17129cfbece4d8395c3797524f5bfda", + "df6e4f2516754d8998c024914c359197", + "df3c5e3409dc4c63bf4f82b623692755", + "9c5fb2b927a84959b1994753cc1bc795", + "5f4c10fd4f354aa890b9b9d77b70a4f2", + "338041f26ac94c1e9b0050822b3d2ce5", + "57446a6c5f6540aa8186b6d1b45eb8a0", + "ec733c40e8c34b7799bf6649eb8d3204", + "6f4f194995a54a768cb1745e058ebdb4", + "d8f38d77054c49ba8ef8219a46835c6a", + "5606f6413bc24e98ac82738eb6b77352", + "c72b72dd936f43ca9e7b43d8ddaf07e5", + "10d731456a4f4191a3f5314f291e5d6a", + "0864bcd49347402fb361b936e809e8b5", + "4ba486719c4346a39f7a370b14615bda", + "5c06ce14a17a4379b68715a39d415f47", + "a65d309c4b594219a376cb0c1090b771", + "5b40f96a47a044a591d3b90d00107fcd", + "968e53c4ba3a4e2fb997033acb3aed0c", + "de73f6ed034d461487fabda18e300d5a", + "bfc4493fd3db439dac341667459f69f1", + "ec4fcdf171ca40eea96c43b81ddfa0a4", + "6439b0871cb74e9cb356b902c8a59032", + "98f33af7917546bbb2810b02d074c3fb", + "1a8c88e7890347d6b4905ef82864f455", + "cbb2ae4aaf384a32984e517f09717d51", + "c611475f56134802abd842b4460ff431", + "cab619bce0c74ec5b6530d01b93d9b62", + "9997518db62f4006a88b706d6f9c7fa3", + "64b3823221904eb28019dea6aefc4997", + "dacbc568ea88490289e37598beb78f08", + "3e58d77978364f35902afdc2be9a9b44", + "cfc1f531d5e645f5b3a4c04b1292957f", + "523b7bc7b387485580ff424dc24fa763", + "8fac9a91dfe648c0b20d714711b4a35a", + "8abcb56f574148928c687174a9ef39b5", + "011ecb9cf9544dde898ae74b2b2e431d", + "69130a78308a4763b33cc41b199f72fc", + "f52636bcf35c47f78d12379a53b5616e", + "6f0bac3fcb214b2dbed4f275afbf999c", + "f765cb1a1fca4711a781b15c79a577b8", + "15a2b5f09571454a9b7564bfd5422988", + "3ab40c11ced64bea9f65deea308bd91c", + "f6586a0726704b1dbc7cca992dad4c40", + "db301c8a0e90423f834bba34d3e2ce6a", + "c76db86d92694c0695dd84a4569e63d7", + "744c1e5bf1a04328b751ac2540d0d2b7", + "0257e8b83d0b4b5b810d5b9dbff81087", + "f0441c125ec44e558b927c3d6733e16e", + "fb17131bd9584b16b3fba62b717c46c9", + "c35c725dc3024614bdef0d7f4140105e", + "a401e3458bba49279572b3cf723ac58e", + "fdcec4bc637f4cd384c6e06fb05fb744" + ] + }, + "id": "_b89GvQKosA0", + "outputId": "25eeadc1-aba4-4ad9-856e-214f9855bbd2" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n", + "The secret `HF_TOKEN` does not exist in your Colab secrets.\n", + "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n", + "You will be able to reuse this secret in all of your notebooks.\n", + "Please note that authentication is recommended but still optional to access public models or datasets.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b290505d643f4b55b53d321b7a3b7173", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "config.json: 0%| | 0.00/866 [00:00 0, chunk -> 0, score -> 0.5146987}, []}]|\n", + "|[{chunk, 0, 6, France, {sentence -> 0, chunk -> 0, score -> 0.34097242}, []}] |\n", + "|[{chunk, 0, 3, Lion, {sentence -> 0, chunk -> 0, score -> 0.26465067}, []}] |\n", + "|[{chunk, 0, 3, 90°C, {sentence -> 0, chunk -> 0, score -> 0.34688318}, []}] |\n", + "|[{chunk, 0, 5, Venus, {sentence -> 0, chunk -> 0, score -> 0.35853413}, []}] |\n", + "|[{chunk, 0, 7, English, {sentence -> 0, chunk -> 0, score -> 0.38890713}, []}] |\n", + "|[{chunk, 0, 9, The Greeks, {sentence -> 0, chunk -> 0, score -> 0.29366478}, []}] |\n", + "|[{chunk, 0, 5, Ozone, {sentence -> 0, chunk -> 0, score -> 0.34738493}, []}] |\n", + "|[{chunk, 0, 6, Africa, {sentence -> 0, chunk -> 0, score -> 0.35337886}, []}] |\n", + "|[{chunk, 0, 15, Vincent van Gogh, {sentence -> 0, chunk -> 0, score -> 0.37136987}, []}] |\n", + "+----------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from sparknlp.base import *\n", + "from sparknlp.annotator import *\n", + "from pyspark.ml import Pipeline, PipelineModel\n", + "\n", + "document_assembler = MultiDocumentAssembler() \\\n", + " .setInputCols([\"question\", \"choices\"]) \\\n", + " .setOutputCols([\"document_question\", \"document_choices\"])\n", + "\n", + "albert_for_multiple_choice = AlbertForMultipleChoice() \\\n", + " .load(f\"{MODEL_NAME}_spark_nlp_openvino\") \\\n", + " .setInputCols([\"document_question\", \"document_choices\"])\\\n", + " .setOutputCol(\"answer\") \\\n", + " .setBatchSize(4)\n", + "\n", + "pipeline = Pipeline(stages=[document_assembler, albert_for_multiple_choice])\n", + "pipeline_model = pipeline.fit(testing_df)\n", + "\n", + "pipeline_df = pipeline_model.transform(testing_df)\n", + "\n", + "pipeline_df.select(\"answer\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lpxiq1igoj6c" + }, + "source": [ + "That's it! You can now go wild and use hundreds of `AlbertForMultipleChoice` models from HuggingFace 🤗 in Spark NLP 🚀\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "011ecb9cf9544dde898ae74b2b2e431d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0257e8b83d0b4b5b810d5b9dbff81087": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04aa5c39a0de4890b0c2c1d896898980": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0864bcd49347402fb361b936e809e8b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "10d731456a4f4191a3f5314f291e5d6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_968e53c4ba3a4e2fb997033acb3aed0c", + "placeholder": "​", + "style": "IPY_MODEL_de73f6ed034d461487fabda18e300d5a", + "value": " 1.41k/1.41k [00:00<00:00, 126kB/s]" + } + }, + "1227b58f17714176b3d4f214e9a9a6ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_322472e75c82489f8fb60195d9b2423e", + "max": 866, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_959d91379231457683a338e40433a622", + "value": 866 + } + }, + "15a2b5f09571454a9b7564bfd5422988": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a8c88e7890347d6b4905ef82864f455": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "322472e75c82489f8fb60195d9b2423e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "338041f26ac94c1e9b0050822b3d2ce5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37da5707cece4783b0156359e59855dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a47aefb34314b518f5d658dc7a43e95", + "placeholder": "​", + "style": "IPY_MODEL_04aa5c39a0de4890b0c2c1d896898980", + "value": " 866/866 [00:00<00:00, 75.3kB/s]" + } + }, + "3ab40c11ced64bea9f65deea308bd91c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f6586a0726704b1dbc7cca992dad4c40", + "IPY_MODEL_db301c8a0e90423f834bba34d3e2ce6a", + "IPY_MODEL_c76db86d92694c0695dd84a4569e63d7" + ], + "layout": "IPY_MODEL_744c1e5bf1a04328b751ac2540d0d2b7" + } + }, + "3e58d77978364f35902afdc2be9a9b44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cfc1f531d5e645f5b3a4c04b1292957f", + "IPY_MODEL_523b7bc7b387485580ff424dc24fa763", + "IPY_MODEL_8fac9a91dfe648c0b20d714711b4a35a" + ], + "layout": "IPY_MODEL_8abcb56f574148928c687174a9ef39b5" + } + }, + "4ba486719c4346a39f7a370b14615bda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "523b7bc7b387485580ff424dc24fa763": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f52636bcf35c47f78d12379a53b5616e", + "max": 2272611, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6f0bac3fcb214b2dbed4f275afbf999c", + "value": 2272611 + } + }, + "532f8611f3874da8840129b2db849434": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5606f6413bc24e98ac82738eb6b77352": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4ba486719c4346a39f7a370b14615bda", + "placeholder": "​", + "style": "IPY_MODEL_5c06ce14a17a4379b68715a39d415f47", + "value": "tokenizer_config.json: 100%" + } + }, + "57446a6c5f6540aa8186b6d1b45eb8a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5b40f96a47a044a591d3b90d00107fcd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5c06ce14a17a4379b68715a39d415f47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5f4c10fd4f354aa890b9b9d77b70a4f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6439b0871cb74e9cb356b902c8a59032": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cab619bce0c74ec5b6530d01b93d9b62", + "max": 760289, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9997518db62f4006a88b706d6f9c7fa3", + "value": 760289 + } + }, + "64b3823221904eb28019dea6aefc4997": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "69130a78308a4763b33cc41b199f72fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6f0bac3fcb214b2dbed4f275afbf999c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6f4f194995a54a768cb1745e058ebdb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "744c1e5bf1a04328b751ac2540d0d2b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "75a3920d9fbb4ce69c82d7188f1723fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7a47aefb34314b518f5d658dc7a43e95": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d16ef5ff9cb45738b582e813c8432c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9c5fb2b927a84959b1994753cc1bc795", + "placeholder": "​", + "style": "IPY_MODEL_5f4c10fd4f354aa890b9b9d77b70a4f2", + "value": "model.safetensors: 100%" + } + }, + "812a25b979bc4fcdb16a4cfcf3edf514": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8abcb56f574148928c687174a9ef39b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8fac9a91dfe648c0b20d714711b4a35a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f765cb1a1fca4711a781b15c79a577b8", + "placeholder": "​", + "style": "IPY_MODEL_15a2b5f09571454a9b7564bfd5422988", + "value": " 2.27M/2.27M [00:00<00:00, 3.53MB/s]" + } + }, + "959d91379231457683a338e40433a622": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "968e53c4ba3a4e2fb997033acb3aed0c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "98f33af7917546bbb2810b02d074c3fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_64b3823221904eb28019dea6aefc4997", + "placeholder": "​", + "style": "IPY_MODEL_dacbc568ea88490289e37598beb78f08", + "value": " 760k/760k [00:00<00:00, 50.3MB/s]" + } + }, + "9997518db62f4006a88b706d6f9c7fa3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9c5fb2b927a84959b1994753cc1bc795": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a3087040ac924bc48d5c0f499e5fb013": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7d16ef5ff9cb45738b582e813c8432c6", + "IPY_MODEL_b17129cfbece4d8395c3797524f5bfda", + "IPY_MODEL_df6e4f2516754d8998c024914c359197" + ], + "layout": "IPY_MODEL_df3c5e3409dc4c63bf4f82b623692755" + } + }, + "a401e3458bba49279572b3cf723ac58e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a65d309c4b594219a376cb0c1090b771": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b17129cfbece4d8395c3797524f5bfda": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_338041f26ac94c1e9b0050822b3d2ce5", + "max": 46740836, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_57446a6c5f6540aa8186b6d1b45eb8a0", + "value": 46740836 + } + }, + "b290505d643f4b55b53d321b7a3b7173": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d5d0a4b4e6ec4930b7d9a63570c5f628", + "IPY_MODEL_1227b58f17714176b3d4f214e9a9a6ab", + "IPY_MODEL_37da5707cece4783b0156359e59855dd" + ], + "layout": "IPY_MODEL_812a25b979bc4fcdb16a4cfcf3edf514" + } + }, + "bfc4493fd3db439dac341667459f69f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ec4fcdf171ca40eea96c43b81ddfa0a4", + "IPY_MODEL_6439b0871cb74e9cb356b902c8a59032", + "IPY_MODEL_98f33af7917546bbb2810b02d074c3fb" + ], + "layout": "IPY_MODEL_1a8c88e7890347d6b4905ef82864f455" + } + }, + "c35c725dc3024614bdef0d7f4140105e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c611475f56134802abd842b4460ff431": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c72b72dd936f43ca9e7b43d8ddaf07e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a65d309c4b594219a376cb0c1090b771", + "max": 1412, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5b40f96a47a044a591d3b90d00107fcd", + "value": 1412 + } + }, + "c76db86d92694c0695dd84a4569e63d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a401e3458bba49279572b3cf723ac58e", + "placeholder": "​", + "style": "IPY_MODEL_fdcec4bc637f4cd384c6e06fb05fb744", + "value": " 970/970 [00:00<00:00, 81.3kB/s]" + } + }, + "cab619bce0c74ec5b6530d01b93d9b62": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cbb2ae4aaf384a32984e517f09717d51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cfc1f531d5e645f5b3a4c04b1292957f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_011ecb9cf9544dde898ae74b2b2e431d", + "placeholder": "​", + "style": "IPY_MODEL_69130a78308a4763b33cc41b199f72fc", + "value": "tokenizer.json: 100%" + } + }, + "d5d0a4b4e6ec4930b7d9a63570c5f628": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_532f8611f3874da8840129b2db849434", + "placeholder": "​", + "style": "IPY_MODEL_75a3920d9fbb4ce69c82d7188f1723fe", + "value": "config.json: 100%" + } + }, + "d8f38d77054c49ba8ef8219a46835c6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5606f6413bc24e98ac82738eb6b77352", + "IPY_MODEL_c72b72dd936f43ca9e7b43d8ddaf07e5", + "IPY_MODEL_10d731456a4f4191a3f5314f291e5d6a" + ], + "layout": "IPY_MODEL_0864bcd49347402fb361b936e809e8b5" + } + }, + "dacbc568ea88490289e37598beb78f08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "db301c8a0e90423f834bba34d3e2ce6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fb17131bd9584b16b3fba62b717c46c9", + "max": 970, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c35c725dc3024614bdef0d7f4140105e", + "value": 970 + } + }, + "de73f6ed034d461487fabda18e300d5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "df3c5e3409dc4c63bf4f82b623692755": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df6e4f2516754d8998c024914c359197": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ec733c40e8c34b7799bf6649eb8d3204", + "placeholder": "​", + "style": "IPY_MODEL_6f4f194995a54a768cb1745e058ebdb4", + "value": " 46.7M/46.7M [00:01<00:00, 43.2MB/s]" + } + }, + "ec4fcdf171ca40eea96c43b81ddfa0a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cbb2ae4aaf384a32984e517f09717d51", + "placeholder": "​", + "style": "IPY_MODEL_c611475f56134802abd842b4460ff431", + "value": "spiece.model: 100%" + } + }, + "ec733c40e8c34b7799bf6649eb8d3204": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0441c125ec44e558b927c3d6733e16e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f52636bcf35c47f78d12379a53b5616e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f6586a0726704b1dbc7cca992dad4c40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0257e8b83d0b4b5b810d5b9dbff81087", + "placeholder": "​", + "style": "IPY_MODEL_f0441c125ec44e558b927c3d6733e16e", + "value": "special_tokens_map.json: 100%" + } + }, + "f765cb1a1fca4711a781b15c79a577b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb17131bd9584b16b3fba62b717c46c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fdcec4bc637f4cd384c6e06fb05fb744": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_CoHere.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_CoHere.ipynb new file mode 100644 index 00000000000000..2d4f3efba97653 --- /dev/null +++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_CoHere.ipynb @@ -0,0 +1,2498 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "FvX_yCcI4W7D" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_CoHere.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8J48sFcb4W7G" + }, + "source": [ + "# Import OpenVINO CoHere models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "This notebook provides a detailed walkthrough on optimizing and importing CoHere models from HuggingFace for use in Spark NLP, with [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html). The focus is on converting the model to the OpenVINO format and applying precision optimizations (INT8 and INT4), to enhance the performance and efficiency on CPU platforms using [Optimum Intel](https://huggingface.co/docs/optimum/main/en/intel/inference).\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- OpenVINO support was introduced in `Spark NLP 5.4.0`, enabling high performance CPU inference for models. So please make sure you have upgraded to the latest Spark NLP release.\n", + "- Model quantization is a computationally expensive process, so it is recommended to use a runtime with more than 32GB memory for exporting the quantized model from HuggingFace.\n", + "- You can import CoHere models via `CoHereModel`. These models are usually under `Text Generation` category and have `CoHere` in their labels.\n", + "- Reference: [CoHereModel](https://huggingface.co/docs/transformers/model_doc/CoHereTransformer#transformers.CoHereModel)\n", + "- Some [example models](https://huggingface.co/models?search=CoHere)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ko24PkTd4W7H" + }, + "source": [ + "## 1. Export and Save the HuggingFace model\n", + "\n", + "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n", + "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future release, but we wanted you to know which versions have been tested successfully." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2rOdslOi4W7H", + "outputId": "0fe0d124-f09d-4fc0-b822-655d7b616125" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n", + "Note: you may need to restart the kernel to use updated packages.\n", + "Note: you may need to restart the kernel to use updated packages.\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install -q \"nncf>=2.14.0\" \"torch>=2.3\" \"transformers>=4.39.1\" \"accelerate\" \"pillow\" \"gradio>=4.26\" \"datasets>=2.14.6\" \"tqdm\" --extra-index-url https://download.pytorch.org/whl/cpu\n", + "%pip install -q -U \"openvino>=2024.5.0\" \"openvino-tokenizers>=2024.5.0\" \"openvino-genai>=2024.5\"\n", + "%pip install -q \"git+https://github.com/huggingface/optimum-intel.git\" --extra-index-url https://download.pytorch.org/whl/cpu\n", + "%pip install -q ipywidgets" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 145, + "referenced_widgets": [ + "8420c288f5e44084af6589d767899664", + "a03258e8bcb241b2be89ac5c03fba9fe", + "0540ea7b02994fa1a8318a7d2f38c12c", + "4f57921b6c234eabae3f424afe3c04b5", + "97bca2fe9b06436ab7174a8e0b921fcf", + "529731f33fb242d9a1d283931beaa70f", + "1b76dafe2da64c1fa55e52a5f83715c9", + "8087b4ffd55b450ca453fd4c5ffd21f9", + "ee6313eca4be4f6b9d386b2c27624452", + "e23e8b6170294d4999b90a293da45b19", + "452dbb332660410ca9b94d11017075c0", + "f15d2dd70cee40899a34443cd1589e21", + "b20f5c394c9b4c7e9a7d68c1c1dd89ba", + "374c8537fa7443d4aa6f6b8047fc090b", + "8cecf94197a040e88791faddd5df7698", + "d52ee940ddd64d44aa8d08ad032f4225", + "65686043fcb4475baa17734312cc7f7d", + "6d4a762cf1f847a59c5e2acf27d3780b", + "cb0cf954d70d4a20b45b6a7a5508d05d", + "174693aa52194cae9bde419572ac117e", + "ec830e5068ef40a7b596fef9908e9c0b", + "9f994a6df3b94907a6da46c63209dac2", + "1ca22e25121b4d36a7a8bd88c6d39efe", + "3154cd7ba0b841bf909030a40dba671a", + "68b4590ad1bf4eebb05be97c3445bf11", + "90ac8ccbb2c447b79064050316b4fa1e", + "446c4a71c2574673b4f54d06ff24a4ba", + "12e23151dcc74313be8c7e02b0f4ea05", + "613ffc0f9ac74c0fab8f3cb05f9deb43", + "8cf69353a540492a8f81795d635e9069", + "9802c5078cb245a793c8ab8a97e370ca", + "4fed2ab467c94954b8b463b96c751715" + ] + }, + "id": "bYxXi0Gr4W7J", + "outputId": "a421b770-6287-439a-c892-816448fc23f5" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6237118d2c1e42a687289d6dc49e3389", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value='
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "`optimum-cli export openvino --model CohereForAI/c4ai-command-r-v01 /mnt/research/c4ai-command-r-v01/INT4 --weight-format int4 --task text-generation-with-past --group-size 128 --ratio 1 --all-layers`" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/prabod/anaconda3/envs/cohere/lib/python3.9/importlib/util.py:245: DeprecationWarning: The `openvino.runtime` module is deprecated and will be removed in the 2026.0 release. Please replace `openvino.runtime` with `openvino`.\n", + " self.__spec__.loader.exec_module(self)\n", + "Loading checkpoint shards: 100%|██████████| 15/15 [00:03<00:00, 4.13it/s]\n", + "`loss_type=None` was set in the config but it is unrecognised.Using the default loss: `ForCausalLMLoss`.\n", + "/home/prabod/anaconda3/envs/cohere/lib/python3.9/site-packages/transformers/cache_utils.py:460: TracerWarning: Using len to get tensor shape might cause the trace to be incorrect. Recommended usage would be tensor.shape[0]. Passing a tensor of different shape might lead to errors or silently give incorrect results.\n", + " or len(self.key_cache[layer_idx]) == 0 # the layer has no cache\n", + "/home/prabod/anaconda3/envs/cohere/lib/python3.9/site-packages/optimum/exporters/openvino/model_patcher.py:515: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n", + " if sequence_length != 1:\n", + "/home/prabod/anaconda3/envs/cohere/lib/python3.9/site-packages/transformers/cache_utils.py:444: TracerWarning: Using len to get tensor shape might cause the trace to be incorrect. Recommended usage would be tensor.shape[0]. Passing a tensor of different shape might lead to errors or silently give incorrect results.\n", + " len(self.key_cache[layer_idx]) == 0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:nncf:Statistics of the bitwidth distribution:\n", + "┍━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑\n", + "│ Weight compression mode │ % all parameters (layers) │ % ratio-defining parameters (layers) │\n", + "┝━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┥\n", + "│ int4_asym │ 100% (281 / 281) │ 100% (281 / 281) │\n", + "┕━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┙\n", + "\u001b[2KApplying Weight Compression \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[35m100%\u001b[0m • \u001b[36m0:04:08\u001b[0m • \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:08\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "from cmd_helper import optimum_cli\n", + "\n", + "model_id = \"CohereForAI/c4ai-command-r-v01\"\n", + "model_path = Path(model_id.split(\"/\")[-1]) / \"INT4\"\n", + "\n", + "model_path = \"/mnt/research\" / model_path\n", + "if not model_path.exists():\n", + " optimum_cli(\n", + " model_id,\n", + " model_path,\n", + " additional_args={\"weight-format\": \"int4\", \"task\": \"text-generation-with-past\",\"group-size\": \"128\", \"ratio\": \"1\", \"all-layers\": \"\"},\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n4_STbc7kJji" + }, + "source": [ + "Once the model export and quantization is complete, move the model assets needed for tokenization in Spark NLP to the `assets` directory." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PP6xDXDC4W7K" + }, + "source": [ + "Let's have a look inside these two directories and see what we are dealing with:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "EXPORT_PATH = model_path" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EOLmL1S14W7K", + "outputId": "32f9bf09-3b78-43b8-e250-9bc24aa4d4ad" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 17G\n", + "drwxrwxr-x 3 prabod prabod 4.0K Feb 13 09:13 .\n", + "drwxrwxr-x 3 prabod prabod 4.0K Feb 13 09:02 ..\n", + "drwxrwxr-x 2 prabod prabod 4.0K Feb 13 09:13 assets\n", + "-rw-rw-r-- 1 prabod prabod 810 Feb 13 09:02 config.json\n", + "-rw-rw-r-- 1 prabod prabod 137 Feb 13 09:02 generation_config.json\n", + "-rw-rw-r-- 1 prabod prabod 2.8M Feb 13 09:06 openvino_detokenizer.bin\n", + "-rw-rw-r-- 1 prabod prabod 23K Feb 13 09:06 openvino_detokenizer.xml\n", + "-rw-rw-r-- 1 prabod prabod 17G Feb 13 09:11 openvino_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 3.4M Feb 13 09:11 openvino_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 6.6M Feb 13 09:06 openvino_tokenizer.bin\n", + "-rw-rw-r-- 1 prabod prabod 40K Feb 13 09:06 openvino_tokenizer.xml\n", + "-rw-rw-r-- 1 prabod prabod 439 Feb 13 09:02 special_tokens_map.json\n", + "-rw-rw-r-- 1 prabod prabod 21K Feb 13 09:02 tokenizer_config.json\n", + "-rw-rw-r-- 1 prabod prabod 20M Feb 13 09:02 tokenizer.json\n" + ] + } + ], + "source": [ + "!ls -lah {EXPORT_PATH}" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "assets_dir = EXPORT_PATH / \"assets\"\n", + "assets_dir.mkdir(exist_ok=True)\n", + "\n", + "# copy all the assets to the assets directory (json files, vocab files, etc.)\n", + "\n", + "import shutil\n", + "\n", + "# copy all json files\n", + "\n", + "for file in EXPORT_PATH.glob(\"*.json\"):\n", + " shutil.copy(file, assets_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zQ1SbNAc4W7K", + "outputId": "bbb93961-3dbf-459f-d3c0-bdca7965bf53" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 19692\n", + "-rw-rw-r-- 1 prabod prabod 810 Feb 13 09:13 config.json\n", + "-rw-rw-r-- 1 prabod prabod 137 Feb 13 09:13 generation_config.json\n", + "-rw-rw-r-- 1 prabod prabod 439 Feb 13 09:13 special_tokens_map.json\n", + "-rw-rw-r-- 1 prabod prabod 20749 Feb 13 09:13 tokenizer_config.json\n", + "-rw-rw-r-- 1 prabod prabod 20124090 Feb 13 09:13 tokenizer.json\n" + ] + } + ], + "source": [ + "!ls -l {EXPORT_PATH}/assets" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "svbT3OG24W7L" + }, + "source": [ + "## 2. Import and Save CoHere in Spark NLP\n", + "\n", + "- Let's install and setup Spark NLP in Google Colab\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "z6TWf2r14W7L" + }, + "outputs": [], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OYI03iqp4W7L" + }, + "source": [ + "Let's start Spark with Spark NLP included via our simple `start()` function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7_Oy0zMi4W7L" + }, + "outputs": [], + "source": [ + "import sparknlp\n", + "\n", + "# let's start Spark with Spark NLP\n", + "spark = sparknlp.start()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aXCJqb9i4W7M" + }, + "source": [ + "- Let's use `loadSavedModel` functon in `CoHereTransformer` which allows us to load the OpenVINO model.\n", + "- Most params will be set automatically. They can also be set later after loading the model in `CoHereTransformer` during runtime, so don't worry about setting them now.\n", + "- `loadSavedModel` accepts two params, first is the path to the exported model. The second is the SparkSession that is `spark` variable we previously started via `sparknlp.start()`\n", + "- NOTE: `loadSavedModel` accepts local paths in addition to distributed file systems such as `HDFS`, `S3`, `DBFS`, etc. This feature was introduced in Spark NLP 4.2.2 release. Keep in mind the best and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively.st and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "T3591W9R4W7M" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "25/02/13 09:19:52 WARN NativeLibrary: Failed to load library null: java.lang.UnsatisfiedLinkError: Can't load library: /tmp/openvino-native14220754060683836653/libtbb.so.2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: An illegal reflective access operation has occurred\n", + "WARNING: Illegal reflective access by org.apache.spark.util.SizeEstimator$ (file:/home/prabod/spark/jars/spark-core_2.12-3.3.2.jar) to field java.util.regex.Pattern.pattern\n", + "WARNING: Please consider reporting this to the maintainers of org.apache.spark.util.SizeEstimator$\n", + "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n", + "WARNING: All illegal access operations will be denied in a future release\n" + ] + } + ], + "source": [ + "from sparknlp.annotator import *\n", + "\n", + "CoHere = CoHereTransformer \\\n", + " .loadSavedModel(str(EXPORT_PATH), spark) \\\n", + " .setMaxOutputLength(50) \\\n", + " .setDoSample(False) \\\n", + " .setInputCols([\"documents\"]) \\\n", + " .setOutputCol(\"generation\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9X3RphM-4W7M" + }, + "source": [ + "Let's save it on disk so it is easier to be moved around and also be used later via `.load` function" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "MODEL_NAME = \"CohereForAI/c4ai-command-r-v01\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "T6GaugQa4W7M" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "CoHere.write().overwrite().save(f\"{MODEL_NAME}_spark_nlp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o0kroa6u4W7M" + }, + "source": [ + "Let's clean up stuff we don't need anymore" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BHvWriCn4W7M" + }, + "outputs": [], + "source": [ + "!rm -rf {EXPORT_PATH}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Gz4cU4Q54W7N" + }, + "source": [ + "Awesome 😎 !\n", + "\n", + "This is your OpenVINO CoHere model from HuggingFace 🤗 loaded and saved by Spark NLP 🚀" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "17klLp1M4W7N", + "outputId": "eccfaaba-5b98-4914-dcfc-aedb8de3d285" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 17754944\n", + "-rw-r--r-- 1 prabod prabod 18181049933 Feb 13 09:34 CoHere_openvino\n", + "drwxr-xr-x 6 prabod prabod 4096 Feb 13 09:32 fields\n", + "drwxr-xr-x 2 prabod prabod 4096 Feb 13 09:32 metadata\n" + ] + } + ], + "source": [ + "! ls -l {MODEL_NAME}_spark_nlp" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3R_rS8Fj4W7N" + }, + "source": [ + "Now let's see how we can use it on other machines, clusters, or any place you wish to use your new and shiny CoHere model 😊" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uxSo5-b24W7N", + "outputId": "c4c91a3a-de46-41d7-98c7-e301fbe9419a" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Stage 21:======================================================> (30 + 1) / 31]\r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+--------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|result |\n", + "+--------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "|[ Hello, how are you?Hello! I'm doing well, thank you for asking! I'm excited to help you with whatever questions you have today. How can I assist you?]|\n", + "+--------------------------------------------------------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "import sparknlp\n", + "from sparknlp.base import *\n", + "from sparknlp.annotator import *\n", + "from pyspark.ml import Pipeline\n", + "\n", + "test_data = spark.createDataFrame([\n", + " (\n", + " 1,\n", + " \"<|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>\"\n", + " )\n", + " ]).toDF(\"id\", \"text\")\n", + "\n", + "\n", + "document_assembler = DocumentAssembler() \\\n", + " .setInputCol(\"text\") \\\n", + " .setOutputCol(\"documents\")\n", + "\n", + "CoHere = CoHereTransformer \\\n", + " .load(f\"{MODEL_NAME}_spark_nlp\") \\\n", + " .setMaxOutputLength(50) \\\n", + " .setDoSample(False) \\\n", + " .setBeamSize(1) \\\n", + " .setInputCols([\"documents\"]) \\\n", + " .setOutputCol(\"generation\")\n", + "\n", + "pipeline = Pipeline().setStages([document_assembler, CoHere])\n", + "results = pipeline.fit(test_data).transform(test_data)\n", + "\n", + "results.select(\"generation.result\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PdvQAAfo4W7N" + }, + "source": [ + "That's it! You can now go wild and use hundreds of CoHere models from HuggingFace 🤗 in Spark NLP 🚀\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "cohere", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.21" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "0340296c8770497d84982352c35708ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_13f85f42ec2941998d4e4f241e15d88a", + "placeholder": "​", + "style": "IPY_MODEL_7cac4aa1adf84d338e7de9f3ac91bd47", + "value": " 2/2 [00:39<00:00, 18.11s/it]" + } + }, + "0540ea7b02994fa1a8318a7d2f38c12c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "PasswordModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "PasswordModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Token:", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_e23e8b6170294d4999b90a293da45b19", + "placeholder": "​", + "style": "IPY_MODEL_452dbb332660410ca9b94d11017075c0", + "value": "" + } + }, + "09dd4d814d1a43719a4dfd145ffe5d1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dccf73bd549b4e25ae1da68d0f3931fc", + "placeholder": "​", + "style": "IPY_MODEL_a0f81e62e3f74e418fae0c9e08830f2a", + "value": "Loading checkpoint shards: 100%" + } + }, + "12e23151dcc74313be8c7e02b0f4ea05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "13f85f42ec2941998d4e4f241e15d88a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "174693aa52194cae9bde419572ac117e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1b76dafe2da64c1fa55e52a5f83715c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "1ca22e25121b4d36a7a8bd88c6d39efe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_613ffc0f9ac74c0fab8f3cb05f9deb43", + "placeholder": "​", + "style": "IPY_MODEL_8cf69353a540492a8f81795d635e9069", + "value": "Your token has been saved to /root/.cache/huggingface/token" + } + }, + "3154cd7ba0b841bf909030a40dba671a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9802c5078cb245a793c8ab8a97e370ca", + "placeholder": "​", + "style": "IPY_MODEL_4fed2ab467c94954b8b463b96c751715", + "value": "Login successful" + } + }, + "36adb757251e475b9d854456b6a59a60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8291ca2579ee4c3bbaf3bf34614e865f", + "placeholder": "​", + "style": "IPY_MODEL_5ae825fa761a4cdab40831ec71624dfa", + "value": "Loading checkpoint shards:  25%" + } + }, + "374c8537fa7443d4aa6f6b8047fc090b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "446c4a71c2574673b4f54d06ff24a4ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "452dbb332660410ca9b94d11017075c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "48199a26cd8047acbe897c6600919b67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f57921b6c234eabae3f424afe3c04b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "CheckboxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "CheckboxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "CheckboxView", + "description": "Add token as git credential?", + "description_tooltip": null, + "disabled": false, + "indent": true, + "layout": "IPY_MODEL_f15d2dd70cee40899a34443cd1589e21", + "style": "IPY_MODEL_b20f5c394c9b4c7e9a7d68c1c1dd89ba", + "value": true + } + }, + "4fed2ab467c94954b8b463b96c751715": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "529731f33fb242d9a1d283931beaa70f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d52ee940ddd64d44aa8d08ad032f4225", + "placeholder": "​", + "style": "IPY_MODEL_65686043fcb4475baa17734312cc7f7d", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks.
" + } + }, + "5ae825fa761a4cdab40831ec71624dfa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "613ffc0f9ac74c0fab8f3cb05f9deb43": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65686043fcb4475baa17734312cc7f7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "68b4590ad1bf4eebb05be97c3445bf11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6d4a762cf1f847a59c5e2acf27d3780b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb0cf954d70d4a20b45b6a7a5508d05d", + "placeholder": "​", + "style": "IPY_MODEL_174693aa52194cae9bde419572ac117e", + "value": "Connecting..." + } + }, + "6e7be2d51b3b4bd4967a0d0193078629": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7cac4aa1adf84d338e7de9f3ac91bd47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8087b4ffd55b450ca453fd4c5ffd21f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "80a1163781ca4b76952de9b2dc3b6fb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_36adb757251e475b9d854456b6a59a60", + "IPY_MODEL_cb7635efbf78425e82caafc51e05588d", + "IPY_MODEL_fadeed4224c44883942b67fee7691241" + ], + "layout": "IPY_MODEL_a959a396bdeb4d51b5819ba8ee12be03" + } + }, + "8291ca2579ee4c3bbaf3bf34614e865f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "830590bf17d7419c915bfd27aff3b9c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8420c288f5e44084af6589d767899664": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ec830e5068ef40a7b596fef9908e9c0b", + "IPY_MODEL_9f994a6df3b94907a6da46c63209dac2", + "IPY_MODEL_1ca22e25121b4d36a7a8bd88c6d39efe", + "IPY_MODEL_3154cd7ba0b841bf909030a40dba671a" + ], + "layout": "IPY_MODEL_1b76dafe2da64c1fa55e52a5f83715c9" + } + }, + "84fd5763774748eeb36f33dcb4bbe83f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89582782ab634fd1a59994272f817d00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8cecf94197a040e88791faddd5df7698": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + }, + "8cf69353a540492a8f81795d635e9069": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "90ac8ccbb2c447b79064050316b4fa1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "95828bd4ddd54be4bf441952d22ae080": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "97aba788d25a48bb9aed50f0802d76f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_84fd5763774748eeb36f33dcb4bbe83f", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_89582782ab634fd1a59994272f817d00", + "value": 2 + } + }, + "97bca2fe9b06436ab7174a8e0b921fcf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_374c8537fa7443d4aa6f6b8047fc090b", + "style": "IPY_MODEL_8cecf94197a040e88791faddd5df7698", + "tooltip": "" + } + }, + "9802c5078cb245a793c8ab8a97e370ca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a504923ea28417897157cc07065fe26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_09dd4d814d1a43719a4dfd145ffe5d1d", + "IPY_MODEL_97aba788d25a48bb9aed50f0802d76f0", + "IPY_MODEL_0340296c8770497d84982352c35708ea" + ], + "layout": "IPY_MODEL_830590bf17d7419c915bfd27aff3b9c3" + } + }, + "9b2f731950544dc1be7a5671fc1efe63": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_95828bd4ddd54be4bf441952d22ae080", + "msg_id": "", + "outputs": [ + { + "data": { + "text/html": "
Applying Weight Compression ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 226/226 • 0:03:46 • 0:00:00\n
\n", + "text/plain": "Applying Weight Compression \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[35m100%\u001b[0m \u001b[38;2;0;104;181m226/226\u001b[0m • \u001b[38;2;0;104;181m0:03:46\u001b[0m • \u001b[38;2;0;104;181m0:00:00\u001b[0m\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ] + } + }, + "9e5afb290c1b4320a95d328c74566123": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_df213f2f24d347a1aedf121c8d071345", + "msg_id": "", + "outputs": [ + { + "data": { + "text/html": "
Mixed-Precision assignment ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 224/224 • 0:04:06 • 0:00:00\n
\n", + "text/plain": "Mixed-Precision assignment \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[35m100%\u001b[0m \u001b[38;2;0;104;181m224/224\u001b[0m • \u001b[38;2;0;104;181m0:04:06\u001b[0m • \u001b[38;2;0;104;181m0:00:00\u001b[0m\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ] + } + }, + "9f994a6df3b94907a6da46c63209dac2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_446c4a71c2574673b4f54d06ff24a4ba", + "placeholder": "​", + "style": "IPY_MODEL_12e23151dcc74313be8c7e02b0f4ea05", + "value": "Your token has been saved in your configured git credential helpers (store)." + } + }, + "a03258e8bcb241b2be89ac5c03fba9fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8087b4ffd55b450ca453fd4c5ffd21f9", + "placeholder": "​", + "style": "IPY_MODEL_ee6313eca4be4f6b9d386b2c27624452", + "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } + }, + "a0f81e62e3f74e418fae0c9e08830f2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a959a396bdeb4d51b5819ba8ee12be03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b20f5c394c9b4c7e9a7d68c1c1dd89ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c0c8f56586684c95a71f5926b1ecc4fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c354400f56d84c19ab16fd9533bc4abf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cb0cf954d70d4a20b45b6a7a5508d05d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb7635efbf78425e82caafc51e05588d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48199a26cd8047acbe897c6600919b67", + "max": 4, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c354400f56d84c19ab16fd9533bc4abf", + "value": 1 + } + }, + "d52ee940ddd64d44aa8d08ad032f4225": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dccf73bd549b4e25ae1da68d0f3931fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df213f2f24d347a1aedf121c8d071345": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e23e8b6170294d4999b90a293da45b19": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec830e5068ef40a7b596fef9908e9c0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68b4590ad1bf4eebb05be97c3445bf11", + "placeholder": "​", + "style": "IPY_MODEL_90ac8ccbb2c447b79064050316b4fa1e", + "value": "Token is valid (permission: write)." + } + }, + "ee6313eca4be4f6b9d386b2c27624452": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f15d2dd70cee40899a34443cd1589e21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fadeed4224c44883942b67fee7691241": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6e7be2d51b3b4bd4967a0d0193078629", + "placeholder": "​", + "style": "IPY_MODEL_c0c8f56586684c95a71f5926b1ecc4fb", + "value": " 1/4 [00:27<01:22, 27.51s/it]" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_DistilBertForMultipleChoice.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_DistilBertForMultipleChoice.ipynb new file mode 100644 index 00000000000000..018ee5807e529d --- /dev/null +++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_DistilBertForMultipleChoice.ipynb @@ -0,0 +1,2903 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "_V5XcDCnVgSi" + }, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_DistilBertForMultipleChoice.ipynb)\n", + "\n", + "# Import OpenVINO DistilBertForMultipleChoice models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "This notebook provides a detailed walkthrough on optimizing and exporting DistilBertForMultipleChoice models from HuggingFace for use in Spark NLP, leveraging the various tools provided in the [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html) ecosystem.\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- OpenVINO support was introduced in `Spark NLP 5.4.0`, enabling high performance inference for models. Please make sure you have upgraded to the latest Spark NLP release.\n", + "- You can import models for DistilBertForMultipleChoice from DistilBertForMultipleChoice and they have to be in `Multiple Choice` category." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aghasVppVgSk" + }, + "source": [ + "## 1. Export and Save the HuggingFace model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "be4HsTDMVgSk" + }, + "source": [ + "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n", + "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future releases, but we wanted you to know which versions have been tested successfully." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-7L-2ZWUVgSl", + "outputId": "5d2d172b-5f02-4639-83fc-82b9e601dfe3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.8/43.8 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9.1/9.1 MB\u001b[0m \u001b[31m61.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.6/3.6 MB\u001b[0m \u001b[31m84.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m38.7/38.7 MB\u001b[0m \u001b[31m52.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m215.7/215.7 kB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m480.6/480.6 kB\u001b[0m \u001b[31m21.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m424.1/424.1 kB\u001b[0m \u001b[31m38.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m102.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m13.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.3/179.3 kB\u001b[0m \u001b[31m18.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m13.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m18.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m9.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.1/13.1 MB\u001b[0m \u001b[31m101.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m66.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "google-ai-generativelanguage 0.6.10 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-api-core 2.19.2 requires protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0.dev0,>=3.19.5, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-aiplatform 1.74.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-bigquery-connection 1.17.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-bigquery-storage 2.27.0 requires protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-bigtable 2.27.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-datastore 2.20.2 requires protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-firestore 2.19.0 requires protobuf!=3.20.0,!=3.20.1,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-functions 1.19.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-iam 2.17.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-language 2.16.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-pubsub 2.27.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-resource-manager 1.14.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "google-cloud-translate 3.19.0 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "googleapis-common-protos 1.66.0 requires protobuf!=3.20.0,!=3.20.1,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0.dev0,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "grpc-google-iam-v1 0.13.1 requires protobuf!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.2, but you have protobuf 3.20.1 which is incompatible.\n", + "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.1 which is incompatible.\n", + "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.1 which is incompatible.\n", + "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.1 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install -q --upgrade transformers==4.41.2\n", + "!pip install -q --upgrade openvino==2024.1\n", + "!pip install -q --upgrade optimum-intel==1.17.0\n", + "!pip install -q --upgrade onnx==1.12.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vI7uz_6hVgSl" + }, + "source": [ + "[Optimum Intel](https://github.com/huggingface/optimum-intel?tab=readme-ov-file#openvino) is the interface between the Transformers library and the various model optimization and acceleration tools provided by Intel. HuggingFace models loaded with optimum-intel are automatically optimized for OpenVINO, while being compatible with the Transformers API.\n", + "- Normally, to load a HuggingFace model directly for inference/export, just replace the `AutoModelForXxx` class with the corresponding `OVModelForXxx` class. However, ForMultipleChoice is not yet available so we will use `openvino.convert_model()` after exporting ONNX model\n", + "- We'll use [irfanamal/bert_multiple_choice](https://huggingface.co/irfanamal/bert_multiple_choice) model from HuggingFace as an example\n", + "- We also need the `vocab.txt` saved from `AutoTokenizer`. This is the same for every model, these are assets (saved in `/assets`) needed for tokenization inside Spark NLP." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TDapJ_09nqXQ", + "outputId": "3d8b2ec9-b2c9-4fe8-b3de-0654a43416ba" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: pip in /usr/local/lib/python3.10/dist-packages (24.1.2)\n", + "Collecting pip\n", + " Downloading pip-24.3.1-py3-none-any.whl.metadata (3.7 kB)\n", + "Downloading pip-24.3.1-py3-none-any.whl (1.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m22.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: pip\n", + " Attempting uninstall: pip\n", + " Found existing installation: pip 24.1.2\n", + " Uninstalling pip-24.1.2:\n", + " Successfully uninstalled pip-24.1.2\n", + "Successfully installed pip-24.3.1\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m113.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.0/3.0 MB\u001b[0m \u001b[31m115.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.1/10.1 MB\u001b[0m \u001b[31m151.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m60.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.2 which is incompatible.\n", + "optimum-intel 1.17.0 requires transformers<4.42.0,>=4.36.0, but you have transformers 4.47.1 which is incompatible.\n", + "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\n", + "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install --upgrade pip\n", + "!pip install -q --upgrade transformers[onnx] optimum openvino==2024.1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 313, + "referenced_widgets": [ + "1685190d1c0b40dc9a04bf961ed1fe9a", + "8faf63a59311431e8a4f8149b3d09be3", + "04caa1515af146588adb1552ece36dcd", + "0a41311d87454a49b28792762d1ad390", + "df80408d1d9f4995bce81c9657a16902", + "d09eb9036f7042979767eee8b8adafdd", + "e45f9f7671f84e5783ba53cdafbf0eee", + "3787315381de4f4a8f383dffe4dd1318", + "92efd8cc36b24ba7827eb8ee8d5ddd76", + "586875b1181840658f82ed3791819ea9", + "e5927cae79b2469a8c72dc30591f895c", + "cd2acd5f7e7f4811906e9efdf91cf2f3", + "497ac3bcc25b4710994554005e19ca36", + "7154097716564b4db750626f7efdffc7", + "103d60fc85664ea6852c6cf65a838f08", + "94034333eb9f4399ae56edfa1b9d4b9b", + "153a98ebce99415bbaa8f3bcf0e003a3", + "56b0be1d416b4e968a9b5380367dcd77", + "48d8e523726b426ab553e158e1738d35", + "6758258d40b34089bb9a2ff3d3008c98", + "abde155ca5604caea5996b7eb88e80a3", + "f2e9969ee9364f8b96c0ccbe17b04dd3", + "c77c1345e62441ec9f0cccefd74680ae", + "bda09c689b7e451b9f205bcd89e2892c", + "4d1ce1e3122d4685895e531179f1a6f8", + "ea563bffe9a9402797647d6e57726b07", + "11e9347df720416ab68f7254699e4bfd", + "d74e96dcba28405bb0b90863c372b9a3", + "4143428097184e239be3aa15a709a1bd", + "ebb172d5ac1c4e2381a5e02b3d009d71", + "3935021ef68448f394a93f6a6215724b", + "f73b5c70ce424707951099c81a54ec0f", + "545fcedce22f463e9745cf2785c6260f", + "5acb405e46c7407aa3d38e49d4087a0b", + "e27b262eb28f48a8b39c32a4f65bf74f", + "1da886fbe0a341059120356697806776", + "16da8069c945418f8bb156a7f6d25748", + "795ff4db8fae4852a055586f00364be4", + "1ce12659ed8748239d6755f6da042a98", + "2cba33d72df64451856a650f45f1f765", + "8774027c38a1482895e6c21e6d0e662b", + "c2a9db5e3ef54f7fb704f599e65af401", + "4f3818960d504431a7eb18cd7488e2ba", + "77b7b75457ef4c38ac2634eff41a29d4", + "ea3db61523174ad08842b86d8645fe36", + "7adfc44756d64dbd9552b3e4c7315424", + "9280dc685751491d96554819dce773f2", + "cbc7ecd928d841ee9c448fbb1643612c", + "9a6dd0ec39954a46982e711ece20d8c8", + "83f34c62dcc64d6abb92b880877c3b31", + "466e13e3b2864431962a8a0e29473063", + "dc1dc8a06d7f4b949a50e388e84f690f", + "3e93119eb321493281c6a8cbdf5bb226", + "7061bf9eac4d4f4b8f7250fc8043d912", + "783ee37e722c49d69bc856466340d9eb", + "3a4eaa1f68fd4e9cbd36d29815918c6a", + "4e57df313f4a43fab68b281d93893952", + "a089f60df2b9404290a4634deaf0654a", + "b763f3ad27f044139de5d4eb656153a1", + "ecf9f67c924e4ea69fd2a6b9fb9ef2a6", + "203467747a404ad9b34c642b1a05b711", + "620132d19704448386b7aced66a92ab6", + "c1dde60b58ce4a449f0663cd8a6040b6", + "146d64045c554e66afa4dbd4797971e8", + "26c383992f4742ca92e8132e9aee73b9", + "35c6f2532f6f44a6a90ce6c3a508791c" + ] + }, + "id": "_b89GvQKosA0", + "outputId": "afab9178-e2fd-4979-dbe5-5dcee3c3036f" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n", + "The secret `HF_TOKEN` does not exist in your Colab secrets.\n", + "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n", + "You will be able to reuse this secret in all of your notebooks.\n", + "Please note that authentication is recommended but still optional to access public models or datasets.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1685190d1c0b40dc9a04bf961ed1fe9a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "config.json: 0%| | 0.00/574 [00:00 0, chunk -> 0, score -> 0.60487646}, []}]|\n", + "|[{chunk, 0, 6, Germany, {sentence -> 0, chunk -> 0, score -> 0.39134768}, []}] |\n", + "|[{chunk, 0, 5, Tiger, {sentence -> 0, chunk -> 0, score -> 0.28978878}, []}] |\n", + "|[{chunk, 0, 3, 90°C, {sentence -> 0, chunk -> 0, score -> 0.35916173}, []}] |\n", + "|[{chunk, 0, 6, Jupiter, {sentence -> 0, chunk -> 0, score -> 0.35947314}, []}] |\n", + "|[{chunk, 0, 7, English, {sentence -> 0, chunk -> 0, score -> 0.36399662}, []}] |\n", + "|[{chunk, 0, 11, The Mongols, {sentence -> 0, chunk -> 0, score -> 0.29171973}, []}] |\n", + "|[{chunk, 0, 6, Osmium, {sentence -> 0, chunk -> 0, score -> 0.40618128}, []}] |\n", + "|[{chunk, 0, 13, South America, {sentence -> 0, chunk -> 0, score -> 0.39206758}, []}] |\n", + "|[{chunk, 0, 13, Pablo Picasso, {sentence -> 0, chunk -> 0, score -> 0.4128621}, []}] |\n", + "+-----------------------------------------------------------------------------------------------------------+\n", + "\n" + ] + } + ], + "source": [ + "from sparknlp.base import *\n", + "from sparknlp.annotator import *\n", + "from pyspark.ml import Pipeline, PipelineModel\n", + "\n", + "document_assembler = MultiDocumentAssembler() \\\n", + " .setInputCols([\"question\", \"choices\"]) \\\n", + " .setOutputCols([\"document_question\", \"document_choices\"])\n", + "\n", + "distilbert_for_multiple_choice = DistilBertForMultipleChoice() \\\n", + " .load(f\"{MODEL_NAME}_spark_nlp_openvino\") \\\n", + " .setInputCols([\"document_question\", \"document_choices\"])\\\n", + " .setOutputCol(\"answer\") \\\n", + " .setBatchSize(4)\n", + "\n", + "pipeline = Pipeline(stages=[document_assembler, distilbert_for_multiple_choice])\n", + "pipeline_model = pipeline.fit(testing_df)\n", + "\n", + "pipeline_df = pipeline_model.transform(testing_df)\n", + "\n", + "pipeline_df.select(\"answer\").show(truncate=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lpxiq1igoj6c" + }, + "source": [ + "That's it! You can now go wild and use hundreds of `DistilBertForMultipleChoice` models from HuggingFace 🤗 in Spark NLP 🚀\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "04caa1515af146588adb1552ece36dcd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3787315381de4f4a8f383dffe4dd1318", + "max": 574, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_92efd8cc36b24ba7827eb8ee8d5ddd76", + "value": 574 + } + }, + "0a41311d87454a49b28792762d1ad390": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_586875b1181840658f82ed3791819ea9", + "placeholder": "​", + "style": "IPY_MODEL_e5927cae79b2469a8c72dc30591f895c", + "value": " 574/574 [00:00<00:00, 44.8kB/s]" + } + }, + "103d60fc85664ea6852c6cf65a838f08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_abde155ca5604caea5996b7eb88e80a3", + "placeholder": "​", + "style": "IPY_MODEL_f2e9969ee9364f8b96c0ccbe17b04dd3", + "value": " 268M/268M [00:06<00:00, 42.4MB/s]" + } + }, + "11e9347df720416ab68f7254699e4bfd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "146d64045c554e66afa4dbd4797971e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "153a98ebce99415bbaa8f3bcf0e003a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1685190d1c0b40dc9a04bf961ed1fe9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8faf63a59311431e8a4f8149b3d09be3", + "IPY_MODEL_04caa1515af146588adb1552ece36dcd", + "IPY_MODEL_0a41311d87454a49b28792762d1ad390" + ], + "layout": "IPY_MODEL_df80408d1d9f4995bce81c9657a16902" + } + }, + "16da8069c945418f8bb156a7f6d25748": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f3818960d504431a7eb18cd7488e2ba", + "placeholder": "​", + "style": "IPY_MODEL_77b7b75457ef4c38ac2634eff41a29d4", + "value": " 232k/232k [00:00<00:00, 2.76MB/s]" + } + }, + "1ce12659ed8748239d6755f6da042a98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1da886fbe0a341059120356697806776": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8774027c38a1482895e6c21e6d0e662b", + "max": 231508, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c2a9db5e3ef54f7fb704f599e65af401", + "value": 231508 + } + }, + "203467747a404ad9b34c642b1a05b711": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "26c383992f4742ca92e8132e9aee73b9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2cba33d72df64451856a650f45f1f765": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "35c6f2532f6f44a6a90ce6c3a508791c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3787315381de4f4a8f383dffe4dd1318": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3935021ef68448f394a93f6a6215724b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3a4eaa1f68fd4e9cbd36d29815918c6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4e57df313f4a43fab68b281d93893952", + "IPY_MODEL_a089f60df2b9404290a4634deaf0654a", + "IPY_MODEL_b763f3ad27f044139de5d4eb656153a1" + ], + "layout": "IPY_MODEL_ecf9f67c924e4ea69fd2a6b9fb9ef2a6" + } + }, + "3e93119eb321493281c6a8cbdf5bb226": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4143428097184e239be3aa15a709a1bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "466e13e3b2864431962a8a0e29473063": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "48d8e523726b426ab553e158e1738d35": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "497ac3bcc25b4710994554005e19ca36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_153a98ebce99415bbaa8f3bcf0e003a3", + "placeholder": "​", + "style": "IPY_MODEL_56b0be1d416b4e968a9b5380367dcd77", + "value": "model.safetensors: 100%" + } + }, + "4d1ce1e3122d4685895e531179f1a6f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ebb172d5ac1c4e2381a5e02b3d009d71", + "max": 1224, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3935021ef68448f394a93f6a6215724b", + "value": 1224 + } + }, + "4e57df313f4a43fab68b281d93893952": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_203467747a404ad9b34c642b1a05b711", + "placeholder": "​", + "style": "IPY_MODEL_620132d19704448386b7aced66a92ab6", + "value": "special_tokens_map.json: 100%" + } + }, + "4f3818960d504431a7eb18cd7488e2ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "545fcedce22f463e9745cf2785c6260f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "56b0be1d416b4e968a9b5380367dcd77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "586875b1181840658f82ed3791819ea9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5acb405e46c7407aa3d38e49d4087a0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e27b262eb28f48a8b39c32a4f65bf74f", + "IPY_MODEL_1da886fbe0a341059120356697806776", + "IPY_MODEL_16da8069c945418f8bb156a7f6d25748" + ], + "layout": "IPY_MODEL_795ff4db8fae4852a055586f00364be4" + } + }, + "620132d19704448386b7aced66a92ab6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6758258d40b34089bb9a2ff3d3008c98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7061bf9eac4d4f4b8f7250fc8043d912": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7154097716564b4db750626f7efdffc7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48d8e523726b426ab553e158e1738d35", + "max": 267829484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6758258d40b34089bb9a2ff3d3008c98", + "value": 267829484 + } + }, + "77b7b75457ef4c38ac2634eff41a29d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "783ee37e722c49d69bc856466340d9eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "795ff4db8fae4852a055586f00364be4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7adfc44756d64dbd9552b3e4c7315424": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83f34c62dcc64d6abb92b880877c3b31", + "placeholder": "​", + "style": "IPY_MODEL_466e13e3b2864431962a8a0e29473063", + "value": "tokenizer.json: 100%" + } + }, + "83f34c62dcc64d6abb92b880877c3b31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8774027c38a1482895e6c21e6d0e662b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8faf63a59311431e8a4f8149b3d09be3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d09eb9036f7042979767eee8b8adafdd", + "placeholder": "​", + "style": "IPY_MODEL_e45f9f7671f84e5783ba53cdafbf0eee", + "value": "config.json: 100%" + } + }, + "9280dc685751491d96554819dce773f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dc1dc8a06d7f4b949a50e388e84f690f", + "max": 711396, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3e93119eb321493281c6a8cbdf5bb226", + "value": 711396 + } + }, + "92efd8cc36b24ba7827eb8ee8d5ddd76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "94034333eb9f4399ae56edfa1b9d4b9b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a6dd0ec39954a46982e711ece20d8c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a089f60df2b9404290a4634deaf0654a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c1dde60b58ce4a449f0663cd8a6040b6", + "max": 125, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_146d64045c554e66afa4dbd4797971e8", + "value": 125 + } + }, + "abde155ca5604caea5996b7eb88e80a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b763f3ad27f044139de5d4eb656153a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_26c383992f4742ca92e8132e9aee73b9", + "placeholder": "​", + "style": "IPY_MODEL_35c6f2532f6f44a6a90ce6c3a508791c", + "value": " 125/125 [00:00<00:00, 8.24kB/s]" + } + }, + "bda09c689b7e451b9f205bcd89e2892c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d74e96dcba28405bb0b90863c372b9a3", + "placeholder": "​", + "style": "IPY_MODEL_4143428097184e239be3aa15a709a1bd", + "value": "tokenizer_config.json: 100%" + } + }, + "c1dde60b58ce4a449f0663cd8a6040b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2a9db5e3ef54f7fb704f599e65af401": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c77c1345e62441ec9f0cccefd74680ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bda09c689b7e451b9f205bcd89e2892c", + "IPY_MODEL_4d1ce1e3122d4685895e531179f1a6f8", + "IPY_MODEL_ea563bffe9a9402797647d6e57726b07" + ], + "layout": "IPY_MODEL_11e9347df720416ab68f7254699e4bfd" + } + }, + "cbc7ecd928d841ee9c448fbb1643612c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7061bf9eac4d4f4b8f7250fc8043d912", + "placeholder": "​", + "style": "IPY_MODEL_783ee37e722c49d69bc856466340d9eb", + "value": " 711k/711k [00:00<00:00, 5.21MB/s]" + } + }, + "cd2acd5f7e7f4811906e9efdf91cf2f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_497ac3bcc25b4710994554005e19ca36", + "IPY_MODEL_7154097716564b4db750626f7efdffc7", + "IPY_MODEL_103d60fc85664ea6852c6cf65a838f08" + ], + "layout": "IPY_MODEL_94034333eb9f4399ae56edfa1b9d4b9b" + } + }, + "d09eb9036f7042979767eee8b8adafdd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d74e96dcba28405bb0b90863c372b9a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc1dc8a06d7f4b949a50e388e84f690f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df80408d1d9f4995bce81c9657a16902": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e27b262eb28f48a8b39c32a4f65bf74f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1ce12659ed8748239d6755f6da042a98", + "placeholder": "​", + "style": "IPY_MODEL_2cba33d72df64451856a650f45f1f765", + "value": "vocab.txt: 100%" + } + }, + "e45f9f7671f84e5783ba53cdafbf0eee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e5927cae79b2469a8c72dc30591f895c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ea3db61523174ad08842b86d8645fe36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7adfc44756d64dbd9552b3e4c7315424", + "IPY_MODEL_9280dc685751491d96554819dce773f2", + "IPY_MODEL_cbc7ecd928d841ee9c448fbb1643612c" + ], + "layout": "IPY_MODEL_9a6dd0ec39954a46982e711ece20d8c8" + } + }, + "ea563bffe9a9402797647d6e57726b07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f73b5c70ce424707951099c81a54ec0f", + "placeholder": "​", + "style": "IPY_MODEL_545fcedce22f463e9745cf2785c6260f", + "value": " 1.22k/1.22k [00:00<00:00, 107kB/s]" + } + }, + "ebb172d5ac1c4e2381a5e02b3d009d71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ecf9f67c924e4ea69fd2a6b9fb9ef2a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f2e9969ee9364f8b96c0ccbe17b04dd3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f73b5c70ce424707951099c81a54ec0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Janus.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Janus.ipynb new file mode 100644 index 00000000000000..50d0c7ceef1284 --- /dev/null +++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Janus.ipynb @@ -0,0 +1,1048 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Janus.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import OpenVINO Janus models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "This notebook provides a detailed walkthrough on optimizing and importing Janus models from HuggingFace for use in Spark NLP, with [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html). The focus is on converting the model to the OpenVINO format and applying precision optimizations (INT8 and INT4), to enhance the performance and efficiency on CPU platforms using [Optimum Intel](https://huggingface.co/docs/optimum/main/en/intel/inference).\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- OpenVINO support was introduced in `Spark NLP 5.4.0`, enabling high performance CPU inference for models. So please make sure you have upgraded to the latest Spark NLP release.\n", + "- Model quantization is a computationally expensive process, so it is recommended to use a runtime with more than 32GB memory for exporting the quantized model from HuggingFace.\n", + "- You can import Janus models via `Janus`. These models are usually under `Text Generation` category and have `Janus` in their labels.\n", + "- Reference: [Janus](https://huggingface.co/docs/transformers/model_doc/llama#transformers.Janus)\n", + "- Some [example models](https://huggingface.co/models?search=Janus)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Export and Save the HuggingFace model\n", + "\n", + "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n", + "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future release, but we wanted you to know which versions have been tested successfully." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import requests" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "%pip install -q --upgrade transformers==4.41.2\n", + "%pip install -U --pre \"openvino>2024.5\" --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly\n", + "%pip install -q \"git+https://github.com/eaidova/optimum-intel.git@ea/minicpmv\"\n", + "%pip install -q \"nncf>=2.14.0\" \"sentencepiece\" \"tokenizers>=0.12.1\" \"transformers>=4.45.0\" \"gradio>=4.36\"\n", + "%pip install -q -U --pre --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly openvino-tokenizers openvino openvino-genai\n", + "%pip install -q --upgrade huggingface_hub\n", + "%pip install -q --upgrade onnx==1.15.0\n", + "%pip install -q --upgrade torch==2.3.0\n", + "%pip install -q \"git+https://github.com/deepseek-ai/Janus\" --extra-index-url https://download.pytorch.org/whl/cpu\n", + "\n", + "\n", + "import platform\n", + "\n", + "if platform.system() == \"Darwin\":\n", + " %pip install -q \"numpy<2.0.0\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from pathlib import Path\n", + "import requests\n", + "\n", + "utility_files = [\"notebook_utils.py\"]\n", + "local_helpers = [\"ov_janus_helper.py\", \"gradio_helper.py\"]\n", + "\n", + "base_utils_url = \"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/\"\n", + "base_local_files_url = \"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/notebooks/janus-multimodal-generation/\"\n", + "\n", + "\n", + "for util_path in utility_files:\n", + " if not Path(util_path).exists():\n", + " r = requests.get(base_utils_url + util_path)\n", + " with open(util_path, \"w\") as f:\n", + " f.write(r.text)\n", + "\n", + "for util_path in local_helpers:\n", + " if not Path(util_path).exists():\n", + " r = requests.get(base_local_files_url + util_path)\n", + " with open(util_path, \"w\") as f:\n", + " f.write(r.text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Convert the model to OpenVino" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:nncf:NNCF initialized successfully. Supported frameworks detected: torch, onnx, openvino\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/prabod/anaconda3/envs/pth23/lib/python3.9/importlib/util.py:245: DeprecationWarning: The `openvino.runtime` module is deprecated and will be removed in the 2026.0 release. Please replace `openvino.runtime` with `openvino`.\n", + " self.__spec__.loader.exec_module(self)\n", + "/home/prabod/anaconda3/envs/pth23/lib/python3.9/site-packages/transformers/models/auto/image_processing_auto.py:524: FutureWarning: The image_processor_class argument is deprecated and will be removed in v4.42. Please use `slow_image_processor_class`, or `fast_image_processor_class` instead\n", + " warnings.warn(\n", + "/home/prabod/anaconda3/envs/pth23/lib/python3.9/site-packages/attrdict/mapping.py:4: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3, and in 3.10 it will stop working\n", + " from collections import Mapping\n", + "/home/prabod/anaconda3/envs/pth23/lib/python3.9/site-packages/attrdict/mixins.py:5: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3, and in 3.10 it will stop working\n", + " from collections import Mapping, MutableMapping, Sequence\n", + "/home/prabod/anaconda3/envs/pth23/lib/python3.9/site-packages/attrdict/mixins.py:5: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3, and in 3.10 it will stop working\n", + " from collections import Mapping, MutableMapping, Sequence\n" + ] + } + ], + "source": [ + "import nncf\n", + "from ov_janus_helper import convert_janus_model\n", + "\n", + "model_id = \"deepseek-ai/Janus-1.3B\"\n", + "model_path = Path(model_id.split(\"/\")[-1] + \"-ov\")\n", + "\n", + "compression_configuration = {\n", + " \"mode\": nncf.CompressWeightsMode.INT4_ASYM,\n", + " \"group_size\": 64,\n", + " \"ratio\": 1.0,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Janus-1.3B model already converted. You can find results in Janus-1.3B-ov\n" + ] + } + ], + "source": [ + "convert_janus_model(model_id, model_path, compression_configuration)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Load openvino models" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import openvino as ov\n", + "core = ov.Core()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some kwargs in processor config are unused and will not have any effect: ignore_id, image_start_tag, image_end_tag, num_image_tokens, add_special_token, mask_prompt, image_tag, sft_format. \n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "from PIL import Image\n", + "from io import BytesIO\n", + "from janus.utils.io import load_pil_images\n", + "from janus.models import VLChatProcessor\n", + "import requests\n", + "\n", + "input_prompt = \"Describe image in details\"\n", + "\n", + "image_path = Path(\"cat_in_box.png\")\n", + "processor = VLChatProcessor.from_pretrained(model_path)\n", + "\n", + "if not image_path.exists():\n", + " response = requests.get(\"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\")\n", + " image = Image.open(BytesIO(response.content)).convert(\"RGB\")\n", + " image.save(image_path)\n", + "\n", + "conversation = [\n", + " {\n", + " \"role\": \"User\",\n", + " \"content\": f\"{input_prompt}\\n\",\n", + " \"images\": [str(image_path)],\n", + " },\n", + " {\"role\": \"Assistant\", \"content\": \"\"},\n", + "]\n", + "pil_images = load_pil_images(conversation)\n", + "\n", + "prepare_inputs = processor(conversations=conversation, images=pil_images, force_batchify=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "model_dir = model_path\n", + "VISION_EMBEDDINGS = \"openvino_vision_embeddings_model.xml\"\n", + "TEXT_EMBEDDINGS = \"openvino_text_embeddings_model.xml\"\n", + "LANGUAGE_MODEL = \"openvino_language_model.xml\"\n", + "LM_HEAD = \"openvino_lm_head_model.xml\"\n", + "MERGE_MULTIMODAL = \"openvino_multimodal_merge_model.xml\"\n", + "GEN_HEAD = \"openvino_gen_head_model.xml\"\n", + "GEN_EMBEDDINGS = \"openvino_gen_embeddings_model.xml\"\n", + "GEN_DECODER = \"openvino_gen_decoder_model.xml\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "text_embeddings = core.compile_model(model_dir / TEXT_EMBEDDINGS, \"CPU\")\n", + "vision_embeddings = core.compile_model(model_dir / VISION_EMBEDDINGS, \"CPU\")\n", + "language_model = core.compile_model(model_dir / LANGUAGE_MODEL, \"CPU\")\n", + "lm_head = core.compile_model(model_dir / LM_HEAD, \"CPU\")\n", + "request = language_model.create_infer_request()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "class MergeMultiModalInputs(torch.nn.Module):\n", + " def __init__(self,image_token_index=100594):\n", + " super().__init__()\n", + " self.image_token_index = image_token_index\n", + "\n", + " def forward(\n", + " self,\n", + " vision_embeds,\n", + " inputs_embeds,\n", + " input_ids,\n", + " ):\n", + " image_features = vision_embeds\n", + " inputs_embeds = inputs_embeds\n", + " special_image_mask = (input_ids == self.image_token_index).unsqueeze(-1).expand_as(inputs_embeds)\n", + " # image_features = image_features.to(inputs_embeds.dtype)\n", + " final_embedding = inputs_embeds.masked_scatter(special_image_mask, image_features)\n", + "\n", + " return {\n", + " \"final_embeddings\": final_embedding\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# sample text and image embeddings\n", + "\n", + "inputs = {}\n", + "# Set the initial input_ids\n", + "current_input_ids = prepare_inputs[\"input_ids\"]\n", + "attention_mask = prepare_inputs[\"attention_mask\"]\n", + "position_ids = attention_mask.long().cumsum(-1) - 1\n", + "position_ids.masked_fill_(attention_mask == 0, 1)\n", + "pixel_values = prepare_inputs[\"pixel_values\"]\n", + "\n", + "# Set the initial input_ids\n", + "text_out = text_embeddings(prepare_inputs[\"input_ids\"])[0]\n", + "vision_out = vision_embeddings(pixel_values)[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:nncf:NNCF provides best results with torch==2.5.*, while current torch version is 2.3.1+cu121. If you encounter issues, consider switching to torch==2.5.*\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + } + ], + "source": [ + "import openvino as ov\n", + "\n", + "torch_model_merge = MergeMultiModalInputs()\n", + "\n", + "# convert MergeMultiModalInputs to OpenVINO IR\n", + "ov_model_merge = ov.convert_model(\n", + " torch_model_merge,\n", + " example_input={\n", + " \"vision_embeds\": vision_out,\n", + " \"inputs_embeds\": text_out,\n", + " \"input_ids\": current_input_ids,\n", + " }\n", + ")\n", + "ov.save_model(ov_model_merge, model_path/\"openvino_multimodal_merge_model.xml\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "⌛ Check if all models are converted\n", + "✅ All models are converted. You can find results in Janus-1.3B-ov\n" + ] + } + ], + "source": [ + "# check if all the models are converted\n", + "\n", + "print(\"⌛ Check if all models are converted\")\n", + "lang_model_path = model_dir / \"openvino_language_model.xml\"\n", + "image_embed_path = model_dir / \"openvino_vision_embeddings_model.xml\"\n", + "img_projection_path = model_dir / \"openvino_text_embeddings_model.xml\"\n", + "merge_model_path = model_dir / \"openvino_multimodal_merge_model.xml\"\n", + "gen_head_path = model_dir / \"openvino_gen_head_model.xml\"\n", + "gen_embed_path = model_dir / \"openvino_gen_embeddings_model.xml\"\n", + "gen_decoder_path = model_dir / \"openvino_gen_decoder_model.xml\"\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "if all(\n", + " [\n", + " lang_model_path.exists(),\n", + " image_embed_path.exists(),\n", + " img_projection_path.exists(),\n", + " merge_model_path.exists(),\n", + " gen_head_path.exists(),\n", + " gen_embed_path.exists(),\n", + " gen_decoder_path.exists(),\n", + " ]\n", + "):\n", + " print(f\"✅ All models are converted. You can find results in {model_dir}\")\n", + "else:\n", + " print(\"❌ Not all models are converted. Please check the conversion process\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Copy assets to the assets folder" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# update the preprocessor_config.json with the format needed for spark-nlp\n", + "import json\n", + "\n", + "with open(model_path / \"preprocessor_config.json\") as f:\n", + " preprocessor_config = json.load(f)\n", + "\n", + "preprocessor_config[\"size\"] = {\n", + " \"width\": preprocessor_config[\"image_size\"],\n", + " \"height\": preprocessor_config[\"image_size\"],\n", + "}\n", + "\n", + "preprocessor_config[\"do_normalize\"] = True\n", + "preprocessor_config[\"do_resize\"] = True\n", + "preprocessor_config[\"do_rescale\"] = True\n", + "preprocessor_config[\"resample\"] = 2\n", + "\n", + "with open(model_path / \"preprocessor_config.json\", \"w\") as f:\n", + " json.dump(preprocessor_config, f)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "assets_dir = model_dir / \"assets\"\n", + "assets_dir.mkdir(exist_ok=True)\n", + "\n", + "# copy all the assets to the assets directory (json files, vocab files, etc.)\n", + "\n", + "import shutil\n", + "\n", + "# copy all json files\n", + "\n", + "for file in model_dir.glob(\"*.json\"):\n", + " shutil.copy(file, assets_dir)\n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 2.2G\n", + "drwxrwxr-x 2 prabod prabod 4.0K Feb 5 07:59 assets\n", + "-rw-rw-r-- 1 prabod prabod 1.5K Jan 22 05:52 config.json\n", + "-rw-rw-r-- 1 prabod prabod 82M Jan 22 05:54 openvino_gen_decoder_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 370K Jan 22 05:54 openvino_gen_decoder_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 8.3M Jan 22 05:54 openvino_gen_embeddings_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 8.8K Jan 22 05:54 openvino_gen_embeddings_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 73M Jan 22 05:54 openvino_gen_head_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 6.7K Jan 22 05:54 openvino_gen_head_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 640M Jan 22 05:54 openvino_language_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 2.1M Jan 22 05:54 openvino_language_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 400M Jan 22 05:52 openvino_lm_head_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 2.2K Jan 22 05:52 openvino_lm_head_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 40 Feb 10 05:00 openvino_multimodal_merge_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 9.8K Feb 10 05:00 openvino_multimodal_merge_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 401M Jan 22 05:52 openvino_text_embeddings_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 2.9K Jan 22 05:52 openvino_text_embeddings_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 592M Jan 22 05:54 openvino_vision_embeddings_model.bin\n", + "-rw-rw-r-- 1 prabod prabod 738K Jan 22 05:54 openvino_vision_embeddings_model.xml\n", + "-rw-rw-r-- 1 prabod prabod 370 Feb 10 05:00 preprocessor_config.json\n", + "-rw-rw-r-- 1 prabod prabod 288 Jan 22 05:52 processor_config.json\n", + "-rw-rw-r-- 1 prabod prabod 663 Jan 22 05:52 special_tokens_map.json\n", + "-rw-rw-r-- 1 prabod prabod 104K Jan 22 05:52 tokenizer_config.json\n", + "-rw-rw-r-- 1 prabod prabod 7.3M Feb 5 02:02 tokenizer.json\n" + ] + } + ], + "source": [ + "!ls -lh {model_dir}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 7.4M\n", + "-rw-rw-r-- 1 prabod prabod 1.5K Feb 10 05:00 config.json\n", + "-rw-rw-r-- 1 prabod prabod 370 Feb 10 05:00 preprocessor_config.json\n", + "-rw-rw-r-- 1 prabod prabod 288 Feb 10 05:00 processor_config.json\n", + "-rw-rw-r-- 1 prabod prabod 663 Feb 10 05:00 special_tokens_map.json\n", + "-rw-rw-r-- 1 prabod prabod 104K Feb 10 05:00 tokenizer_config.json\n", + "-rw-rw-r-- 1 prabod prabod 7.3M Feb 10 05:00 tokenizer.json\n" + ] + } + ], + "source": [ + "!ls -lh {assets_dir}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3 Test the openvino model" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import openvino as ov\n", + "import torch\n", + "\n", + "core = ov.Core()\n", + "device = \"CPU\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "text_embeddings = core.compile_model(model_dir / TEXT_EMBEDDINGS, \"CPU\")\n", + "vision_embeddings = core.compile_model(model_dir / VISION_EMBEDDINGS, \"CPU\")\n", + "language_model = core.compile_model(model_dir / LANGUAGE_MODEL, \"CPU\")\n", + "lm_head = core.compile_model(model_dir / LM_HEAD, \"CPU\")\n", + "model_merge = core.compile_model(model_dir / MERGE_MULTIMODAL, \"CPU\")\n", + "request = language_model.create_infer_request()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "generated_tokens = []\n", + "\n", + "from pathlib import Path\n", + "from PIL import Image\n", + "from io import BytesIO\n", + "from janus.utils.io import load_pil_images\n", + "import requests\n", + "import numpy as np\n", + "\n", + "input_prompt = \"Describe image in details\"\n", + "\n", + "image_path = Path(\"cat_in_box.png\")\n", + "\n", + "if not image_path.exists():\n", + " response = requests.get(\"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\")\n", + " image = Image.open(BytesIO(response.content)).convert(\"RGB\")\n", + " image.save(image_path)\n", + "\n", + "conversation = [\n", + " {\n", + " \"role\": \"User\",\n", + " \"content\": f\"{input_prompt}\\n\",\n", + " \"images\": [str(image_path)],\n", + " },\n", + " {\"role\": \"Assistant\", \"content\": \"\"},\n", + "]\n", + "pil_images = load_pil_images(conversation)\n", + "\n", + "prepare_inputs = processor(conversations=conversation, images=pil_images, force_batchify=True)\n", + "request = language_model.create_infer_request()\n", + "merge_model_request = model_merge.create_infer_request()\n", + "\n", + "current_input_ids = prepare_inputs[\"input_ids\"]\n", + "attention_mask = prepare_inputs[\"attention_mask\"]\n", + "position_ids = attention_mask.long().cumsum(-1) - 1\n", + "position_ids.masked_fill_(attention_mask == 0, 1)\n", + "\n", + "pixel_values = prepare_inputs[\"pixel_values\"]\n", + "\n", + "for i in range(50):\n", + " # Generate input embeds each time\n", + " if current_input_ids.shape[-1] > 1:\n", + " vision_embeds = vision_embeddings(pixel_values)[0] \n", + " text_embeds = text_embeddings(current_input_ids)[0]\n", + "\n", + " \n", + " if i == 0:\n", + " # Merge the text and vision embeddings\n", + " text_embeds = torch.from_numpy(text_embeds)\n", + " vision_embeds = torch.from_numpy(vision_embeds)\n", + " final_embedding = model_merge({\n", + " \"vision_embeds\": vision_embeds,\n", + " \"inputs_embeds\": text_embeds,\n", + " \"input_ids\": current_input_ids,\n", + " }, share_inputs=True)[0]\n", + " input_embeds = final_embedding\n", + " else:\n", + " input_embeds = torch.from_numpy(text_embeds)\n", + " inputs = {}\n", + " # Prepare inputs for the model\n", + " inputs[\"inputs_embeds\"] = input_embeds\n", + " inputs[\"attention_mask\"] = attention_mask\n", + " inputs[\"position_ids\"] = position_ids\n", + " inputs[\"beam_idx\"] = np.arange(attention_mask.shape[0], dtype=int)\n", + "\n", + " request.start_async(inputs,share_inputs=True)\n", + " request.wait()\n", + " hidden_states = request.get_tensor(\"last_hidden_state\").data\n", + " logits = torch.from_numpy(lm_head(hidden_states,share_inputs=True,share_outputs=True)[0])\n", + " \n", + " next_token =logits.argmax(-1)[0][-1]\n", + "\n", + " # Append the generated token\n", + " generated_tokens.append(next_token)\n", + " \n", + " # Update input_ids with the new token\n", + " current_input_ids = torch.cat([next_token.unsqueeze(0).unsqueeze(0)], dim=-1)\n", + " \n", + " # update the attention mask\n", + " attention_mask = torch.cat([attention_mask, torch.ones_like(attention_mask[:, :1])], dim=-1)\n", + "\n", + " # Update inputs for the next iteration\n", + " position_ids = attention_mask.long().cumsum(-1) - 1\n", + " position_ids.masked_fill_(attention_mask == 0, 1)\n", + " position_ids = position_ids[:, -current_input_ids.shape[1] :]\n", + " inputs[\"position_ids\"] = position_ids" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Question:\n", + " Describe image in details\n", + "Answer:\n", + "The image depicts a gray and white tabby cat lying comfortably inside a cardboard box. The cat is lying on its back with its paws up in the air, and its eyes are closed, suggesting it is relaxed and possibly asleep. The box is placed\n" + ] + } + ], + "source": [ + "generated_text = processor.tokenizer.decode(generated_tokens, skip_special_tokens=True)\n", + "\n", + "print(\"Question:\\n Describe image in details\")\n", + "print(\"Answer:\")\n", + "print(generated_text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Import and Save Janus in Spark NLP\n", + "\n", + "- Let's install and setup Spark NLP in Google Colab\n", + "- This part is pretty easy via our simple script" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start Spark with Spark NLP included via our simple `start()` function" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24/11/07 09:56:55 WARN Utils: Your hostname, minotaur resolves to a loopback address: 127.0.1.1; using 192.168.1.4 instead (on interface eno1)\n", + "24/11/07 09:56:55 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n", + "24/11/07 09:56:55 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Setting default log level to \"WARN\".\n", + "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n" + ] + } + ], + "source": [ + "import sparknlp\n", + "\n", + "# let's start Spark with Spark NLP\n", + "spark = sparknlp.start()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "25/03/11 02:20:47 WARN NativeLibrary: Failed to load library null: java.lang.UnsatisfiedLinkError: Can't load library: /tmp/openvino-native2264403399992055719/libtbb.so.2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: An illegal reflective access operation has occurred\n", + "WARNING: Illegal reflective access by org.apache.spark.util.SizeEstimator$ (file:/home/prabod/spark/jars/spark-core_2.12-3.3.2.jar) to field java.util.regex.Pattern.pattern\n", + "WARNING: Please consider reporting this to the maintainers of org.apache.spark.util.SizeEstimator$\n", + "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n", + "WARNING: All illegal access operations will be denied in a future release\n" + ] + } + ], + "source": [ + "imageClassifier = JanusForMultiModal.loadSavedModel(model_dir, spark) \\\n", + " .setInputCols(\"image_assembler\") \\\n", + " .setOutputCol(\"answer\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "imageClassifier.write().overwrite().save(\"file:///tmp/Janus_spark_nlp\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import sparknlp\n", + "from sparknlp.base import *\n", + "from sparknlp.annotator import *\n", + "from pyspark.sql.functions import lit\n", + "from pyspark.ml import Pipeline\n", + "from pathlib import Path\n", + "import os\n", + "\n", + "# download two images to test into ./images folder\n", + "\n", + "url1 = \"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\"\n", + "url2 = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n", + "\n", + "Path(\"images\").mkdir(exist_ok=True)\n", + "\n", + "!wget -q -O images/image1.jpg {url1}\n", + "!wget -q -O images/image2.jpg {url2}\n", + "\n", + "\n", + "\n", + "images_path = \"file://\" + os.getcwd() + \"/images/\"\n", + "image_df = spark.read.format(\"image\").load(\n", + " path=images_path\n", + ")\n", + "\n", + "test_df = image_df.withColumn(\"text\", lit(\"You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\\n\\nUser: Describe image in details\\n\\nAssistant:\"))\n", + "\n", + "image_assembler = ImageAssembler().setInputCol(\"image\").setOutputCol(\"image_assembler\")\n", + "\n", + "imageClassifier = JanusForMultiModal.load(\"file:///tmp/Janus_spark_nlp\")\\\n", + " .setMaxOutputLength(50) \\\n", + " .setInputCols(\"image_assembler\") \\\n", + " .setOutputCol(\"answer\")\n", + "\n", + "pipeline = Pipeline(\n", + " stages=[\n", + " image_assembler,\n", + " imageClassifier,\n", + " ]\n", + " )\n", + "\n", + "model = pipeline.fit(test_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image_path: file:///home/prabod/Projects/spark-nlp/examples/python/transformers/openvino/images/image1.jpg\n", + "[Annotation(document, 0, 222, The image depicts a gray tabby cat lounging in a cardboard box. The cat is lying on its back with its legs and paws spread out in a relaxed manner. Its eyes are closed, and it appears to be enjoying a moment of tranquility., Map(), [])]\n" + ] + } + ], + "source": [ + "light_pipeline = LightPipeline(model)\n", + "image_path = \"file://\" + os.getcwd() + \"/images/\" + \"image1.jpg\"\n", + "print(\"image_path: \" + image_path)\n", + "annotations_result = light_pipeline.fullAnnotateImage(\n", + " image_path,\n", + " \"You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\\n\\nUser: Describe image in details\\n\\nAssistant:\"\n", + ")\n", + "\n", + "for result in annotations_result:\n", + " print(result[\"answer\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Image Generation with Janus\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To use Janus for image generation, an image must be provided to the pipeline as it is a required column for the ImageAssembler. This image can be an empty image or any placeholder image. The provided image will not be used to generate a new image but will serve as a necessary input for the pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image_path: file:///tmp/empty_image.jpg\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAGACAIAAAArpSLoAAAHoklEQVR4Ae3QgQAAAADDoPlTX+AIhVBhwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwIABAwYMGDBgwICBPzDB2gABCQd7EQAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create an empty image to test the model\n", + "\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "image = Image.new(\"RGB\", (384, 384))\n", + "image.save(\"/tmp/empty_image.jpg\")\n", + "\n", + "image_path = \"file:///tmp/empty_image.jpg\"\n", + "print(\"image_path: \" + image_path)\n", + "\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "\n", + "import sparknlp\n", + "from sparknlp.base import *\n", + "from sparknlp.annotator import *\n", + "from pyspark.sql.functions import lit\n", + "from pyspark.ml import Pipeline\n", + "from pathlib import Path\n", + "import os\n", + "\n", + "image_df = spark.read.format(\"image\").load(\n", + " path=image_path\n", + ")\n", + "test_df = image_df.withColumn(\"text\", lit(\"User: Create a detailed image of a whimsical forest filled with vibrant, oversized mushrooms, glowing flowers, and towering, twisted trees with bioluminescent vines. The atmosphere is magical, with soft, ethereal light filtering through a misty canopy. Small floating orbs of light hover among the branches, and tiny fairy-like creatures flit through the air. A winding, moss-covered path leads to a mysterious glowing portal hidden within the trees. The scene should feel enchanting, otherworldly, and full of wonder, like a dreamlike fantasy realm.\\n\\nAssistant:\"))\n", + "\n", + "\n", + "image_assembler = ImageAssembler().setInputCol(\"image\").setOutputCol(\"image_assembler\")\n", + "\n", + "imageClassifier = JanusForMultiModal.load(\"file:///tmp/Janus_spark_nlp\")\\\n", + " .setMaxOutputLength(50) \\\n", + " .setImageGenerateMode(True) \\\n", + " .setInputCols(\"image_assembler\") \\\n", + " .setOutputCol(\"answer\")\n", + "\n", + "generate_pipeline = Pipeline(\n", + " stages=[\n", + " image_assembler,\n", + " imageClassifier,\n", + " ]\n", + " )\n", + "\n", + "generate_model = generate_pipeline.fit(test_df)\n", + "generation_result = generate_model.transform(test_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "metadata = generation_result.select(\"answer.metadata\").collect()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import io\n", + "from PIL import Image\n", + "import base64\n", + "from IPython.display import display\n", + "\n", + "for row in metadata:\n", + " result = row[\"metadata\"][0]\n", + " for key in result:\n", + " if \"generated_image\" in key:\n", + " image = result[key]\n", + " image = base64.b64decode(image)\n", + " image = Image.open(io.BytesIO(image)).resize((384, 384))\n", + " display(image)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mllama", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.21" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_LLAVA.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_LLAVA.ipynb new file mode 100644 index 00000000000000..5b5020df3a140e --- /dev/null +++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_LLAVA.ipynb @@ -0,0 +1,971 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_LLAVA.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import OpenVINO LLAVA models from HuggingFace 🤗 into Spark NLP 🚀\n", + "\n", + "This notebook provides a detailed walkthrough on optimizing and importing LLAVA models from HuggingFace for use in Spark NLP, with [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html). The focus is on converting the model to the OpenVINO format and applying precision optimizations (INT8 and INT4), to enhance the performance and efficiency on CPU platforms using [Optimum Intel](https://huggingface.co/docs/optimum/main/en/intel/inference).\n", + "\n", + "Let's keep in mind a few things before we start 😊\n", + "\n", + "- OpenVINO support was introduced in `Spark NLP 5.4.0`, enabling high performance CPU inference for models. So please make sure you have upgraded to the latest Spark NLP release.\n", + "- Model quantization is a computationally expensive process, so it is recommended to use a runtime with more than 32GB memory for exporting the quantized model from HuggingFace.\n", + "- You can import LLAVA models via `LLAVA`. These models are usually under `Text Generation` category and have `LLAVA` in their labels.\n", + "- Reference: [LLAVA](https://huggingface.co/docs/transformers/model_doc/llama#transformers.LLAVA)\n", + "- Some [example models](https://huggingface.co/models?search=LLAVA)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Export and Save the HuggingFace model\n", + "\n", + "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n", + "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future release, but we wanted you to know which versions have been tested successfully." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n", + "Note: you may need to restart the kernel to use updated packages.\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "\n", + "%pip install -q \"nncf>=2.14.0\" \"torch>=2.1\" \"transformers>=4.39.1\" \"accelerate\" \"pillow\" \"gradio>=4.26\" \"datasets>=2.14.6\" \"tqdm\" --extra-index-url https://download.pytorch.org/whl/cpu\n", + "%pip install -q -U \"openvino>=2024.5.0\" \"openvino-tokenizers>=2024.5.0\" \"openvino-genai>=2024.5\"\n", + "%pip install -q \"git+https://github.com/huggingface/optimum-intel.git\" --extra-index-url https://download.pytorch.org/whl/cpu\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import requests\n", + "\n", + "utility_files = [\"notebook_utils.py\", \"cmd_helper.py\"]\n", + "\n", + "for utility in utility_files:\n", + " local_path = Path(utility)\n", + " if not local_path.exists():\n", + " r = requests.get(\n", + " url=f\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/{local_path.name}\",\n", + " )\n", + " with local_path.open(\"w\") as f:\n", + " f.write(r.text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Convert the model to OpenVino" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "**Export command:**" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "`optimum-cli export openvino --model llava-hf/llava-1.5-7b-hf llava-1.5-7b-hf/FP16 --weight-format fp16`" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/prabod/anaconda3/envs/llava/lib/python3.9/importlib/util.py:245: DeprecationWarning: The `openvino.runtime` module is deprecated and will be removed in the 2026.0 release. Please replace `openvino.runtime` with `openvino`.\n", + " self.__spec__.loader.exec_module(self)\n", + "Downloading shards: 100%|██████████| 3/3 [00:00<00:00, 3.84it/s]\n", + "Loading checkpoint shards: 100%|██████████| 3/3 [00:05<00:00, 1.90s/it]\n", + "Using a slow image processor as `use_fast` is unset and a slow processor was saved with this model. `use_fast=True` will be the default behavior in v4.48, even if the model was saved with a slow processor. This will result in minor differences in outputs. You'll still be able to use a slow processor with `use_fast=False`.\n", + "`loss_type=None` was set in the config but it is unrecognised.Using the default loss: `ForCausalLMLoss`.\n", + "/home/prabod/anaconda3/envs/llava/lib/python3.9/site-packages/transformers/cache_utils.py:460: TracerWarning: Using len to get tensor shape might cause the trace to be incorrect. Recommended usage would be tensor.shape[0]. Passing a tensor of different shape might lead to errors or silently give incorrect results.\n", + " or len(self.key_cache[layer_idx]) == 0 # the layer has no cache\n", + "/home/prabod/anaconda3/envs/llava/lib/python3.9/site-packages/optimum/exporters/openvino/model_patcher.py:515: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n", + " if sequence_length != 1:\n", + "/home/prabod/anaconda3/envs/llava/lib/python3.9/site-packages/transformers/cache_utils.py:444: TracerWarning: Using len to get tensor shape might cause the trace to be incorrect. Recommended usage would be tensor.shape[0]. Passing a tensor of different shape might lead to errors or silently give incorrect results.\n", + " len(self.key_cache[layer_idx]) == 0\n", + "/home/prabod/anaconda3/envs/llava/lib/python3.9/site-packages/transformers/models/clip/modeling_clip.py:243: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n", + " if not interpolate_pos_encoding and (height != self.image_size or width != self.image_size):\n" + ] + } + ], + "source": [ + "from cmd_helper import optimum_cli\n", + "\n", + "model_id = \"llava-hf/llava-1.5-7b-hf\"\n", + "model_path = Path(model_id.split(\"/\")[-1]) / \"FP16\"\n", + "\n", + "if not model_path.exists():\n", + " optimum_cli(model_id, model_path, additional_args={\"weight-format\": \"fp16\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:nncf:Statistics of the bitwidth distribution:\n", + "┍━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑\n", + "│ Weight compression mode │ % all parameters (layers) │ % ratio-defining parameters (layers) │\n", + "┝━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┥\n", + "│ int4_asym │ 100% (225 / 225) │ 100% (225 / 225) │\n", + "┕━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┙\n" + ] + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import shutil\n",
+    "import nncf\n",
+    "import openvino as ov\n",
+    "import gc\n",
+    "\n",
+    "\n",
+    "compression_mode = \"INT4\"\n",
+    "\n",
+    "core = ov.Core()\n",
+    "\n",
+    "\n",
+    "def compress_model_weights(precision):\n",
+    "    int4_compression_config = {\"mode\": nncf.CompressWeightsMode.INT4_ASYM, \"group_size\": 128, \"ratio\": 1, \"all_layers\": True}\n",
+    "    int8_compression_config = {\"mode\": nncf.CompressWeightsMode.INT8_ASYM}\n",
+    "\n",
+    "    compressed_model_path = model_path.parent / precision\n",
+    "\n",
+    "    if not compressed_model_path.exists():\n",
+    "        ov_model = core.read_model(model_path / \"openvino_language_model.xml\")\n",
+    "        compression_config = int4_compression_config if precision == \"INT4\" else int8_compression_config\n",
+    "        compressed_ov_model = nncf.compress_weights(ov_model, **compression_config)\n",
+    "        ov.save_model(compressed_ov_model, compressed_model_path / \"openvino_language_model.xml\")\n",
+    "        del compressed_ov_model\n",
+    "        del ov_model\n",
+    "        gc.collect()\n",
+    "        for file_name in model_path.glob(\"*\"):\n",
+    "            if file_name.name in [\"openvino_language_model.xml\", \"openvino_language_model.bin\"]:\n",
+    "                continue\n",
+    "            shutil.copy(file_name, compressed_model_path)\n",
+    "\n",
+    "\n",
+    "compress_model_weights(compression_mode)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2 Load openvino models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_dir = model_path.parent / compression_mode\n",
+    "language_model = core.read_model(model_dir / \"openvino_language_model.xml\")\n",
+    "vision_embedding = core.compile_model(model_dir / \"openvino_vision_embeddings_model.xml\", \"AUTO\")\n",
+    "text_embedding = core.compile_model(model_dir / \"openvino_text_embeddings_model.xml\", \"AUTO\")\n",
+    "compiled_language_model = core.compile_model(language_model, \"AUTO\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prabod/anaconda3/envs/llava/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "Using a slow image processor as `use_fast` is unset and a slow processor was saved with this model. `use_fast=True` will be the default behavior in v4.48, even if the model was saved with a slow processor. This will result in minor differences in outputs. You'll still be able to use a slow processor with `use_fast=False`.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "from PIL import Image\n",
+    "from io import BytesIO\n",
+    "from transformers import AutoProcessor, AutoConfig\n",
+    "\n",
+    "config = AutoConfig.from_pretrained(model_path)\n",
+    "\n",
+    "processor = AutoProcessor.from_pretrained(\n",
+    "    model_path, patch_size=config.vision_config.patch_size, vision_feature_select_strategy=config.vision_feature_select_strategy\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def load_image(image_file):\n",
+    "    if image_file.startswith(\"http\") or image_file.startswith(\"https\"):\n",
+    "        response = requests.get(image_file)\n",
+    "        image = Image.open(BytesIO(response.content)).convert(\"RGB\")\n",
+    "    else:\n",
+    "        image = Image.open(image_file).convert(\"RGB\")\n",
+    "    return image\n",
+    "\n",
+    "\n",
+    "image_file = \"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\"\n",
+    "text_message = \"What is unusual on this image?\"\n",
+    "\n",
+    "image = load_image(image_file)\n",
+    "\n",
+    "conversation = [\n",
+    "    {\n",
+    "        \"role\": \"user\",\n",
+    "        \"content\": [\n",
+    "            {\"type\": \"text\", \"text\": text_message},\n",
+    "            {\"type\": \"image\"},\n",
+    "        ],\n",
+    "    },\n",
+    "]\n",
+    "\n",
+    "prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)\n",
+    "\n",
+    "inputs_new = processor(images=image, text=prompt, return_tensors=\"pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "request = compiled_language_model.create_infer_request()\n",
+    "input_names = {key.get_any_name(): idx for idx, key in enumerate(language_model.inputs)}\n",
+    "inputs = {}\n",
+    "# Set the initial input_ids\n",
+    "current_input_ids = inputs_new[\"input_ids\"]\n",
+    "attention_mask = inputs_new[\"attention_mask\"]\n",
+    "position_ids = attention_mask.long().cumsum(-1) - 1\n",
+    "position_ids.masked_fill_(attention_mask == 0, 1)\n",
+    "pixel_values = inputs_new[\"pixel_values\"]\n",
+    "\n",
+    "# Set the initial input_ids\n",
+    "text_out = text_embedding(inputs_new[\"input_ids\"])[0]\n",
+    "vision_out = vision_embedding(pixel_values)[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "class MergeMultiModalInputs(torch.nn.Module):\n",
+    "    def __init__(self,image_seq_length=576,image_token_index=32000):\n",
+    "        super().__init__()\n",
+    "        self.image_seq_length = image_seq_length\n",
+    "        self.image_token_index = image_token_index\n",
+    "\n",
+    "    def forward(\n",
+    "        self,\n",
+    "        vision_embeds,\n",
+    "        inputs_embeds,\n",
+    "        input_ids,\n",
+    "    ):\n",
+    "        image_features = vision_embeds\n",
+    "        inputs_embeds = inputs_embeds\n",
+    "        special_image_mask = (input_ids == self.image_token_index).unsqueeze(-1).expand_as(inputs_embeds)\n",
+    "        # image_features = image_features.to(inputs_embeds.dtype)\n",
+    "        final_embedding = inputs_embeds.masked_scatter(special_image_mask, image_features)\n",
+    "\n",
+    "        return {\n",
+    "            \"final_embedding\": final_embedding\n",
+    "        }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch_model_merge = MergeMultiModalInputs(\n",
+    "    image_seq_length=config.image_seq_length,\n",
+    "    image_token_index=config.image_token_index\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test the model\n",
+    "inputs_embeds = torch.from_numpy(text_out)\n",
+    "input_ids = inputs_new[\"input_ids\"]\n",
+    "vision_embeds = torch.from_numpy(vision_out)\n",
+    "\n",
+    "final_embedding = torch_model_merge(vision_embeds, inputs_embeds, input_ids)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:nncf:NNCF provides best results with torch==2.5.*, while current torch version is 2.6.0+cpu. If you encounter issues, consider switching to torch==2.5.*\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import openvino as ov\n",
+    "\n",
+    "# convert MergeMultiModalInputs to OpenVINO IR\n",
+    "ov_model_merge = ov.convert_model(\n",
+    "    torch_model_merge,\n",
+    "    example_input={\n",
+    "        \"vision_embeds\": torch.from_numpy(vision_out),\n",
+    "        \"inputs_embeds\": torch.from_numpy(text_out),\n",
+    "        \"input_ids\": inputs_new[\"input_ids\"],\n",
+    "    }\n",
+    ")\n",
+    "ov.save_model(ov_model_merge, model_dir/\"openvino_merge_model.xml\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "⌛ Check if all models are converted\n",
+      "✅ All models are converted. You can find results in llava-1.5-7b-hf/INT4\n"
+     ]
+    }
+   ],
+   "source": [
+    "# check if all the models are converted\n",
+    "\n",
+    "print(\"⌛ Check if all models are converted\")\n",
+    "lang_model_path = model_dir / \"openvino_language_model.xml\"\n",
+    "image_embed_path = model_dir / \"openvino_vision_embeddings_model.xml\"\n",
+    "img_projection_path = model_dir / \"openvino_text_embeddings_model.xml\"\n",
+    "merge_model_path = model_dir / \"openvino_merge_model.xml\"\n",
+    "\n",
+    "\n",
+    "\n",
+    "if all(\n",
+    "    [\n",
+    "        lang_model_path.exists(),\n",
+    "        image_embed_path.exists(),\n",
+    "        img_projection_path.exists(),\n",
+    "        merge_model_path.exists(),\n",
+    "    ]\n",
+    "):\n",
+    "    print(f\"✅ All models are converted. You can find results in {model_dir}\")\n",
+    "else:\n",
+    "    print(\"❌ Not all models are converted. Please check the conversion process\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2 Copy assets to the assets folder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prabod/anaconda3/envs/llava/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "assets_dir = model_dir / \"assets\"\n",
+    "assets_dir.mkdir(exist_ok=True)\n",
+    "\n",
+    "# copy all the assets to the assets directory (json files, vocab files, etc.)\n",
+    "\n",
+    "import shutil\n",
+    "\n",
+    "# copy all json files\n",
+    "\n",
+    "for file in model_dir.glob(\"*.json\"):\n",
+    "    shutil.copy(file, assets_dir)\n",
+    "\n",
+    "from transformers import AutoConfig\n",
+    "\n",
+    "model_id = \"llava-hf/llava-1.5-7b-hf\"\n",
+    "\n",
+    "config = AutoConfig.from_pretrained(model_id)\n",
+    "config.save_pretrained(assets_dir)\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 4.1G\n",
+      "-rw-rw-r-- 1 prabod prabod   41 Feb 13 05:09 added_tokens.json\n",
+      "drwxrwxr-x 2 prabod prabod 4.0K Feb 13 05:10 assets\n",
+      "-rw-rw-r-- 1 prabod prabod  701 Feb 13 05:09 chat_template.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.1K Feb 13 05:09 config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  136 Feb 13 05:09 generation_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 332K Feb 13 05:09 openvino_detokenizer.bin\n",
+      "-rw-rw-r-- 1 prabod prabod  12K Feb 13 05:09 openvino_detokenizer.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 3.2G Feb 13 05:09 openvino_language_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 2.9M Feb 13 05:09 openvino_language_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod   40 Feb 13 05:10 openvino_merge_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 9.9K Feb 13 05:10 openvino_merge_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 251M Feb 13 05:09 openvino_text_embeddings_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 3.1K Feb 13 05:09 openvino_text_embeddings_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 1.2M Feb 13 05:09 openvino_tokenizer.bin\n",
+      "-rw-rw-r-- 1 prabod prabod  25K Feb 13 05:09 openvino_tokenizer.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 595M Feb 13 05:09 openvino_vision_embeddings_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 928K Feb 13 05:09 openvino_vision_embeddings_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  505 Feb 13 05:09 preprocessor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  173 Feb 13 05:09 processor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  580 Feb 13 05:09 special_tokens_map.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.5K Feb 13 05:09 tokenizer_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 3.5M Feb 13 05:09 tokenizer.json\n",
+      "-rw-rw-r-- 1 prabod prabod 489K Feb 13 05:09 tokenizer.model\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh {model_dir}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 3.5M\n",
+      "-rw-rw-r-- 1 prabod prabod   41 Feb 13 05:10 added_tokens.json\n",
+      "-rw-rw-r-- 1 prabod prabod  701 Feb 13 05:10 chat_template.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.1K Feb 13 05:10 config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  136 Feb 13 05:10 generation_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  505 Feb 13 05:10 preprocessor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  173 Feb 13 05:10 processor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  580 Feb 13 05:10 special_tokens_map.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.5K Feb 13 05:10 tokenizer_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 3.5M Feb 13 05:10 tokenizer.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh {assets_dir}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.3 Test the openvino model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openvino as ov\n",
+    "import torch\n",
+    "\n",
+    "core = ov.Core()\n",
+    "device = \"CPU\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "language_model = core.read_model(model_dir / \"openvino_language_model.xml\")\n",
+    "language_model = core.read_model(model_dir / \"openvino_language_model.xml\")\n",
+    "vision_embedding = core.compile_model(model_dir / \"openvino_vision_embeddings_model.xml\", \"AUTO\")\n",
+    "text_embedding = core.compile_model(model_dir / \"openvino_text_embeddings_model.xml\", \"AUTO\")\n",
+    "compiled_language_model = core.compile_model(language_model, \"AUTO\")\n",
+    "merge_multi_modal = core.compile_model(model_dir / \"openvino_merge_model.xml\", \"AUTO\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "generated_tokens = []\n",
+    "\n",
+    "from transformers import AutoProcessor, TextStreamer\n",
+    "\n",
+    "conversation = [\n",
+    "    {\n",
+    "        \"role\": \"user\",\n",
+    "        \"content\": [\n",
+    "            {\"type\": \"text\", \"text\": \"What is unusual on this image?\"},\n",
+    "            {\"type\": \"image\"},\n",
+    "        ],\n",
+    "    },\n",
+    "]\n",
+    "\n",
+    "prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)\n",
+    "\n",
+    "inputs_new = processor(images=image, text=prompt, return_tensors=\"pt\")\n",
+    "\n",
+    "# inputs_new = processor(prompt, [image], return_tensors=\"pt\")\n",
+    "\n",
+    "generation_args = {\"max_new_tokens\": 50, \"do_sample\": False, \"streamer\": TextStreamer(processor.tokenizer, skip_prompt=True, skip_special_tokens=True)}\n",
+    "\n",
+    "\n",
+    "request = compiled_language_model.create_infer_request()\n",
+    "merge_model_request = merge_multi_modal.create_infer_request()\n",
+    "input_names = {key.get_any_name(): idx for idx, key in enumerate(language_model.inputs)}\n",
+    "inputs = {}\n",
+    "# Set the initial input_ids\n",
+    "current_input_ids = inputs_new[\"input_ids\"]\n",
+    "attention_mask = inputs_new[\"attention_mask\"]\n",
+    "position_ids = attention_mask.long().cumsum(-1) - 1\n",
+    "position_ids.masked_fill_(attention_mask == 0, 1)\n",
+    "pixel_values = inputs_new[\"pixel_values\"]\n",
+    "\n",
+    "for i in range(generation_args[\"max_new_tokens\"]):\n",
+    "    # Generate input embeds each time\n",
+    "    if current_input_ids.shape[-1] > 1:\n",
+    "        vision_embeds = torch.from_numpy(vision_embedding({\n",
+    "            \"pixel_values\": pixel_values,\n",
+    "        })[0])\n",
+    "    \n",
+    "    text_embeds = torch.from_numpy(text_embedding(current_input_ids)[0])\n",
+    "\n",
+    "    if i == 0:\n",
+    "        merge_model_request.start_async({\n",
+    "            \"vision_embeds\": vision_embeds,\n",
+    "            \"inputs_embeds\": text_embeds,\n",
+    "            \"input_ids\": current_input_ids,\n",
+    "        }, share_inputs=True)\n",
+    "        merge_model_request.wait()\n",
+    "        final_embedding = torch.from_numpy(merge_model_request.get_tensor(\"final_embedding\").data)\n",
+    "    else:\n",
+    "        final_embedding = text_embeds\n",
+    "    if i>0:\n",
+    "        inputs = {}\n",
+    "    # Prepare inputs for the model\n",
+    "    inputs[\"inputs_embeds\"] = final_embedding\n",
+    "    inputs[\"attention_mask\"] = attention_mask\n",
+    "    inputs[\"position_ids\"] = position_ids\n",
+    "    if \"beam_idx\" in input_names:\n",
+    "        inputs[\"beam_idx\"] = np.arange(attention_mask.shape[0], dtype=int)\n",
+    "    \n",
+    "    # Start inference\n",
+    "    request.start_async(inputs, share_inputs=True)\n",
+    "    request.wait()\n",
+    "    \n",
+    "    # Get the logits and find the next token\n",
+    "    logits = torch.from_numpy(request.get_tensor(\"logits\").data)\n",
+    "    next_token = logits.argmax(-1)[0][-1]\n",
+    "    \n",
+    "    # Append the generated token\n",
+    "    generated_tokens.append(next_token)\n",
+    "    \n",
+    "    # Update input_ids with the new token\n",
+    "    current_input_ids = torch.cat([next_token.unsqueeze(0).unsqueeze(0)], dim=-1)\n",
+    "    \n",
+    "    # update the attention mask\n",
+    "    attention_mask = torch.cat([attention_mask, torch.ones_like(attention_mask[:, :1])], dim=-1)\n",
+    "\n",
+    "    # Update inputs for the next iteration\n",
+    "    position_ids = attention_mask.long().cumsum(-1) - 1\n",
+    "    position_ids.masked_fill_(attention_mask == 0, 1)\n",
+    "    position_ids = position_ids[:, -current_input_ids.shape[1] :]\n",
+    "    inputs[\"position_ids\"] = position_ids"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Question:\n",
+      " What is unusual on this picture?\n",
+      "Answer:\n",
+      "The unusual aspect of this image is that a cat is lying inside a cardboard box, which is not a typical place for a cat to rest. Cats are known for their curiosity and love for small, enclosed spaces, but in this case\n"
+     ]
+    }
+   ],
+   "source": [
+    "generated_text = processor.decode(generated_tokens, skip_special_tokens=True)\n",
+    "\n",
+    "image\n",
+    "print(\"Question:\\n What is unusual on this picture?\")\n",
+    "print(\"Answer:\")\n",
+    "print(generated_text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Import and Save LLAVA in Spark NLP\n",
+    "\n",
+    "- Let's install and setup Spark NLP in Google Colab\n",
+    "- This part is pretty easy via our simple script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's start Spark with Spark NLP included via our simple `start()` function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "24/11/07 09:56:55 WARN Utils: Your hostname, minotaur resolves to a loopback address: 127.0.1.1; using 192.168.1.4 instead (on interface eno1)\n",
+      "24/11/07 09:56:55 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n",
+      "24/11/07 09:56:55 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting default log level to \"WARN\".\n",
+      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sparknlp\n",
+    "\n",
+    "# let's start Spark with Spark NLP\n",
+    "spark = sparknlp.start()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "25/02/13 06:30:15 WARN NativeLibrary: Failed to load library null: java.lang.UnsatisfiedLinkError: Can't load library: /tmp/openvino-native10897903401200889289/libtbb.so.2\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: An illegal reflective access operation has occurred\n",
+      "WARNING: Illegal reflective access by org.apache.spark.util.SizeEstimator$ (file:/home/prabod/spark/jars/spark-core_2.12-3.3.2.jar) to field java.util.regex.Pattern.pattern\n",
+      "WARNING: Please consider reporting this to the maintainers of org.apache.spark.util.SizeEstimator$\n",
+      "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n",
+      "WARNING: All illegal access operations will be denied in a future release\n"
+     ]
+    }
+   ],
+   "source": [
+    "imageClassifier = LLAVAForMultiModal.loadSavedModel(str(model_dir),spark) \\\n",
+    "            .setInputCols(\"image_assembler\") \\\n",
+    "            .setOutputCol(\"answer\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    }
+   ],
+   "source": [
+    "imageClassifier.write().overwrite().save(\"file:///tmp/LLAVA_spark_nlp\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sparknlp\n",
+    "from sparknlp.base import *\n",
+    "from sparknlp.annotator import *\n",
+    "from pyspark.sql.functions import lit\n",
+    "from pyspark.ml import Pipeline\n",
+    "from pathlib import Path\n",
+    "import os\n",
+    "\n",
+    "# download two images to test into ./images folder\n",
+    "\n",
+    "url1 = \"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\"\n",
+    "url2 = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n",
+    "\n",
+    "Path(\"images\").mkdir(exist_ok=True)\n",
+    "\n",
+    "!wget -q -O images/image1.jpg {url1}\n",
+    "!wget -q -O images/image2.jpg {url2}\n",
+    "\n",
+    "\n",
+    "\n",
+    "images_path = \"file://\" + os.getcwd() + \"/images/\"\n",
+    "image_df = spark.read.format(\"image\").load(\n",
+    "    path=images_path\n",
+    ")\n",
+    "\n",
+    "test_df = image_df.withColumn(\"text\", lit(\"USER: \\n <|image|> \\n What's this picture about? \\n ASSISTANT:\\n\"))\n",
+    "\n",
+    "image_assembler = ImageAssembler().setInputCol(\"image\").setOutputCol(\"image_assembler\")\n",
+    "\n",
+    "imageClassifier = LLAVAForMultiModal.load(\"file:///tmp/LLAVA_spark_nlp\")\\\n",
+    "            .setMaxOutputLength(50) \\\n",
+    "            .setInputCols(\"image_assembler\") \\\n",
+    "            .setOutputCol(\"answer\")\n",
+    "\n",
+    "pipeline = Pipeline(\n",
+    "            stages=[\n",
+    "                image_assembler,\n",
+    "                imageClassifier,\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "model = pipeline.fit(test_df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "image_path: file:///home/prabod/Projects/spark-nlp/examples/python/transformers/openvino/images/image1.jpg\n",
+      "[Annotation(document, 0, 207, This image features a cat comfortably laying inside a cardboard box. The cat appears to be relaxed and enjoying its cozy spot. The scene takes place on a carpeted floor, which adds to the overall warm and inv, Map(), [])]\n"
+     ]
+    }
+   ],
+   "source": [
+    "light_pipeline = LightPipeline(model)\n",
+    "image_path = \"file://\"+os.getcwd() + \"/images/\" + \"image1.jpg\"\n",
+    "print(\"image_path: \" + image_path)\n",
+    "annotations_result = light_pipeline.fullAnnotateImage(\n",
+    "    image_path,\n",
+    "    \"USER: \\n <|image|> \\n What's this picture about? \\n ASSISTANT:\\n\"\n",
+    ")\n",
+    "\n",
+    "for result in annotations_result:\n",
+    "    print(result[\"answer\"])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llava",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.21"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_MLLama.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_MLLama.ipynb
new file mode 100644
index 00000000000000..f31513353542a1
--- /dev/null
+++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_MLLama.ipynb
@@ -0,0 +1,812 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_MLLama.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Import OpenVINO MLLama models from HuggingFace 🤗 into Spark NLP 🚀\n",
+    "\n",
+    "This notebook provides a detailed walkthrough on optimizing and importing MLLama models from HuggingFace  for use in Spark NLP, with [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html). The focus is on converting the model to the OpenVINO format and applying precision optimizations (INT8 and INT4), to enhance the performance and efficiency on CPU platforms using [Optimum Intel](https://huggingface.co/docs/optimum/main/en/intel/inference).\n",
+    "\n",
+    "Let's keep in mind a few things before we start 😊\n",
+    "\n",
+    "- OpenVINO support was introduced in  `Spark NLP 5.4.0`, enabling high performance CPU inference for models. So please make sure you have upgraded to the latest Spark NLP release.\n",
+    "- Model quantization is a computationally expensive process, so it is recommended to use a runtime with more than 32GB memory for exporting the quantized model from HuggingFace.\n",
+    "- You can import MLLama models via `MLLama`. These models are usually under `Text Generation` category and have `MLLama` in their labels.\n",
+    "- Reference: [MLLama](https://github.com/meta-llama/llama-models/blob/main/models/llama3_2/MODEL_CARD_VISION.md)\n",
+    "- Some [example models](https://huggingface.co/models?search=MLLama)\n",
+    "- Openvino export taken from [Openvino Notebooks](https://github.com/openvinotoolkit/openvino_notebooks/tree/b4a0791/notebooks/mllama-3.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Export and Save the HuggingFace model\n",
+    "\n",
+    "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n",
+    "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future release, but we wanted you to know which versions have been tested successfully."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install -q \"torch>=2.1\" \"torchvision\" \"Pillow\" \"tqdm\" \"datasets>=2.14.6\" \"gradio>=4.36\" \"nncf>=2.14.0\" --extra-index-url https://download.pytorch.org/whl/cpu\n",
+    "%pip install -q \"transformers>=4.45\" --extra-index-url https://download.pytorch.org/whl/cpu\n",
+    "%pip install -Uq \"openvino>=2024.5.0\"\n",
+    "%pip install -q --upgrade ipywidgets\n",
+    "\n",
+    "utility_files = [\"notebook_utils.py\", \"cmd_helper.py\"]\n",
+    "\n",
+    "import requests\n",
+    "from pathlib import Path\n",
+    "\n",
+    "if not Path(\"ov_mllama_helper.py\").exists():\n",
+    "    r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/b4a0791/notebooks/mllama-3.2/ov_mllama_helper.py\")\n",
+    "    open(\"ov_mllama_helper.py\", \"w\").write(r.text)\n",
+    "\n",
+    "if not Path(\"gradio_helper.py\").exists():\n",
+    "    r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/b4a0791/notebooks/mllama-3.2/gradio_helper.py\")\n",
+    "    open(\"gradio_helper.py\", \"w\").write(r.text)\n",
+    "\n",
+    "if not Path(\"ov_mllama_compression.py\").exists():\n",
+    "    r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/b4a0791/notebooks/mllama-3.2/ov_mllama_compression.py\")\n",
+    "    open(\"ov_mllama_compression.py\", \"w\").write(r.text)\n",
+    "\n",
+    "if not Path(\"data_preprocessing.py\").exists():\n",
+    "    r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/b4a0791/notebooks/mllama-3.2/data_preprocessing.py\")\n",
+    "    open(\"data_preprocessing\", \"w\").write(r.text)\n",
+    "\n",
+    "if not Path(\"notebook_utils.py\").exists():\n",
+    "    r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/b4a0791/utils/notebook_utils.py\")\n",
+    "    open(\"notebook_utils.py\", \"w\").write(r.text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1 Convert the model to OpenVino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prabod/anaconda3/envs/mllama/lib/python3.9/importlib/util.py:245: DeprecationWarning: The `openvino.runtime` module is deprecated and will be removed in the 2026.0 release. Please replace `openvino.runtime` with `openvino`.\n",
+      "  self.__spec__.loader.exec_module(self)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "from ov_mllama_helper import convert_mllama\n",
+    "\n",
+    "model_id = \"meta-llama/Llama-3.2-11B-Vision-Instruct\"\n",
+    "model_dir = Path(model_id.split(\"/\")[-1]) / \"OV\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "dc77113413684c39ba2b488d2504c7f8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Dropdown(description='Device:', options=('CPU', 'AUTO'), value='CPU')"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from notebook_utils import device_widget\n",
+    "\n",
+    "device = device_widget(\"CPU\", exclude=[\"NPU\"])\n",
+    "\n",
+    "device"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PosixPath('Llama-3.2-11B-Vision-Instruct/OV')"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_dir"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "convert_mllama(model_id, model_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ov_mllama_compression import compress\n",
+    "from ov_mllama_compression import compression_widgets_helper\n",
+    "\n",
+    "compression_scenario, compress_args = compression_widgets_helper()\n",
+    "\n",
+    "compression_scenario"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compression_kwargs = {key: value.value for key, value in compress_args.items()}\n",
+    "\n",
+    "language_model_path = compress(model_dir, **compression_kwargs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ov_mllama_compression import vision_encoder_selection_widget\n",
+    "\n",
+    "vision_encoder_options = vision_encoder_selection_widget(device.value)\n",
+    "\n",
+    "vision_encoder_options"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoProcessor\n",
+    "import nncf\n",
+    "import openvino as ov\n",
+    "import gc\n",
+    "\n",
+    "from data_preprocessing import prepare_dataset_vision\n",
+    "\n",
+    "processor = AutoProcessor.from_pretrained(model_dir)\n",
+    "core = ov.Core()\n",
+    "\n",
+    "fp_vision_encoder_path = model_dir / \"openvino_vision_encoder.xml\"\n",
+    "int8_vision_encoder_path = model_dir / fp_vision_encoder_path.name.replace(\".xml\", \"_int8.xml\")\n",
+    "int8_wc_vision_encoder_path = model_dir / fp_vision_encoder_path.name.replace(\".xml\", \"_int8_wc.xml\")\n",
+    "\n",
+    "\n",
+    "if vision_encoder_options.value == \"INT8 quantization\":\n",
+    "    if not int8_vision_encoder_path.exists():\n",
+    "        calibration_data = prepare_dataset_vision(processor, 100)\n",
+    "        ov_model = core.read_model(fp_vision_encoder_path)\n",
+    "        calibration_dataset = nncf.Dataset(calibration_data)\n",
+    "        quantized_model = nncf.quantize(\n",
+    "            model=ov_model,\n",
+    "            calibration_dataset=calibration_dataset,\n",
+    "            model_type=nncf.ModelType.TRANSFORMER,\n",
+    "            advanced_parameters=nncf.AdvancedQuantizationParameters(smooth_quant_alpha=0.6),\n",
+    "        )\n",
+    "        ov.save_model(quantized_model, int8_vision_encoder_path)\n",
+    "        del quantized_model\n",
+    "        del ov_model\n",
+    "        del calibration_dataset\n",
+    "        del calibration_data\n",
+    "        gc.collect()\n",
+    "\n",
+    "    vision_encoder_path = int8_vision_encoder_path\n",
+    "elif vision_encoder_options.value == \"INT8 weights compression\":\n",
+    "    if not int8_wc_vision_encoder_path.exists():\n",
+    "        ov_model = core.read_model(fp_vision_encoder_path)\n",
+    "        compressed_model = nncf.compress_weights(ov_model)\n",
+    "        ov.save_model(compressed_model, int8_wc_vision_encoder_path)\n",
+    "    vision_encoder_path = int8_wc_vision_encoder_path\n",
+    "else:\n",
+    "    vision_encoder_path = fp_vision_encoder_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoProcessor, AutoConfig\n",
+    "\n",
+    "model_id = \"meta-llama/Llama-3.2-11B-Vision-Instruct\"\n",
+    "processor = AutoProcessor.from_pretrained(model_id)\n",
+    "config = AutoConfig.from_pretrained(model_id)\n",
+    "\n",
+    "import requests\n",
+    "from PIL import Image\n",
+    "\n",
+    "\n",
+    "question = \"What is unusual on this image?\"\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"user\", \"content\": [{\"type\": \"image\"}, {\"type\": \"text\", \"text\": question}]},\n",
+    "]\n",
+    "text = processor.tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)\n",
+    "url = \"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\"\n",
+    "raw_image = Image.open(requests.get(url, stream=True).raw)\n",
+    "\n",
+    "inputs = processor(text=text, images=[raw_image], return_tensors=\"pt\")\n",
+    "\n",
+    "pixel_values = inputs[\"pixel_values\"]\n",
+    "aspect_ratio_ids = inputs[\"aspect_ratio_ids\"]\n",
+    "aspect_ratio_mask = inputs[\"aspect_ratio_mask\"]\n",
+    "\n",
+    "image_inputs = {\n",
+    "    \"pixel_values\": pixel_values,\n",
+    "    \"aspect_ratio_ids\": aspect_ratio_ids,\n",
+    "    \"aspect_ratio_mask\": aspect_ratio_mask,\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openvino as ov\n",
+    "from pathlib import Path\n",
+    "core = ov.Core()\n",
+    "\n",
+    "IMAGE_ENCODER_NAME = \"openvino_vision_encoder.xml\"\n",
+    "\n",
+    "image_encoder = core.compile_model(model_path / IMAGE_ENCODER_NAME,\"CPU\")\n",
+    "cross_attn_outputs = [key.get_any_name() for key in image_encoder.outputs if \"cross_attn_key_values\" in key.get_any_name()]\n",
+    "\n",
+    "\n",
+    "image_request = image_encoder.create_infer_request()\n",
+    "image_request.start_async([pixel_values, aspect_ratio_ids, aspect_ratio_mask], share_inputs=True)\n",
+    "image_request.wait()\n",
+    "cross_attn_key_values = [image_request.get_tensor(name) for name in cross_attn_outputs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "class PreprocessingMasks(torch.nn.Module):\n",
+    "    def __init__(self,):\n",
+    "        super().__init__()\n",
+    "\n",
+    "    def forward(\n",
+    "        self,\n",
+    "        cross_attention_mask,\n",
+    "        attention_mask,\n",
+    "        current_input_ids,\n",
+    "        num_vision_tokens,\n",
+    "        past_cross_attn_kv_length\n",
+    "    ):\n",
+    "        dtype=torch.float32\n",
+    "        batch_size, text_total_length, *_ = cross_attention_mask.shape\n",
+    "        cross_attention_mask = cross_attention_mask.repeat_interleave(num_vision_tokens, dim=3)\n",
+    "        cross_attention_mask = cross_attention_mask.view(batch_size, text_total_length, -1)\n",
+    "        cross_attention_mask = cross_attention_mask.unsqueeze(1)\n",
+    "\n",
+    "        inverted_cross_attn_mask = (1.0 - cross_attention_mask).to(dtype)\n",
+    "        cross_attention_mask = inverted_cross_attn_mask.masked_fill(inverted_cross_attn_mask.to(torch.bool), torch.finfo(dtype).min)\n",
+    "\n",
+    "        # apply full-row bias, which return 4D tensor of shape [B, H, S1, 1] where value is 0 if the a full row in cross attn mask's\n",
+    "        # last dimension contains negative infinity values, otherwise it's 1\n",
+    "        negative_inf_value = torch.finfo(dtype).min\n",
+    "        full_text_row_masked_out_mask = (cross_attention_mask != negative_inf_value).any(dim=-1).type_as(cross_attention_mask)[..., None]\n",
+    "        cross_attention_mask *= full_text_row_masked_out_mask\n",
+    "\n",
+    "        # if first_pass > 0:\n",
+    "        # past_cross_attn_kv_length = cross_attn_key_values[0].shape[-2]\n",
+    "        past_cross_attn_mask = torch.zeros((*cross_attention_mask.shape[:-1], past_cross_attn_kv_length), dtype=dtype)\n",
+    "        # concatenate both on image-seq-length dimension\n",
+    "        cross_attention_mask_second_pass = torch.cat([past_cross_attn_mask, cross_attention_mask], dim=-1)\n",
+    "        cache_position = (attention_mask.long().cumsum(-1) - 1)[:, -current_input_ids.shape[1] :][0]\n",
+    "\n",
+    "        cross_attention_mask_second_pass = cross_attention_mask_second_pass[:, :, cache_position]\n",
+    "\n",
+    "        cross_attention_mask = cross_attention_mask[:, :, cache_position]\n",
+    "        full_text_row_masked_out_mask = full_text_row_masked_out_mask[:, :, cache_position]\n",
+    "\n",
+    "        return {\n",
+    "            \"cache_position\": cache_position.to(torch.int32),\n",
+    "            \"cross_attention_mask_first_pass\": cross_attention_mask.to(dtype),\n",
+    "            \"cross_attention_mask_second_pass\": cross_attention_mask_second_pass.to(dtype),\n",
+    "            \"full_text_row_masked_out_mask\": full_text_row_masked_out_mask.to(dtype),\n",
+    "        }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "preprocessing_masks = PreprocessingMasks()\n",
+    "cross_attention_mask = inputs[\"cross_attention_mask\"]\n",
+    "attention_mask = inputs[\"attention_mask\"]\n",
+    "current_input_ids = inputs[\"input_ids\"]\n",
+    "first_pass = torch.tensor(1)\n",
+    "num_vision_tokens = torch.tensor((config.vision_config.image_size // config.vision_config.patch_size) ** 2 + 1)\n",
+    "past_cross_attn_kv_length = torch.tensor(cross_attn_key_values[0].shape[-2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openvino as ov\n",
+    "\n",
+    "ov_model_preprocessing_masks = ov.convert_model(\n",
+    "    preprocessing_masks,\n",
+    "    example_input={\n",
+    "        \"cross_attention_mask\": cross_attention_mask,\n",
+    "        \"attention_mask\": attention_mask,\n",
+    "        \"current_input_ids\": current_input_ids,\n",
+    "        \"num_vision_tokens\": num_vision_tokens,\n",
+    "        \"past_cross_attn_kv_length\": past_cross_attn_kv_length,\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "ov.save_model(ov_model_preprocessing_masks,model_path/\"openvino_reshape_model.xml\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2 Load openvino models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "LANGUAGE_MODEL_NAME = \"llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers.xml\"\n",
+    "LANGUAGE_MODEL_NAME_1 = \"openvino_language_model.xml\"\n",
+    "IMAGE_ENCODER_NAME = \"openvino_vision_encoder.xml\"\n",
+    "PREPROCESSING_MASKS_NAME = \"openvino_reshape_model.xml\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openvino as ov\n",
+    "import gc\n",
+    "\n",
+    "core = ov.Core()\n",
+    "model_path = model_dir\n",
+    "\n",
+    "language_model = core.read_model(model_path / LANGUAGE_MODEL_NAME)\n",
+    "compiled_language_model = core.compile_model(language_model, \"CPU\")\n",
+    "request = compiled_language_model.create_infer_request()\n",
+    "\n",
+    "image_encoder = core.compile_model(model_path / IMAGE_ENCODER_NAME,\"CPU\")\n",
+    "preprocessing_masks = core.compile_model(model_path / PREPROCESSING_MASKS_NAME,\"CPU\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "⌛ Check if all models are converted\n",
+      "✅ All models are converted. You can find results in /mnt/research/Projects/ModelZoo/LLAMA-3.2-VI/Llama-3.2-11B-Vision-Instruct/OV\n"
+     ]
+    }
+   ],
+   "source": [
+    "# check if all the models are converted\n",
+    "\n",
+    "print(\"⌛ Check if all models are converted\")\n",
+    "language_model_path = model_dir / LANGUAGE_MODEL_NAME\n",
+    "# language_model_path_1 = model_dir / LANGUAGE_MODEL_NAME_1\n",
+    "image_encoder_path = model_dir / IMAGE_ENCODER_NAME\n",
+    "preprocessing_masks_path = model_dir / PREPROCESSING_MASKS_NAME\n",
+    "\n",
+    "if all(\n",
+    "    [\n",
+    "        language_model_path.exists(),\n",
+    "        # language_model_path_1.exists(),\n",
+    "        image_encoder_path.exists(),\n",
+    "        preprocessing_masks_path.exists(),\n",
+    "    ]\n",
+    "):\n",
+    "    print(f\"✅ All models are converted. You can find results in {model_dir}\")\n",
+    "else:\n",
+    "    print(\"❌ Not all models are converted. Please check the conversion process\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2 Copy assets to the assets folder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assets_dir = model_dir / \"assets\"\n",
+    "assets_dir.mkdir(exist_ok=True)\n",
+    "\n",
+    "# copy all the assets to the assets directory (json files, vocab files, etc.)\n",
+    "\n",
+    "import shutil\n",
+    "\n",
+    "# copy all json files\n",
+    "\n",
+    "for file in model_dir.glob(\"*.json\"):\n",
+    "    shutil.copy(file, assets_dir)\n",
+    "\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 31G\n",
+      "drwxrwxr-x 2 prabod prabod 4.0K Jan 15 03:09 assets\n",
+      "-rw-rw-r-- 1 prabod prabod 5.0K Dec 12 01:53 chat_template.json\n",
+      "-rw-rw-r-- 1 prabod prabod 5.0K Jan 15 03:06 config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  210 Dec 12 01:53 generation_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 4.9G Jan 23 01:10 llm_int4_asym_r10_gs64_max_activation_variance_all_layers.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 3.9M Jan 23 01:10 llm_int4_asym_r10_gs64_max_activation_variance_all_layers.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 4.9G Dec 12 04:28 llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 3.9M Dec 12 04:28 llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  19G Dec 12 01:55 openvino_language_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 3.0M Dec 12 01:55 openvino_language_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod   92 Jan 22 05:14 openvino_reshape_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod  37K Jan 22 05:14 openvino_reshape_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 1.8G Dec 12 01:54 openvino_vision_encoder.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 924M Dec 12 08:15 openvino_vision_encoder_int8.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 2.5M Dec 12 08:15 openvino_vision_encoder_int8.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 1.6M Dec 12 01:54 openvino_vision_encoder.xml\n",
+      "-rw-rw-r-- 1 prabod prabod   92 Jan 13 07:25 preprocessing_masks.bin\n",
+      "-rw-rw-r-- 1 prabod prabod  37K Jan 13 07:25 preprocessing_masks.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  477 Dec 12 01:53 preprocessor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  454 Dec 12 01:53 special_tokens_map.json\n",
+      "-rw-rw-r-- 1 prabod prabod  55K Dec 12 01:53 tokenizer_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  17M Dec 12 01:53 tokenizer.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh {model_dir}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 17M\n",
+      "-rw-rw-r-- 1 prabod prabod 5.0K Jan 14 08:10  chat_template.json\n",
+      "-rw-rw-r-- 1 prabod prabod 5.0K Jan 15 03:09 'config copy.json'\n",
+      "-rw-rw-r-- 1 prabod prabod 5.0K Jan 15 03:09  config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  210 Jan 14 08:10  generation_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  477 Jan 14 08:10  preprocessor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  454 Jan 14 08:10  special_tokens_map.json\n",
+      "-rw-rw-r-- 1 prabod prabod  55K Jan 14 08:10  tokenizer_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  17M Jan 14 08:10  tokenizer.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh {model_dir / \"assets\"}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Import and Save MLLama in Spark NLP\n",
+    "\n",
+    "- Let's install and setup Spark NLP in Google Colab\n",
+    "- This part is pretty easy via our simple script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's start Spark with Spark NLP included via our simple `start()` function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "24/11/07 09:56:55 WARN Utils: Your hostname, minotaur resolves to a loopback address: 127.0.1.1; using 192.168.1.4 instead (on interface eno1)\n",
+      "24/11/07 09:56:55 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n",
+      "24/11/07 09:56:55 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting default log level to \"WARN\".\n",
+      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sparknlp\n",
+    "\n",
+    "# let's start Spark with Spark NLP\n",
+    "spark = sparknlp.start()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "25/02/14 02:49:23 WARN NativeLibrary: Failed to load library null: java.lang.UnsatisfiedLinkError: Can't load library: /tmp/openvino-native8030791226413631526/libtbb.so.2\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: An illegal reflective access operation has occurred\n",
+      "WARNING: Illegal reflective access by org.apache.spark.util.SizeEstimator$ (file:/home/prabod/spark/jars/spark-core_2.12-3.3.2.jar) to field java.util.regex.Pattern.pattern\n",
+      "WARNING: Please consider reporting this to the maintainers of org.apache.spark.util.SizeEstimator$\n",
+      "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n",
+      "WARNING: All illegal access operations will be denied in a future release\n"
+     ]
+    }
+   ],
+   "source": [
+    "imageClassifier = MLLamaForMultimodal.loadSavedModel(str(model_path),spark) \\\n",
+    "            .setInputCols(\"image_assembler\") \\\n",
+    "            .setOutputCol(\"answer\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    }
+   ],
+   "source": [
+    "imageClassifier.write().overwrite().save(\"file:///tmp/MLLama_spark_nlp\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 6.8G\n",
+      "drwxr-xr-x  4 prabod prabod 4.0K Feb 14 02:51 .\n",
+      "drwxr-xr-x 13 prabod root   4.0K Feb 14 02:50 ..\n",
+      "drwxr-xr-x  6 prabod prabod 4.0K Feb 14 02:50 fields\n",
+      "-rw-r--r--  1 prabod prabod 4.9G Feb 14 02:51 llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers.xml\n",
+      "-rw-r--r--  1 prabod prabod  40M Feb 14 02:51 .llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers.xml.crc\n",
+      "drwxr-xr-x  2 prabod prabod 4.0K Feb 14 02:50 metadata\n",
+      "-rw-r--r--  1 prabod prabod  37K Feb 14 02:51 openvino_reshape_model.xml\n",
+      "-rw-r--r--  1 prabod prabod  304 Feb 14 02:51 .openvino_reshape_model.xml.crc\n",
+      "-rw-r--r--  1 prabod prabod 1.8G Feb 14 02:51 openvino_vision_encoder.xml\n",
+      "-rw-r--r--  1 prabod prabod  15M Feb 14 02:51 .openvino_vision_encoder.xml.crc\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lah /tmp/MLLama_spark_nlp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sparknlp\n",
+    "from sparknlp.base import *\n",
+    "from sparknlp.annotator import *\n",
+    "from pyspark.sql.functions import lit\n",
+    "from pyspark.ml import Pipeline\n",
+    "from pathlib import Path\n",
+    "import os\n",
+    "\n",
+    "# download two images to test into ./images folder\n",
+    "\n",
+    "url1 = \"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\"\n",
+    "url2 = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n",
+    "\n",
+    "Path(\"images\").mkdir(exist_ok=True)\n",
+    "\n",
+    "!wget -q -O images/image1.jpg {url1}\n",
+    "!wget -q -O images/image2.jpg {url2}\n",
+    "\n",
+    "\n",
+    "\n",
+    "images_path = \"file://\" + os.getcwd() + \"/images/\"\n",
+    "image_df = spark.read.format(\"image\").load(\n",
+    "    path=images_path\n",
+    ")\n",
+    "\n",
+    "test_df = image_df.withColumn(\"text\", lit(\"<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\\n\\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\\n\\n\"))\n",
+    "\n",
+    "image_assembler = ImageAssembler().setInputCol(\"image\").setOutputCol(\"image_assembler\")\n",
+    "\n",
+    "imageClassifier = MLLamaForMultimodal.load(\"file:///tmp/MLLama_spark_nlp\")\\\n",
+    "            .setMaxOutputLength(50) \\\n",
+    "            .setInputCols(\"image_assembler\") \\\n",
+    "            .setOutputCol(\"answer\")\n",
+    "\n",
+    "pipeline = Pipeline(\n",
+    "            stages=[\n",
+    "                image_assembler,\n",
+    "                imageClassifier,\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "model = pipeline.fit(test_df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "image_path: /home/prabod/Projects/spark-nlp/examples/python/transformers/openvino/images/image1.jpg\n",
+      "[Annotation(document, 0, 208, This image depicts a cat lying in a box, on a carpet. The image features a cat lying in a box placed on a carpet. The image features a cat lying in a box placed on a carpet. The image features a cat lying in a, Map(), [])]\n"
+     ]
+    }
+   ],
+   "source": [
+    "light_pipeline = LightPipeline(model)\n",
+    "image_path = os.getcwd() + \"/images/\" + \"image1.jpg\"\n",
+    "print(\"image_path: \" + image_path)\n",
+    "annotations_result = light_pipeline.fullAnnotateImage(\n",
+    "    image_path,\n",
+    "    \"<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\\n\\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\\n\\n\"\n",
+    ")\n",
+    "\n",
+    "for result in annotations_result:\n",
+    "    print(result[\"answer\"])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "mllama",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.21"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Phi3Vision.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Phi3Vision.ipynb
new file mode 100644
index 00000000000000..1fcd43a3d495df
--- /dev/null
+++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Phi3Vision.ipynb
@@ -0,0 +1,1791 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Phi3Vision.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Import OpenVINO Phi3Vision models from HuggingFace 🤗 into Spark NLP 🚀\n",
+    "\n",
+    "This notebook provides a detailed walkthrough on optimizing and importing Phi3Vision models from HuggingFace  for use in Spark NLP, with [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html). The focus is on converting the model to the OpenVINO format and applying precision optimizations (INT8 and INT4), to enhance the performance and efficiency on CPU platforms using [Optimum Intel](https://huggingface.co/docs/optimum/main/en/intel/inference).\n",
+    "\n",
+    "Let's keep in mind a few things before we start 😊\n",
+    "\n",
+    "- OpenVINO support was introduced in  `Spark NLP 5.4.0`, enabling high performance CPU inference for models. So please make sure you have upgraded to the latest Spark NLP release.\n",
+    "- Model quantization is a computationally expensive process, so it is recommended to use a runtime with more than 32GB memory for exporting the quantized model from HuggingFace.\n",
+    "- You can import Phi3Vision models via `Phi3Vision`. These models are usually under `Text Generation` category and have `Phi3Vision` in their labels.\n",
+    "- Reference: [Phi3Vision](https://huggingface.co/docs/transformers/model_doc/llama#transformers.Phi3Vision)\n",
+    "- Some [example models](https://huggingface.co/models?search=Phi3Vision)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Export and Save the HuggingFace model\n",
+    "\n",
+    "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n",
+    "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future release, but we wanted you to know which versions have been tested successfully."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install -q \"torch>=2.1\" \"torchvision\" \"transformers==4.41\" \"protobuf>=3.20\" \"gradio>=4.26\" \"Pillow\" \"accelerate\" \"tqdm\"  --extra-index-url https://download.pytorch.org/whl/cpu\n",
+    "%pip install  -q \"openvino>=2024.2.0\" \"nncf>=2.11.0\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/importlib/util.py:245: DeprecationWarning: The `openvino.runtime` module is deprecated and will be removed in the 2026.0 release. Please replace `openvino.runtime` with `openvino`.\n",
+      "  self.__spec__.loader.exec_module(self)\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "# taken from https://github.com/openvinotoolkit/openvino_notebooks/blob/e14498f99864a10e37223ec74bf7f7827c07633d/notebooks/phi-3-vision/phi-3-vision.ipynb\n",
+    "\n",
+    "\n",
+    "from pathlib import Path\n",
+    "import types\n",
+    "from typing import Optional, Tuple, Union, List\n",
+    "import gc\n",
+    "import openvino as ov\n",
+    "from openvino.runtime import opset13\n",
+    "import nncf\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from transformers import AutoModelForCausalLM, AutoProcessor, AutoConfig\n",
+    "from transformers.generation import GenerationConfig, GenerationMixin\n",
+    "from transformers.modeling_outputs import CausalLMOutputWithPast, BaseModelOutputWithPast\n",
+    "\n",
+    "\n",
+    "def model_has_state(ov_model: ov.Model):\n",
+    "    return len(ov_model.get_sinks()) > 0\n",
+    "\n",
+    "\n",
+    "def model_has_input_output_name(ov_model: ov.Model, name: str):\n",
+    "    \"\"\"\n",
+    "    Helper function for checking that model has specified input or output name\n",
+    "\n",
+    "    Parameters:\n",
+    "      ov_model (ov.Model):\n",
+    "      name (str):\n",
+    "          name of input or output\n",
+    "\n",
+    "    Returns:\n",
+    "      True if input or output with requested name exists else False\n",
+    "    \"\"\"\n",
+    "    return name in sum([list(t.get_names()) for t in ov_model.inputs + ov_model.outputs], [])\n",
+    "\n",
+    "\n",
+    "def fuse_cache_reorder(\n",
+    "    ov_model: ov.Model,\n",
+    "    not_kv_inputs: List[str],\n",
+    "    key_value_input_names: List[str],\n",
+    "    gather_dim: int,\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Fuses reored_cache during generate cycle into ov.Model. Used with stateful models, because we can not modify model state directly.\n",
+    "\n",
+    "    Adds a new beam_idx parameter and Gather op per each kv-cache input in a given model.\n",
+    "    Should be run before make_stateful. Implements optimumum's _reorder_cache\n",
+    "    inside the model in the beginning of each iteration.\n",
+    "    Gather works along given gather_dim dimension that may vary from model to model.\n",
+    "    KV-cache inputs are identified based on names in key_value_input_names.\n",
+    "    Append the new beam_idx parameter to not_kv_inputs.\n",
+    "\n",
+    "    Parameters:\n",
+    "      ov_model (`ov.Model`):\n",
+    "          openvino model for processing\n",
+    "      not_kv_inputs (`List[str]`):\n",
+    "          list of input nodes in model that not related to past key values\n",
+    "      key_value_input_names (`List[str]`):\n",
+    "          list of names for key value input layers\n",
+    "      gather_dim (int):\n",
+    "          dimension for gathering cache during reorder pass\n",
+    "    \"\"\"\n",
+    "\n",
+    "    if model_has_input_output_name(ov_model, \"beam_idx\"):\n",
+    "        raise ValueError(\"Model already has fused cache\")\n",
+    "    input_batch = ov_model.input(\"inputs_embeds\").get_partial_shape()[0]\n",
+    "    beam_idx = opset13.parameter(name=\"beam_idx\", dtype=ov.Type.i32, shape=ov.PartialShape([input_batch]))\n",
+    "    beam_idx.output(0).get_tensor().add_names({\"beam_idx\"})  # why list is not accepted?\n",
+    "    ov_model.add_parameters([beam_idx])\n",
+    "    not_kv_inputs.append(ov_model.inputs[-1])\n",
+    "    # Go over all cache parameters and fuse _reorder_cache with indices provided by the new parameter beam_idx\n",
+    "    for input_name in key_value_input_names:\n",
+    "        parameter_output_port = ov_model.input(input_name)\n",
+    "        consumers = parameter_output_port.get_target_inputs()\n",
+    "        gather = opset13.gather(parameter_output_port, beam_idx, opset13.constant(gather_dim))\n",
+    "        for consumer in consumers:\n",
+    "            consumer.replace_source_output(gather.output(0))\n",
+    "    ov_model.validate_nodes_and_infer_types()\n",
+    "\n",
+    "\n",
+    "def build_state_initializer(ov_model: ov.Model, batch_dim: int):\n",
+    "    \"\"\"\n",
+    "    Build initialization ShapeOf Expression for all ReadValue ops\n",
+    "\n",
+    "    Parameters:\n",
+    "      ov_model (ov.Model):\n",
+    "          openvino model\n",
+    "      batch_dim (int):\n",
+    "          index of dimension corresponding to batch size\n",
+    "    \"\"\"\n",
+    "    input_ids = ov_model.input(\"inputs_embeds\")\n",
+    "    batch = opset13.gather(\n",
+    "        opset13.shape_of(input_ids, output_type=\"i64\"),\n",
+    "        opset13.constant([0]),\n",
+    "        opset13.constant(0),\n",
+    "    )\n",
+    "    for op in ov_model.get_ops():\n",
+    "        if op.get_type_name() == \"ReadValue\":\n",
+    "            dims = [dim.min_length for dim in list(op.get_output_partial_shape(0))]\n",
+    "            dims[batch_dim] = batch\n",
+    "            dims = [(opset13.constant(np.array([dim], dtype=np.int64)) if isinstance(dim, int) else dim) for dim in dims]\n",
+    "            shape = opset13.concat(dims, axis=0)\n",
+    "            broadcast = opset13.broadcast(opset13.constant(0.0, dtype=op.get_output_element_type(0)), shape)\n",
+    "            op.set_arguments([broadcast])\n",
+    "    ov_model.validate_nodes_and_infer_types()\n",
+    "\n",
+    "\n",
+    "def make_stateful(\n",
+    "    ov_model: ov.Model,\n",
+    "    not_kv_inputs: List[str],\n",
+    "    key_value_input_names: List[str],\n",
+    "    key_value_output_names: List[str],\n",
+    "    batch_dim: int,\n",
+    "    num_attention_heads: int,\n",
+    "    num_beams_and_batch: int = None,\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Hides kv-cache inputs and outputs inside the model as variables.\n",
+    "\n",
+    "    Parameters:\n",
+    "        ov_model (ov.Model):\n",
+    "            openvino model\n",
+    "        not_kv_inputs (`List[str]`):\n",
+    "            list of input nodes in model that not related to past key values\n",
+    "        key_value_input_names (`List[str]`):\n",
+    "            list of names for key value input layers\n",
+    "        key_value_output_names (`List[str]`):\n",
+    "            list of names for key value input layers\n",
+    "        batch_dim (int):\n",
+    "            index of batch dimension in key value layers\n",
+    "        num_attention_heads (int):\n",
+    "            number of attention heads for batch dimension initialization\n",
+    "        num_beams_an_batch (int):\n",
+    "            precalculated number of beams and batch for shapes initialization\n",
+    "    \"\"\"\n",
+    "    from openvino._offline_transformations import apply_make_stateful_transformation\n",
+    "\n",
+    "    input_output_map = {}\n",
+    "\n",
+    "    if num_beams_and_batch is not None:\n",
+    "        # Set batch size for input_ids and attention mask to avoid dynamic dimension got propagated from the end of the model back to ReadValue\n",
+    "        for input in not_kv_inputs:\n",
+    "            shape = input.get_partial_shape()\n",
+    "            if shape.rank.get_length() <= 2:  # == 1 for beam_index\n",
+    "                shape[0] = num_beams_and_batch\n",
+    "                input.get_node().set_partial_shape(shape)\n",
+    "    for kv_name_pair in zip(key_value_input_names, key_value_output_names):\n",
+    "        input_output_map[kv_name_pair[0]] = kv_name_pair[1]\n",
+    "        if num_beams_and_batch is not None:\n",
+    "            input = ov_model.input(kv_name_pair[0])\n",
+    "            shape = input.get_partial_shape()\n",
+    "            shape[batch_dim] = num_beams_and_batch * num_attention_heads\n",
+    "            input.get_node().set_partial_shape(shape)\n",
+    "\n",
+    "    if num_beams_and_batch is not None:\n",
+    "        # Re-validation model if shapes are altered above\n",
+    "        ov_model.validate_nodes_and_infer_types()\n",
+    "\n",
+    "    apply_make_stateful_transformation(ov_model, input_output_map)\n",
+    "    if num_beams_and_batch is None:\n",
+    "        build_state_initializer(ov_model, batch_dim)\n",
+    "\n",
+    "\n",
+    "def patch_stateful(ov_model):\n",
+    "    key_value_input_names = [key.get_any_name() for key in ov_model.inputs[2:-1]]\n",
+    "    key_value_output_names = [key.get_any_name() for key in ov_model.outputs[1:]]\n",
+    "    not_kv_inputs = [input for input in ov_model.inputs if not any(name in key_value_input_names for name in input.get_names())]\n",
+    "    if not key_value_input_names or not key_value_output_names:\n",
+    "        return\n",
+    "    batch_dim = 0\n",
+    "    num_attention_heads = 1\n",
+    "\n",
+    "    fuse_cache_reorder(ov_model, not_kv_inputs, key_value_input_names, batch_dim)\n",
+    "    make_stateful(\n",
+    "        ov_model,\n",
+    "        not_kv_inputs,\n",
+    "        key_value_input_names,\n",
+    "        key_value_output_names,\n",
+    "        batch_dim,\n",
+    "        num_attention_heads,\n",
+    "        None,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "core = ov.Core()\n",
+    "\n",
+    "\n",
+    "def cleanup_torchscript_cache():\n",
+    "    \"\"\"\n",
+    "    Helper for removing cached model representation\n",
+    "    \"\"\"\n",
+    "    torch._C._jit_clear_class_registry()\n",
+    "    torch.jit._recursive.concrete_type_store = torch.jit._recursive.ConcreteTypeStore()\n",
+    "    torch.jit._state._clear_class_state()\n",
+    "\n",
+    "\n",
+    "def convert_phi3_model(model_id, output_dir, quantization_config):\n",
+    "    output_dir = Path(output_dir)\n",
+    "\n",
+    "    lang_model_path = output_dir / \"language_model.xml\"\n",
+    "    image_embed_path = output_dir / \"image_embed.xml\"\n",
+    "    img_projection_path = output_dir / \"img_projection.xml\"\n",
+    "    embed_token_path = output_dir / \"embed_token.xml\"\n",
+    "    embed_token_path_2 = output_dir / \"wte_model.xml\"\n",
+    "\n",
+    "    if all(\n",
+    "        [\n",
+    "            lang_model_path.exists(),\n",
+    "            image_embed_path.exists(),\n",
+    "            img_projection_path.exists(),\n",
+    "            embed_token_path.exists(),\n",
+    "            embed_token_path_2.exists(),\n",
+    "        ]\n",
+    "    ):\n",
+    "        print(f\"✅ Phi-3-vision model already converted. You can find results in {output_dir}\")\n",
+    "        return\n",
+    "    print(\"⌛ Phi-3-vision conversion started. Be patient, it may takes some time.\")\n",
+    "    print(\"⌛ Load Original model\")\n",
+    "    model = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True, _attn_implementation=\"eager\")\n",
+    "    processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)\n",
+    "    model.config.save_pretrained(output_dir)\n",
+    "    processor.save_pretrained(output_dir)\n",
+    "    print(\"✅ Original model successfully loaded\")\n",
+    "\n",
+    "    if not embed_token_path_2.exists():\n",
+    "        print(\"⌛ Convert Input embedding model\")\n",
+    "        ov_model = ov.convert_model(\n",
+    "            model.model.embed_tokens,\n",
+    "            example_input=torch.ones([2, 2], dtype=torch.int64),\n",
+    "        )\n",
+    "        ov.save_model(ov_model, embed_token_path)\n",
+    "        ov.save_model(ov_model, embed_token_path_2)\n",
+    "        del ov_model\n",
+    "        cleanup_torchscript_cache()\n",
+    "        gc.collect()\n",
+    "        print(\"✅ Input embedding model successfully converted\")\n",
+    "\n",
+    "    vision_embed_tokens = model.model.vision_embed_tokens\n",
+    "    if not image_embed_path.exists():\n",
+    "        print(\"⌛ Convert Image embedding model\")\n",
+    "        vision_embed_tokens.forward = vision_embed_tokens.get_img_features\n",
+    "        ov_model = ov.convert_model(vision_embed_tokens, example_input=torch.ones([17, 3, 336, 336]))\n",
+    "        ov.save_model(ov_model, image_embed_path)\n",
+    "        del ov_model\n",
+    "        cleanup_torchscript_cache()\n",
+    "        gc.collect()\n",
+    "        print(\"✅ Image embedding model successfully converted\")\n",
+    "\n",
+    "    if not img_projection_path.exists():\n",
+    "        print(\"⌛ Convert Image projection model\")\n",
+    "        ov_model = ov.convert_model(\n",
+    "            vision_embed_tokens.img_projection,\n",
+    "            example_input=torch.ones([1, 1921, 4096]),\n",
+    "        )\n",
+    "        ov.save_model(ov_model, img_projection_path)\n",
+    "        del ov_model\n",
+    "        cleanup_torchscript_cache()\n",
+    "        gc.collect()\n",
+    "        print(\"✅ Image projection model successfully converted\")\n",
+    "\n",
+    "    if not lang_model_path.exists():\n",
+    "        print(\"⌛ Convert Language model\")\n",
+    "\n",
+    "        def forward_wrap(\n",
+    "            self,\n",
+    "            attention_mask,\n",
+    "            position_ids=None,\n",
+    "            past_key_values=None,\n",
+    "            inputs_embeds=None,\n",
+    "        ):\n",
+    "            result = self._orig_forward(\n",
+    "                input_ids=None,\n",
+    "                attention_mask=attention_mask,\n",
+    "                position_ids=position_ids,\n",
+    "                past_key_values=past_key_values,\n",
+    "                inputs_embeds=inputs_embeds,\n",
+    "            )\n",
+    "            return tuple(result.values())\n",
+    "\n",
+    "        model._orig_forward = model.forward\n",
+    "        model.forward = types.MethodType(forward_wrap, model)\n",
+    "        llm_input = torch.zeros([2, 2, 3072])\n",
+    "        pkv = model(\n",
+    "            inputs_embeds=llm_input,\n",
+    "            attention_mask=torch.ones((2, 2), dtype=torch.int64),\n",
+    "        )[1]\n",
+    "        model_inputs = [\"attention_mask\", \"position_ids\"]\n",
+    "        model_outputs = [\"logits\"]\n",
+    "        for idx in range(len(pkv)):\n",
+    "            model_inputs.extend([f\"past_key_values.{idx}.key\", f\"past_key_values.{idx}.value\"])\n",
+    "            model_outputs.extend([f\"present.{idx}.key\", f\"present.{idx}.value\"])\n",
+    "        model_inputs.append(\"inputs_embeds\")\n",
+    "        position_ids = torch.tensor([[2, 3], [2, 3]])\n",
+    "        ov_model = ov.convert_model(\n",
+    "            model,\n",
+    "            example_input={\n",
+    "                \"inputs_embeds\": llm_input,\n",
+    "                \"attention_mask\": torch.ones([2, 4], dtype=torch.int64),\n",
+    "                \"past_key_values\": pkv,\n",
+    "                \"position_ids\": position_ids,\n",
+    "            },\n",
+    "        )\n",
+    "\n",
+    "        for input, input_name in zip(ov_model.inputs, model_inputs):\n",
+    "            input.get_tensor().set_names({input_name})\n",
+    "\n",
+    "        for output, output_name in zip(ov_model.outputs, model_outputs):\n",
+    "            output.get_tensor().set_names({output_name})\n",
+    "        patch_stateful(ov_model)\n",
+    "        print(\"✅ Language model successfully converted\")\n",
+    "\n",
+    "        if quantization_config is not None:\n",
+    "            print(f\"⌛ Weights compression with {quantization_config['mode']} mode started\")\n",
+    "            ov_model = nncf.compress_weights(ov_model, **quantization_config)\n",
+    "            print(\"✅ Weights compression finished\")\n",
+    "\n",
+    "        ov.save_model(ov_model, lang_model_path)\n",
+    "        del ov_model\n",
+    "        cleanup_torchscript_cache()\n",
+    "        del model\n",
+    "        gc.collect()\n",
+    "        print(f\"✅ Phi-3-vision model conversion finished. You can find results in {output_dir}\")\n",
+    "\n",
+    "\n",
+    "class OvPhi3Vision(GenerationMixin):\n",
+    "    def __init__(self, model_dir, device):\n",
+    "        model_dir = Path(model_dir)\n",
+    "        self.model = core.read_model(model_dir / \"language_model.xml\")\n",
+    "        self.image_embed = core.compile_model(model_dir / \"image_embed.xml\", device)\n",
+    "        self.img_projection = core.compile_model(model_dir / \"img_projection.xml\", device)\n",
+    "        self.embed_tokem = core.compile_model(model_dir / \"embed_token.xml\", device)\n",
+    "        self.input_names = {key.get_any_name(): idx for idx, key in enumerate(self.model.inputs)}\n",
+    "        self.output_names = {key.get_any_name(): idx for idx, key in enumerate(self.model.outputs)}\n",
+    "        compiled_model = core.compile_model(self.model, device)\n",
+    "        self.request = compiled_model.create_infer_request()\n",
+    "        self.config = AutoConfig.from_pretrained(model_dir, trust_remote_code=True)\n",
+    "        self.generation_config = GenerationConfig.from_model_config(self.config)\n",
+    "        self.main_input_name = \"input_ids\"\n",
+    "        self.device = torch.device(\"cpu\")\n",
+    "        self.num_pkv = 2\n",
+    "        self._supports_cache_class = False\n",
+    "        self.next_beam_idx = None\n",
+    "        self._past_length = None\n",
+    "        self.hd_transform_order = \"glb_sub\"\n",
+    "        self.num_img_tokens = self.config.img_processor[\"num_img_tokens\"]\n",
+    "        self.image_dim_out = self.config.img_processor[\"image_dim_out\"]\n",
+    "        self.glb_GN = torch.zeros([1, 1, self.image_dim_out * 4])\n",
+    "        self.sub_GN = torch.zeros([1, 1, 1, self.image_dim_out * 4])\n",
+    "\n",
+    "    def can_generate(self):\n",
+    "        \"\"\"Returns True to validate the check that the model using `GenerationMixin.generate()` can indeed generate.\"\"\"\n",
+    "        return True\n",
+    "\n",
+    "    def __call__(\n",
+    "        self,\n",
+    "        input_ids: torch.LongTensor,\n",
+    "        pixel_values: torch.Tensor,\n",
+    "        attention_mask: Optional[torch.LongTensor] = None,\n",
+    "        past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,\n",
+    "        position_ids: Optional[torch.LongTensor] = None,\n",
+    "        image_sizes=None,\n",
+    "        **kwargs,\n",
+    "    ) -> CausalLMOutputWithPast:\n",
+    "        return self.forward(\n",
+    "            input_ids=input_ids,\n",
+    "            pixel_values=pixel_values,\n",
+    "            attention_mask=attention_mask,\n",
+    "            past_key_values=past_key_values,\n",
+    "            position_ids=position_ids,\n",
+    "            image_sizes=image_sizes,\n",
+    "            **kwargs,\n",
+    "        )\n",
+    "\n",
+    "    def forward(\n",
+    "        self,\n",
+    "        input_ids: torch.LongTensor = None,\n",
+    "        attention_mask: Optional[torch.Tensor] = None,\n",
+    "        position_ids: Optional[torch.LongTensor] = None,\n",
+    "        past_key_values: Optional[List[torch.FloatTensor]] = None,\n",
+    "        inputs_embeds: Optional[torch.FloatTensor] = None,\n",
+    "        pixel_values: Optional[torch.FloatTensor] = None,\n",
+    "        image_sizes: Optional[torch.LongTensor] = None,\n",
+    "        **kwargs,\n",
+    "    ) -> Union[Tuple, BaseModelOutputWithPast]:\n",
+    "        if inputs_embeds is None:\n",
+    "            if pixel_values is not None and image_sizes is not None:\n",
+    "                inputs_embeds = self.vision_embed_tokens(input_ids, pixel_values=pixel_values, image_sizes=image_sizes)\n",
+    "            else:\n",
+    "                inputs_embeds = self.embed_token(input_ids)[0]\n",
+    "        if past_key_values is None:\n",
+    "            self.request.reset_state()\n",
+    "            self.next_beam_idx = np.arange(inputs_embeds.shape[0], dtype=int)\n",
+    "            self._past_length = 0\n",
+    "        inputs = {}\n",
+    "        inputs[\"inputs_embeds\"] = inputs_embeds\n",
+    "        inputs[\"attention_mask\"] = attention_mask\n",
+    "        inputs[\"position_ids\"] = position_ids\n",
+    "        if \"beam_idx\" in self.input_names:\n",
+    "            inputs[\"beam_idx\"] = self.next_beam_idx if self.next_beam_idx is not None else np.arange(inputs_embeds.shape[0], dtype=int)\n",
+    "        self.request.start_async(inputs, share_inputs=True)\n",
+    "        self.request.wait()\n",
+    "        logits = self.request.get_tensor(\"logits\").data\n",
+    "        logits = torch.from_numpy(logits).to(self.device)\n",
+    "        past_key_values = ((),)\n",
+    "        self._past_length += inputs[\"inputs_embeds\"].shape[1]\n",
+    "\n",
+    "        return CausalLMOutputWithPast(logits=logits, past_key_values=past_key_values)\n",
+    "\n",
+    "    def _reorder_cache(self, past_key_values: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor) -> Tuple[Tuple[torch.Tensor]]:\n",
+    "        \"\"\"\n",
+    "        This function is used to re-order the `past_key_values` cache if [`~PreTrainedModel.beam_search`] or\n",
+    "        [`~PreTrainedModel.beam_sample`] is called.\n",
+    "        This is required to match `past_key_values` with the correct beam_idx at every generation step.\n",
+    "        \"\"\"\n",
+    "        self.next_beam_idx = np.array(beam_idx)  # save beam_idx to be used as an input in the next iteration\n",
+    "        return past_key_values\n",
+    "\n",
+    "    def _get_past_length(self, past_key_values=None):\n",
+    "        if past_key_values is None:\n",
+    "            return 0\n",
+    "        return self._past_length\n",
+    "\n",
+    "    def prepare_inputs_for_generation(\n",
+    "        self,\n",
+    "        input_ids,\n",
+    "        past_key_values=None,\n",
+    "        attention_mask=None,\n",
+    "        inputs_embeds=None,\n",
+    "        pixel_values=None,\n",
+    "        image_sizes=None,\n",
+    "        **kwargs,\n",
+    "    ):\n",
+    "        if past_key_values is not None:\n",
+    "            past_length = self._get_past_length(past_key_values)\n",
+    "\n",
+    "            # Keep only the unprocessed tokens:\n",
+    "            # 1 - If the length of the attention_mask exceeds the length of input_ids, then we are in a setting where\n",
+    "            # some of the inputs are exclusively passed as part of the cache (e.g. when passing input_embeds as\n",
+    "            # input)\n",
+    "            if attention_mask is not None and attention_mask.shape[1] > input_ids.shape[1]:\n",
+    "                input_ids = input_ids[:, -(attention_mask.shape[1] - past_length) :]\n",
+    "            # 2 - If the past_length is smaller than input_ids', then input_ids holds all input tokens. We can discard\n",
+    "            # input_ids based on the past_length.\n",
+    "            elif past_length < input_ids.shape[1]:\n",
+    "                input_ids = input_ids[:, past_length:]\n",
+    "\n",
+    "        position_ids = kwargs.get(\"position_ids\", None)\n",
+    "        if attention_mask is not None and position_ids is None:\n",
+    "            # create position_ids on the fly for batch generation\n",
+    "            position_ids = attention_mask.long().cumsum(-1) - 1\n",
+    "            position_ids.masked_fill_(attention_mask == 0, 1)\n",
+    "            if past_key_values:\n",
+    "                position_ids = position_ids[:, -input_ids.shape[1] :]\n",
+    "\n",
+    "        # if `inputs_embeds` are passed, we only want to use them in the 1st generation step\n",
+    "        if inputs_embeds is not None and past_key_values is None:\n",
+    "            model_inputs = {\"inputs_embeds\": inputs_embeds}\n",
+    "        else:\n",
+    "            model_inputs = {\"input_ids\": input_ids}\n",
+    "\n",
+    "        model_inputs.update(\n",
+    "            {\n",
+    "                \"position_ids\": position_ids,\n",
+    "                \"past_key_values\": past_key_values,\n",
+    "                \"use_cache\": kwargs.get(\"use_cache\"),\n",
+    "                \"attention_mask\": attention_mask,\n",
+    "                \"pixel_values\": pixel_values,\n",
+    "                \"image_sizes\": image_sizes,\n",
+    "            }\n",
+    "        )\n",
+    "        return model_inputs\n",
+    "\n",
+    "    def vision_embed_tokens(\n",
+    "        self,\n",
+    "        input_ids: torch.LongTensor,\n",
+    "        pixel_values: torch.FloatTensor,\n",
+    "        image_sizes=None,\n",
+    "    ) -> torch.FloatTensor:\n",
+    "        MAX_INPUT_ID = int(1e9)\n",
+    "        img_embeds = pixel_values\n",
+    "        img_sizes = image_sizes\n",
+    "\n",
+    "        input_shape = input_ids.size()\n",
+    "        input_ids = input_ids.view(-1, input_shape[-1])\n",
+    "\n",
+    "        with torch.no_grad():\n",
+    "            positions = torch.nonzero((input_ids < 0) & (input_ids > -MAX_INPUT_ID), as_tuple=False)\n",
+    "\n",
+    "        select = False\n",
+    "        if len(positions.tolist()) > 0:\n",
+    "            g_values = abs(input_ids[positions[:, 0], positions[:, 1]])\n",
+    "\n",
+    "            if img_sizes is not None and len(img_sizes):\n",
+    "                hd_transform = True\n",
+    "                bs = img_embeds.shape[0]\n",
+    "                # Nx(HW)xC\n",
+    "                img_features = torch.from_numpy(self.image_embed(img_embeds.flatten(0, 1))[0])\n",
+    "                base_feat_height = base_feat_width = int(img_features.shape[1] ** 0.5)\n",
+    "\n",
+    "                # bs x max_num_crops x (24x24) x C\n",
+    "                img_features = img_features.view(bs, -1, base_feat_height * base_feat_width, self.image_dim_out)\n",
+    "                C = self.image_dim_out\n",
+    "                H = base_feat_height\n",
+    "\n",
+    "                output_imgs = []\n",
+    "                output_len = []\n",
+    "                # training is tensor, inference is list\n",
+    "                if isinstance(img_sizes, torch.Tensor):\n",
+    "                    img_sizes = img_sizes.view(-1, 2)\n",
+    "                for _bs in range(bs):\n",
+    "                    h, w = img_sizes[_bs]\n",
+    "                    h = h // 336\n",
+    "                    w = w // 336\n",
+    "                    B_ = h * w\n",
+    "\n",
+    "                    # 1 x (24x24) x 1024\n",
+    "                    global_img_feature = img_features[_bs, :1]\n",
+    "\n",
+    "                    # 1 x 12 x 12 x 4096\n",
+    "                    glb_img = (\n",
+    "                        global_img_feature.reshape(1, H, H, C)\n",
+    "                        .reshape(1, H // 2, 2, H // 2, 2, C)\n",
+    "                        .contiguous()\n",
+    "                        .permute(0, 1, 3, 2, 4, 5)\n",
+    "                        .reshape(1, H // 2, H // 2, 4 * C)\n",
+    "                        .contiguous()\n",
+    "                    )\n",
+    "                    temp_glb_GN = self.sub_GN.repeat(1, H // 2, 1, 1)\n",
+    "\n",
+    "                    # 1 x 156 x 4096\n",
+    "                    glb_img = torch.cat([glb_img, temp_glb_GN], dim=2).reshape(1, -1, 4 * C)\n",
+    "\n",
+    "                    # (max_num_crops-1) x (12x12) x C\n",
+    "                    sub_img = img_features[_bs, 1:]\n",
+    "                    # 16x574x1024\n",
+    "                    # get rid of padding sub_img\n",
+    "                    sub_img = sub_img[:B_]\n",
+    "\n",
+    "                    # (num_crops, 12, 2, 12, 2, 1024) -> (num_crops, 12, 12, 2, 2, 1024) -> (num_crops, 12*12, 4*1024)\n",
+    "                    sub_img = (\n",
+    "                        sub_img.reshape(B_, H, H, C)\n",
+    "                        .reshape(B_, H // 2, 2, H // 2, 2, C)\n",
+    "                        .contiguous()\n",
+    "                        .permute(0, 1, 3, 2, 4, 5)\n",
+    "                        .reshape(B_, -1, 4 * C)\n",
+    "                        .contiguous()\n",
+    "                    )\n",
+    "                    sub_img = sub_img.reshape(1, h, w, 12, 12, -1).permute(0, 1, 3, 2, 4, 5).reshape(1, h * 12, w * 12, 4 * C)\n",
+    "                    temp_sub_GN = self.sub_GN.repeat(1, h * 12, 1, 1)\n",
+    "                    sub_img = torch.cat([sub_img, temp_sub_GN], dim=2).reshape(1, -1, 4 * C)\n",
+    "                    # (1, num_img_tokens, 1024*4)\n",
+    "\n",
+    "                    # glb + sub\n",
+    "                    if self.hd_transform_order == \"glb_sub\":\n",
+    "                        output_imgs.append(torch.cat([glb_img, self.glb_GN, sub_img], dim=1))\n",
+    "                    elif self.hd_transform_order == \"sub_glb\":\n",
+    "                        output_imgs.append(torch.cat([sub_img, self.glb_GN, glb_img], dim=1))\n",
+    "                    else:\n",
+    "                        raise NotImplementedError(f\"hd_transform_order = {self.hd_transform_order}, not implemented\")\n",
+    "\n",
+    "                    temp_len = int((h * w + 1) * 144 + 1 + (h + 1) * 12)\n",
+    "                    output_len.append(temp_len)\n",
+    "\n",
+    "                num_img_tokens = output_len\n",
+    "                img_set_tensor = []\n",
+    "                for _output_img in output_imgs:\n",
+    "                    img_feature_proj = torch.from_numpy(self.img_projection(_output_img)[0])\n",
+    "                    img_set_tensor.append(img_feature_proj)\n",
+    "            elif img_embeds.ndim == 4:\n",
+    "                selected_g_values = g_values[:: self.num_img_tokens]\n",
+    "                tt = self.image_embed(img_embeds).reshape(-1, self.image_dim_out)[0]\n",
+    "                img_set_tensor = torch.from_numpy(self.img_projection(tt)[0])  # adapted visual features.\n",
+    "            elif img_embeds.ndim == 3:\n",
+    "                selected_g_values = g_values[:: self.num_img_tokens]\n",
+    "                tt = img_embeds.view(-1, self.image_dim_out)\n",
+    "                img_set_tensor = torch.from_numpy(self.img_projection(tt)[0])  # adapted visual features.\n",
+    "            else:\n",
+    "                raise NotImplementedError\n",
+    "            select = True\n",
+    "            input_ids.clamp_min_(0).clamp_max_(self.config.vocab_size)\n",
+    "\n",
+    "        hidden_states = torch.from_numpy(self.embed_tokem(input_ids)[0])\n",
+    "        if select:\n",
+    "            if hd_transform:\n",
+    "                idx = 0\n",
+    "                for i, cnt in enumerate(num_img_tokens):\n",
+    "                    hidden_states[positions[idx, 0], positions[idx, 1] : positions[idx, 1] + cnt] = img_set_tensor[i]\n",
+    "                    idx += cnt\n",
+    "            else:\n",
+    "                idx = 0\n",
+    "                for i, g in enumerate(selected_g_values):\n",
+    "                    cnt = self.num_img_tokens\n",
+    "                    hidden_states[positions[idx, 0], positions[idx, 1] : positions[idx, 1] + cnt] = img_set_tensor[i * cnt : (i + 1) * cnt]\n",
+    "                    idx += cnt\n",
+    "        return hidden_states\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1 Convert the model to OpenVino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "⌛ Phi-3-vision conversion started. Be patient, it may takes some time.\n",
+      "⌛ Load Original model\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:01<00:00,  1.12it/s]\n",
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Original model successfully loaded\n",
+      "⌛ Convert Input embedding model\n",
+      "WARNING:nncf:NNCF provides best results with torch==2.5.*, while current torch version is 2.6.0+cpu. If you encounter issues, consider switching to torch==2.5.*\n",
+      "✅ Input embedding model successfully converted\n",
+      "⌛ Convert Image embedding model\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/transformers/modeling_utils.py:4481: FutureWarning: `_is_quantized_training_enabled` is going to be deprecated in transformers 4.39.0. Please use `model.hf_quantizer.is_trainable` instead\n",
+      "  warnings.warn(\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/transformers/models/clip/modeling_clip.py:276: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/transformers/models/clip/modeling_clip.py:316: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if attn_output.size() != (bsz * self.num_heads, tgt_len, self.head_dim):\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Image embedding model successfully converted\n",
+      "⌛ Convert Image projection model\n",
+      "✅ Image projection model successfully converted\n",
+      "⌛ Convert Language model\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "You are not running the flash-attention implementation, expect numerical differences.\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/transformers/modeling_attn_mask_utils.py:114: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if (input_shape[-1] > 1 or self.sliding_window is not None) and self.is_causal:\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/transformers/modeling_attn_mask_utils.py:162: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if past_key_values_length > 0:\n",
+      "/mnt/research/.cache/modules/transformers_modules/microsoft/Phi-3-vision-128k-instruct/c45209e90a4c4f7d16b2e9d48503c7f3e83623ed/modeling_phi3_v.py:143: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if seq_len > self.original_max_position_embeddings:\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/nncf/torch/dynamic_graph/wrappers.py:85: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
+      "  op1 = operator(*args, **kwargs)\n",
+      "/mnt/research/.cache/modules/transformers_modules/microsoft/Phi-3-vision-128k-instruct/c45209e90a4c4f7d16b2e9d48503c7f3e83623ed/modeling_phi3_v.py:381: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):\n",
+      "/mnt/research/.cache/modules/transformers_modules/microsoft/Phi-3-vision-128k-instruct/c45209e90a4c4f7d16b2e9d48503c7f3e83623ed/modeling_phi3_v.py:388: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):\n",
+      "/mnt/research/.cache/modules/transformers_modules/microsoft/Phi-3-vision-128k-instruct/c45209e90a4c4f7d16b2e9d48503c7f3e83623ed/modeling_phi3_v.py:400: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/torch/jit/_trace.py:165: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations. (Triggered internally at /pytorch/build/aten/src/ATen/core/TensorBody.h:489.)\n",
+      "  if a.grad is not None:\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Language model successfully converted\n",
+      "⌛ Weights compression with int4_sym mode started\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/rich/live.py:231: UserWarning: install \"ipywidgets\" \n",
+       "for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/rich/live.py:231: UserWarning: install \"ipywidgets\" \n",
+       "for Jupyter support\n",
+       "  warnings.warn('install \"ipywidgets\" for Jupyter support')\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:nncf:Statistics of the bitwidth distribution:\n",
+      "┍━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑\n",
+      "│ Weight compression mode   │ % all parameters (layers)   │ % ratio-defining parameters (layers)   │\n",
+      "┝━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┥\n",
+      "│ int8_asym                 │ 42% (54 / 129)              │ 40% (53 / 128)                         │\n",
+      "├───────────────────────────┼─────────────────────────────┼────────────────────────────────────────┤\n",
+      "│ int4_sym                  │ 58% (75 / 129)              │ 60% (75 / 128)                         │\n",
+      "┕━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┙\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Weights compression finished\n",
+      "✅ Phi-3-vision model conversion finished. You can find results in model/openvino/INT4\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "import nncf\n",
+    "\n",
+    "\n",
+    "model_id = \"microsoft/Phi-3-vision-128k-instruct\"\n",
+    "out_dir = Path(\"model/openvino/INT4\")\n",
+    "compression_configuration = {\n",
+    "    \"mode\": nncf.CompressWeightsMode.INT4_SYM,\n",
+    "    \"group_size\": 64,\n",
+    "    \"ratio\": 0.6,\n",
+    "}\n",
+    "convert_phi3_model(model_id, out_dir, compression_configuration)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Name: transformers\n",
+      "Version: 4.41.0\n",
+      "Summary: State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow\n",
+      "Home-page: https://github.com/huggingface/transformers\n",
+      "Author: The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/transformers/graphs/contributors)\n",
+      "Author-email: transformers@huggingface.co\n",
+      "License: Apache 2.0 License\n",
+      "Location: /home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages\n",
+      "Requires: filelock, huggingface-hub, numpy, packaging, pyyaml, regex, requests, safetensors, tokenizers, tqdm\n",
+      "Required-by: \n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip show transformers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List\n",
+    "import torch\n",
+    "\n",
+    "def reshape_hd_patches_2x2merge(self, image_features, h_crop, w_crop):\n",
+    "        \"\"\"\n",
+    "        image_features: (num_images*num_crops, 24*24, 1024)\n",
+    "        output: (num_images, h_crop*12, w_crop*12, 4096), h_crop*w_crop == num_crops\n",
+    "        \"\"\"\n",
+    "        N, L, C = image_features.shape\n",
+    "        # assert L == 24 * 24 and C == 1024\n",
+    "        \n",
+    "        # Calculate the number of images dynamically\n",
+    "        num_images = N // (h_crop * w_crop)\n",
+    "        \n",
+    "        # Compute the height dynamically using tensor operations\n",
+    "        H = 24  # Hardcoded value\n",
+    "        \n",
+    "        # Ensure h_crop and w_crop are tensors for traced operations\n",
+    "        # h_crop = torch.tensor(h_crop, dtype=torch.int32)\n",
+    "        # w_crop = torch.tensor(w_crop, dtype=torch.int32)\n",
+    "        \n",
+    "        image_features_hd = (\n",
+    "            image_features.reshape(N, H, H, C)  # N, 24, 24, 1024\n",
+    "            .reshape(N, H // 2, 2, H // 2, 2, C)  # N, 12, 2, 12, 2, 1024\n",
+    "            .permute(0, 1, 3, 2, 4, 5)  # N, 12, 12, 2, 2, 1024\n",
+    "            .reshape(N, -1, 4 * C)  # N, 144, 4096\n",
+    "            .reshape(\n",
+    "                num_images, h_crop, w_crop, H // 2, H // 2, -1\n",
+    "            )  # n_img, h_crop, w_crop, 12, 12, 4096\n",
+    "            .permute(0, 1, 3, 2, 4, 5)  # n_img, h_crop, 12, w_crop, 12, 4096\n",
+    "            .reshape(\n",
+    "                num_images, h_crop * (H // 2), w_crop * (H // 2), 4 * C\n",
+    "            )  # n_img, h_crop*12, w_crop*12, 4096\n",
+    "        )\n",
+    "\n",
+    "        return image_features_hd\n",
+    "\n",
+    "\n",
+    "# @torch.jit.script  # To make this function TorchScript compatible\n",
+    "def hd_feature_transform(self, image_features: torch.Tensor, image_sizes: torch.Tensor) -> torch.Tensor:\n",
+    "    \"\"\"\n",
+    "    image_features: (num_images, num_crops+1, 24*24, 1024)\n",
+    "    image_sizes: list of tuples (h, w) for each image\n",
+    "    \"\"\"\n",
+    "    # Assuming img_projection is either Sequential or Linear\n",
+    "\n",
+    "    global_image_features = image_features[:, 0]  # (num_images, 24*24, 1024)\n",
+    "\n",
+    "    # Assuming these methods are also TorchScript compatible\n",
+    "    global_image_features_hd = self.reshape_hd_patches_2x2merge(global_image_features, 1, 1)\n",
+    "    global_image_features_hd_newline = self.add_image_newline(global_image_features_hd)\n",
+    "\n",
+    "    all_image_embeddings = torch.jit.annotate(List[torch.Tensor], [])\n",
+    "\n",
+    "    # Iterate through each image and handle based on its size\n",
+    "    for i in range(image_features.size(0)):\n",
+    "        img_size = image_sizes[i]\n",
+    "        h, w = img_size[0], img_size[1]\n",
+    "        h_crop = h // 336\n",
+    "        w_crop = w // 336\n",
+    "        num_crops = h_crop * w_crop\n",
+    "\n",
+    "        # Process sub image features\n",
+    "        sub_image_features = image_features[i, 1:1 + num_crops]  # (num_crops, 24*24, 1024)\n",
+    "        sub_image_features_hd = self.reshape_hd_patches_2x2merge(sub_image_features, h_crop, w_crop)\n",
+    "        sub_image_features_hd_newline = self.add_image_newline(sub_image_features_hd)\n",
+    "\n",
+    "        # Append results to the list\n",
+    "        all_image_embeddings.append(sub_image_features_hd_newline.squeeze(0))  # (h_crop*12*(w_crop*12+1), 4096)\n",
+    "        all_image_embeddings.append(self.glb_GN.squeeze(0))\n",
+    "        all_image_embeddings.append(global_image_features_hd_newline[i])\n",
+    "\n",
+    "    # Concatenate all embeddings and apply the projection\n",
+    "    all_image_embeddings_cat = torch.cat(all_image_embeddings, dim=0)\n",
+    "    image_features_proj = self.img_projection(all_image_embeddings_cat)\n",
+    "\n",
+    "    return image_features_proj"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:02<00:00,  1.27s/it]\n",
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import AutoModelForCausalLM, AutoProcessor\n",
+    "\n",
+    "model_id = \"microsoft/Phi-3-vision-128k-instruct\"\n",
+    "\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True, _attn_implementation=\"eager\")\n",
+    "processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Question:\n",
+      " What is unusual on this picture?\n"
+     ]
+    },
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       ""
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "from PIL import Image\n",
+    "\n",
+    "url = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n",
+    "image = Image.open(requests.get(url, stream=True).raw)\n",
+    "\n",
+    "print(\"Question:\\n What is unusual on this picture?\")\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "You are using the default legacy behaviour of the . This is expected, and simply means that the `legacy` (previous) behavior will be used so nothing changes for you. If you want to use the new behaviour, set `legacy=False`. This should only be set if you understand what it means, and thoroughly read the reason why this was added as explained in https://github.com/huggingface/transformers/pull/24565\n",
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import AutoProcessor, TextStreamer\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"user\", \"content\": \"<|image_1|>\\nWhat is unusual on this picture?\"},\n",
+    "]\n",
+    "\n",
+    "processor = AutoProcessor.from_pretrained(out_dir, trust_remote_code=True)\n",
+    "\n",
+    "prompt = processor.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "\n",
+    "inputs_new = processor(prompt, [image], return_tensors=\"pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_ids = inputs_new[\"input_ids\"]\n",
+    "pixel_values = inputs_new[\"pixel_values\"]\n",
+    "image_sizes = inputs_new[\"image_sizes\"]\n",
+    "MAX_INPUT_ID = int(1e9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/transformers/modeling_utils.py:4481: FutureWarning: `_is_quantized_training_enabled` is going to be deprecated in transformers 4.39.0. Please use `model.hf_quantizer.is_trainable` instead\n",
+      "  warnings.warn(\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/transformers/models/clip/modeling_clip.py:276: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):\n",
+      "/home/prabod/anaconda3/envs/phi3v2/lib/python3.9/site-packages/transformers/models/clip/modeling_clip.py:316: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  if attn_output.size() != (bsz * self.num_heads, tgt_len, self.head_dim):\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import types\n",
+    "\n",
+    "vision_embed_tokens = model.model.vision_embed_tokens\n",
+    "\n",
+    "def forward_wrap(\n",
+    "        self,\n",
+    "        pixel_values,\n",
+    "        image_sizes,\n",
+    "        input_ids\n",
+    "):\n",
+    "    num_images, num_crops, c, h, w = pixel_values.shape\n",
+    "    MAX_INPUT_ID = int(1e9)\n",
+    "    # positions for image tokens\n",
+    "    positions = torch.nonzero((input_ids < 0) & (input_ids > -MAX_INPUT_ID), as_tuple=True)\n",
+    "    # input_shape = input_ids.size()\n",
+    "    # input_ids = input_ids.view(-1, input_shape[-1])\n",
+    "    input_ids = input_ids.clamp_min(0).clamp_max(self.vocab_size).detach()\n",
+    "    hidden_states = self.wte(input_ids)\n",
+    "    \n",
+    "    # torch jit condition check for the position shape\n",
+    "\n",
+    "    if len(positions) > 0:\n",
+    "\n",
+    "        img_features = self.get_img_features(pixel_values.flatten(0, 1)).reshape(\n",
+    "                    num_images, num_crops, -1, self.image_dim_out\n",
+    "                )\n",
+    "        image_features_proj = self.hd_feature_transform(img_features, image_sizes)\n",
+    "        hidden_states[positions] = image_features_proj\n",
+    "            \n",
+    "    return hidden_states\n",
+    "\n",
+    "vision_embed_tokens.reshape_hd_patches_2x2merge = types.MethodType(reshape_hd_patches_2x2merge, vision_embed_tokens)\n",
+    "vision_embed_tokens.hd_feature_transform = types.MethodType(hd_feature_transform, vision_embed_tokens)\n",
+    "vision_embed_tokens.forward = types.MethodType(forward_wrap, vision_embed_tokens)\n",
+    "ov_model = ov.convert_model(vision_embed_tokens, example_input={\n",
+    "    \"pixel_values\": pixel_values,\n",
+    "    \"image_sizes\": image_sizes,\n",
+    "    \"input_ids\": input_ids,\n",
+    "})\n",
+    "ov.save_model(ov_model, out_dir/\"reshape_model.xml\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "⌛ Check if all models are converted\n",
+      "✅ All models are converted. You can find results in {out_dir}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# check if all the models are converted\n",
+    "\n",
+    "print(\"⌛ Check if all models are converted\")\n",
+    "lang_model_path = out_dir / \"language_model.xml\"\n",
+    "image_embed_path = out_dir / \"image_embed.xml\"\n",
+    "img_projection_path = out_dir / \"img_projection.xml\"\n",
+    "embed_token_path = out_dir / \"embed_token.xml\"\n",
+    "embed_token_path_2 = out_dir / \"wte_model.xml\"\n",
+    "reshape_model_path = out_dir / \"reshape_model.xml\"\n",
+    "\n",
+    "if all(\n",
+    "    [\n",
+    "        lang_model_path.exists(),\n",
+    "        image_embed_path.exists(),\n",
+    "        img_projection_path.exists(),\n",
+    "        embed_token_path.exists(),\n",
+    "        embed_token_path_2.exists(),\n",
+    "        reshape_model_path.exists(),\n",
+    "    ]\n",
+    "):\n",
+    "    print(\"✅ All models are converted. You can find results in {out_dir}\")\n",
+    "else:\n",
+    "    print(\"❌ Not all models are converted. Please check the conversion process\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2 Copy assets to the assets folder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assets_dir = out_dir / \"assets\"\n",
+    "assets_dir.mkdir(exist_ok=True)\n",
+    "\n",
+    "# copy all the assets to the assets directory (json files, vocab files, etc.)\n",
+    "\n",
+    "import shutil\n",
+    "\n",
+    "# copy all json files\n",
+    "\n",
+    "for file in out_dir.glob(\"*.json\"):\n",
+    "    shutil.copy(file, assets_dir)\n",
+    "\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 4.3G\n",
+      "drwxrwxr-x 2 prabod prabod 4.0K Feb 13 01:09 assets\n",
+      "-rw-rw-r-- 1 prabod prabod 3.7K Feb 13 01:03 config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 188M Feb 13 01:03 embed_token.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 2.9K Feb 13 01:03 embed_token.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 555M Feb 13 01:04 image_embed.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 982K Feb 13 01:04 image_embed.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  43M Feb 13 01:04 img_projection.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 6.9K Feb 13 01:04 img_projection.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 2.6G Feb 13 01:06 language_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 2.3M Feb 13 01:06 language_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  525 Feb 13 01:03 preprocessor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 785M Feb 13 01:08 reshape_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 1.1M Feb 13 01:08 reshape_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  670 Feb 13 01:03 special_tokens_map.json\n",
+      "-rw-rw-r-- 1 prabod prabod 9.3K Feb 13 01:03 tokenizer_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.8M Feb 13 01:03 tokenizer.json\n",
+      "-rw-rw-r-- 1 prabod prabod 188M Feb 13 01:03 wte_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 2.9K Feb 13 01:03 wte_model.xml\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh {out_dir}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 1.8M\n",
+      "-rw-rw-r-- 1 prabod prabod 3.7K Feb 13 01:09 config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  525 Feb 13 01:09 preprocessor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  670 Feb 13 01:09 special_tokens_map.json\n",
+      "-rw-rw-r-- 1 prabod prabod 9.3K Feb 13 01:09 tokenizer_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.8M Feb 13 01:09 tokenizer.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh {assets_dir}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.3 Test the openvino model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openvino as ov\n",
+    "import torch\n",
+    "\n",
+    "core = ov.Core()\n",
+    "device = \"CPU\"\n",
+    "model_dir = out_dir"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "language_model = core.read_model(model_dir / \"language_model.xml\")\n",
+    "compiled_language_model = core.compile_model(language_model, \"AUTO\")\n",
+    "\n",
+    "image_embed = core.compile_model(model_dir / \"image_embed.xml\", device)\n",
+    "img_projection = core.compile_model(model_dir / \"img_projection.xml\", device)\n",
+    "embed_tokem = core.compile_model(model_dir / \"wte_model.xml\", device)\n",
+    "reshape_model = core.compile_model(model_dir / \"reshape_model.xml\", device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Question:\n",
+      " What is unusual on this picture?\n",
+      "Answer:\n",
+      "The unusual aspect of this picture is that there are two cats lying on a pink couch, and they are both holding remotes in their paws. This is an uncommon sight, as it is not typical for cats to interact\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize the generation loop\n",
+    "generated_tokens = []\n",
+    "\n",
+    "from transformers import AutoProcessor, TextStreamer\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"user\", \"content\": \"<|image_1|>\\nWhat is unusual on this picture?\"},\n",
+    "]\n",
+    "\n",
+    "processor = AutoProcessor.from_pretrained(model_dir, trust_remote_code=True)\n",
+    "\n",
+    "prompt = processor.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "\n",
+    "inputs_new = processor(prompt, [image], return_tensors=\"pt\")\n",
+    "\n",
+    "generation_args = {\"max_new_tokens\": 50, \"do_sample\": False, \"streamer\": TextStreamer(processor.tokenizer, skip_prompt=True, skip_special_tokens=True)}\n",
+    "\n",
+    "\n",
+    "request = compiled_language_model.create_infer_request()\n",
+    "input_names = {key.get_any_name(): idx for idx, key in enumerate(language_model.inputs)}\n",
+    "inputs = {}\n",
+    "# Set the initial input_ids\n",
+    "current_input_ids = input_ids\n",
+    "attention_mask = inputs_new[\"attention_mask\"]\n",
+    "position_ids = attention_mask.long().cumsum(-1) - 1\n",
+    "position_ids.masked_fill_(attention_mask == 0, 1)\n",
+    "# Loop for generating tokens\n",
+    "for i in range(generation_args[\"max_new_tokens\"]):\n",
+    "    # Generate input embeds each time\n",
+    "    if current_input_ids.shape[-1] > 1:\n",
+    "        input_embeds = torch.from_numpy(reshape_model({\n",
+    "            \"pixel_values\": pixel_values,\n",
+    "            \"image_sizes\": image_sizes,\n",
+    "            \"input_ids\": current_input_ids\n",
+    "        })[0])\n",
+    "    else:\n",
+    "        input_embeds = torch.from_numpy(embed_tokem(current_input_ids)[0])\n",
+    "    \n",
+    "    if i>0:\n",
+    "        inputs = {}\n",
+    "    # Prepare inputs for the model\n",
+    "    inputs[\"inputs_embeds\"] = input_embeds\n",
+    "    inputs[\"attention_mask\"] = attention_mask\n",
+    "    inputs[\"position_ids\"] = position_ids\n",
+    "    if \"beam_idx\" in input_names:\n",
+    "        inputs[\"beam_idx\"] = np.arange(input_embeds.shape[0], dtype=int)\n",
+    "    \n",
+    "    # Start inference\n",
+    "    request.start_async(inputs, share_inputs=True)\n",
+    "    request.wait()\n",
+    "    \n",
+    "    # Get the logits and find the next token\n",
+    "    logits = torch.from_numpy(request.get_tensor(\"logits\").data)\n",
+    "    next_token = logits.argmax(-1)[0][-1]\n",
+    "    \n",
+    "    # Append the generated token\n",
+    "    generated_tokens.append(next_token)\n",
+    "    \n",
+    "    # Update input_ids with the new token\n",
+    "    current_input_ids = torch.cat([next_token.unsqueeze(0).unsqueeze(0)], dim=-1)\n",
+    "    \n",
+    "    # update the attention mask\n",
+    "    attention_mask = torch.cat([attention_mask, torch.ones_like(attention_mask[:, :1])], dim=-1)\n",
+    "\n",
+    "    # Update inputs for the next iteration\n",
+    "    position_ids = attention_mask.long().cumsum(-1) - 1\n",
+    "    position_ids.masked_fill_(attention_mask == 0, 1)\n",
+    "    position_ids = position_ids[:, -current_input_ids.shape[1] :]\n",
+    "    inputs[\"position_ids\"] = position_ids\n",
+    "\n",
+    "# Convert generated tokens to text\n",
+    "generated_text = processor.tokenizer.decode(generated_tokens, skip_special_tokens=True, eos_token_id=processor.tokenizer.eos_token_id)\n",
+    "image\n",
+    "print(\"Question:\\n What is unusual on this picture?\")\n",
+    "print(\"Answer:\")\n",
+    "print(generated_text)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Import and Save Phi3Vision in Spark NLP\n",
+    "\n",
+    "- Let's install and setup Spark NLP in Google Colab\n",
+    "- This part is pretty easy via our simple script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's start Spark with Spark NLP included via our simple `start()` function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "24/10/30 04:35:00 WARN Utils: Your hostname, minotaur resolves to a loopback address: 127.0.1.1; using 192.168.1.4 instead (on interface eno1)\n",
+      "24/10/30 04:35:00 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n",
+      "24/10/30 04:35:01 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting default log level to \"WARN\".\n",
+      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sparknlp\n",
+    "\n",
+    "# let's start Spark with Spark NLP\n",
+    "spark = sparknlp.start()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "imageClassifier = Phi3Vision.loadSavedModel(out_dir, spark) \\\n",
+    "            .setInputCols(\"image_assembler\") \\\n",
+    "            .setOutputCol(\"answer\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    }
+   ],
+   "source": [
+    "imageClassifier.write().overwrite().save(\"/tmp/phi3vision_spark_nlp\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "25/02/13 03:00:12 WARN NativeLibrary: Failed to load library null: java.lang.UnsatisfiedLinkError: Can't load library: /tmp/openvino-native2045993875761212240/libtbb.so.2\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: An illegal reflective access operation has occurred\n",
+      "WARNING: Illegal reflective access by org.apache.spark.util.SizeEstimator$ (file:/home/prabod/spark/jars/spark-core_2.12-3.3.2.jar) to field java.util.regex.Pattern.pattern\n",
+      "WARNING: Please consider reporting this to the maintainers of org.apache.spark.util.SizeEstimator$\n",
+      "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n",
+      "WARNING: All illegal access operations will be denied in a future release\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sparknlp\n",
+    "from sparknlp.base import *\n",
+    "from sparknlp.annotator import *\n",
+    "from pyspark.sql.functions import lit\n",
+    "from pyspark.ml import Pipeline\n",
+    "from pathlib import Path\n",
+    "import os\n",
+    "\n",
+    "# download two images to test into ./images folder\n",
+    "\n",
+    "url1 = \"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\"\n",
+    "url2 = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n",
+    "\n",
+    "Path(\"images\").mkdir(exist_ok=True)\n",
+    "\n",
+    "!wget -q -O images/image1.jpg {url1}\n",
+    "!wget -q -O images/image2.jpg {url2}\n",
+    "\n",
+    "\n",
+    "\n",
+    "images_path = \"file://\" + os.getcwd() + \"/images/\"\n",
+    "image_df = spark.read.format(\"image\").load(\n",
+    "    path=images_path\n",
+    ")\n",
+    "\n",
+    "test_df = image_df.withColumn(\"text\", lit(\"<|user|> \\n <|image_1|> \\n What's this picture about? <|end|>\\n <|assistant|>\\n\"))\n",
+    "\n",
+    "image_assembler = ImageAssembler().setInputCol(\"image\").setOutputCol(\"image_assembler\")\n",
+    "\n",
+    "imageClassifier = Phi3Vision.load(\"file:///tmp/phi3vision_spark_nlp\")\\\n",
+    "            .setMaxOutputLength(50) \\\n",
+    "            .setInputCols(\"image_assembler\") \\\n",
+    "            .setOutputCol(\"answer\")\n",
+    "\n",
+    "pipeline = Pipeline(\n",
+    "            stages=[\n",
+    "                image_assembler,\n",
+    "                imageClassifier,\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "model = pipeline.fit(test_df)\n",
+    "\n",
+    "results.select(\"generation.result\").show(truncate=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "image_path: /home/prabod/Projects/spark-nlp/examples/python/transformers/openvino/images/image1.jpg\n",
+      "[Annotation(document, 0, 200, The image shows a cat lying inside a cardboard box. The cat appears to be relaxed and comfortable, with its paws up in the air and its head resting on the side of the box. The box is placed on a carpet, Map(), [])]\n"
+     ]
+    }
+   ],
+   "source": [
+    "light_pipeline = LightPipeline(model)\n",
+    "image_path = os.getcwd() + \"/images/\" + \"image1.jpg\"\n",
+    "print(\"image_path: \" + image_path)\n",
+    "annotations_result = light_pipeline.fullAnnotateImage(\n",
+    "    image_path,\n",
+    "    \"<|user|> \\n <|image_1|> \\n What's this picture about? <|end|>\\n <|assistant|>\\n\"\n",
+    ")\n",
+    "\n",
+    "for result in annotations_result:\n",
+    "    print(result[\"answer\"])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "phi3v2",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.21"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Qwen2VL.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Qwen2VL.ipynb
new file mode 100644
index 00000000000000..38e005dbd7d78e
--- /dev/null
+++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Qwen2VL.ipynb
@@ -0,0 +1,959 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_Qwen2VL.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Import OpenVINO Qwen2VL models from HuggingFace 🤗 into Spark NLP 🚀\n",
+    "\n",
+    "This notebook provides a detailed walkthrough on optimizing and importing Qwen2VL models from HuggingFace  for use in Spark NLP, with [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html). The focus is on converting the model to the OpenVINO format and applying precision optimizations (INT8 and INT4), to enhance the performance and efficiency on CPU platforms using [Optimum Intel](https://huggingface.co/docs/optimum/main/en/intel/inference).\n",
+    "\n",
+    "Let's keep in mind a few things before we start 😊\n",
+    "\n",
+    "- OpenVINO support was introduced in  `Spark NLP 5.4.0`, enabling high performance CPU inference for models. So please make sure you have upgraded to the latest Spark NLP release.\n",
+    "- Model quantization is a computationally expensive process, so it is recommended to use a runtime with more than 32GB memory for exporting the quantized model from HuggingFace.\n",
+    "- You can import Qwen2VL models via `Qwen2VL`. These models are usually under `Text Generation` category and have `Qwen2VL` in their labels.\n",
+    "- Reference: [Qwen2VL](https://huggingface.co/docs/transformers/model_doc/llama#transformers.Qwen2VL)\n",
+    "- Some [example models](https://huggingface.co/models?search=Qwen2VL)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Export and Save the HuggingFace model\n",
+    "\n",
+    "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n",
+    "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future release, but we wanted you to know which versions have been tested successfully."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "%pip install -qU \"openvino>=2024.4.0\" \"nncf>=2.13.0\"\n",
+    "%pip install -q  \"sentencepiece\" \"tokenizers>=0.12.1\" \"transformers>=4.45.0\" \"gradio>=4.36\" \"accelerate>=0.26.0\"\n",
+    "%pip install -q -U --pre --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly openvino-tokenizers openvino openvino-genai\n",
+    "%pip install -q --upgrade huggingface_hub\n",
+    "%pip install -q --upgrade torch>=2.2.1 torchvision>=0.10.2\n",
+    "%pip install -q --upgrade qwen-vl-utils\n",
+    "%pip install -q --upgrade ipywidgets\n",
+    "\n",
+    "utility_files = [\"notebook_utils.py\", \"cmd_helper.py\"]\n",
+    "\n",
+    "from pathlib import Path\n",
+    "import requests\n",
+    "\n",
+    "if not Path(\"ov_qwen2_vl.py\").exists():\n",
+    "    r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/notebooks/qwen2-vl/ov_qwen2_vl.py\")\n",
+    "    open(\"ov_qwen2_vl.py\", \"w\").write(r.text)\n",
+    "\n",
+    "if not Path(\"notebook_utils.py\").exists():\n",
+    "    r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/notebook_utils.py\")\n",
+    "    open(\"notebook_utils.py\", \"w\").write(r.text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1 Convert the model to OpenVino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b6dd00586e2b4cc1bf3fd2e7cd80f072",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Dropdown(description='Model:', options=('Qwen/Qwen2-VL-2B-Instruct', 'Qwen/Qwen2-VL-7B-Instruct'), value='Qwen…"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from ov_qwen2_vl import model_selector\n",
+    "from pathlib import Path\n",
+    "import requests\n",
+    "\n",
+    "model_id = model_selector()\n",
+    "\n",
+    "model_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Selected Qwen/Qwen2-VL-2B-Instruct\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Selected {model_id.value}\")\n",
+    "pt_model_id = model_id.value\n",
+    "model_dir = Path(pt_model_id.split(\"/\")[-1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PosixPath('Qwen2-VL-2B-Instruct')"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_dir"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "⌛ Qwen/Qwen2-VL-2B-Instruct conversion started. Be patient, it may takes some time.\n",
+      "⌛ Load Original model\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5c1440417023424ebcdac61adf7a04bb",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading shards:   0%|          | 0/2 [00:00 target_length:\n",
+      "/home/prabod/anaconda3/envs/qwen2vl/lib/python3.9/site-packages/transformers/cache_utils.py:444: TracerWarning: Using len to get tensor shape might cause the trace to be incorrect. Recommended usage would be tensor.shape[0]. Passing a tensor of different shape might lead to errors or silently give incorrect results.\n",
+      "  len(self.key_cache[layer_idx]) == 0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Language model successfully converted\n",
+      "⌛ Weights compression with int4_asym mode started\n",
+      "INFO:nncf:Statistics of the bitwidth distribution:\n",
+      "┍━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑\n",
+      "│ Weight compression mode   │ % all parameters (layers)   │ % ratio-defining parameters (layers)   │\n",
+      "┝━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┥\n",
+      "│ int8_asym                 │ 15% (1 / 197)               │ 0% (0 / 196)                           │\n",
+      "├───────────────────────────┼─────────────────────────────┼────────────────────────────────────────┤\n",
+      "│ int4_asym                 │ 85% (196 / 197)             │ 100% (196 / 196)                       │\n",
+      "┕━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┙\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7bf356fb03094dea88c213baa5f17ce1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Weights compression finished\n",
+      "⌛ Convert Image embedding model\n",
+      "⌛ Weights compression with int4_asym mode started\n",
+      "INFO:nncf:Statistics of the bitwidth distribution:\n",
+      "┍━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑\n",
+      "│ Weight compression mode   │ % all parameters (layers)   │ % ratio-defining parameters (layers)   │\n",
+      "┝━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┥\n",
+      "│ int8_asym                 │ 1% (1 / 130)                │ 0% (0 / 129)                           │\n",
+      "├───────────────────────────┼─────────────────────────────┼────────────────────────────────────────┤\n",
+      "│ int4_asym                 │ 99% (129 / 130)             │ 100% (129 / 129)                       │\n",
+      "┕━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┙\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "eed1fe0109374336afee2590bd8ee7be",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Weights compression finished\n",
+      "✅ Image embedding model successfully converted\n",
+      "✅ Qwen/Qwen2-VL-2B-Instruct model conversion finished. You can find results in Qwen2-VL-2B-Instruct\n"
+     ]
+    }
+   ],
+   "source": [
+    "from ov_qwen2_vl import convert_qwen2vl_model\n",
+    "import nncf\n",
+    "\n",
+    "compression_configuration = {\n",
+    "    \"mode\": nncf.CompressWeightsMode.INT4_ASYM,\n",
+    "    \"group_size\": 128,\n",
+    "    \"ratio\": 1.0,\n",
+    "}\n",
+    "\n",
+    "convert_qwen2vl_model(pt_model_id, model_dir, compression_configuration)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "\n",
+    "class Qwen2ReshapePatches(nn.Module):\n",
+    "    def __init__(self,\n",
+    "                 temporal_patch_size: int = 2,\n",
+    "                 merge_size: int = 2,\n",
+    "                 patch_size: int = 14\n",
+    "                 ):\n",
+    "        super().__init__()\n",
+    "        self.temporal_patch_size = temporal_patch_size\n",
+    "        self.merge_size = merge_size\n",
+    "        self.patch_size = patch_size\n",
+    "\n",
+    "    def forward(self, patches, repetition_factor=1):\n",
+    "        # Repeat the patches along the first dimension\n",
+    "        patches = patches.repeat(repetition_factor, 1, 1, 1)\n",
+    "        channel = patches.shape[1]\n",
+    "        grid_t = patches.shape[0] // self.temporal_patch_size\n",
+    "        resized_height = patches.shape[2]\n",
+    "        resized_width = patches.shape[3]\n",
+    "        grid_h, grid_w = resized_height // self.patch_size, resized_width // self.patch_size\n",
+    "        patches = patches.reshape(\n",
+    "            grid_t,\n",
+    "            self.temporal_patch_size,\n",
+    "            channel,\n",
+    "            grid_h // self.merge_size,\n",
+    "            self.merge_size,\n",
+    "            self.patch_size,\n",
+    "            grid_w // self.merge_size,\n",
+    "            self.merge_size,\n",
+    "            self.patch_size,\n",
+    "        )\n",
+    "        patches = patches.permute(0, 3, 6, 4, 7, 2, 1, 5, 8)\n",
+    "        flatten_patches = patches.reshape(\n",
+    "            grid_t * grid_h * grid_w, channel * self.temporal_patch_size * self.patch_size * self.patch_size\n",
+    "        )\n",
+    "\n",
+    "        return flatten_patches\n",
+    "\n",
+    "\n",
+    "patch_reshape_model = Qwen2ReshapePatches()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openvino as ov\n",
+    "\n",
+    "\n",
+    "ov_model = ov.convert_model(\n",
+    "            patch_reshape_model,\n",
+    "            example_input={\n",
+    "                \"patches\": torch.ones((1, 3, 1372, 2044), dtype=torch.float32),\n",
+    "                \"repetition_factor\": torch.tensor(2),\n",
+    "            }\n",
+    "        )\n",
+    "\n",
+    "# Save the OpenVINO model\n",
+    "ov.save_model(ov_model, model_dir/\"openvino_patch_reshape_model.xml\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers.models.qwen2_vl.modeling_qwen2_vl import VisionRotaryEmbedding\n",
+    "from transformers import Qwen2VLForConditionalGeneration, AutoProcessor, AutoConfig\n",
+    "\n",
+    "config = AutoConfig.from_pretrained(\"Qwen/Qwen2-VL-2B-Instruct\")\n",
+    "\n",
+    "\n",
+    "class RotaryEmbedding(nn.Module):\n",
+    "\n",
+    "    def __init__(self, embed_dim, spatial_merge_size):\n",
+    "        super().__init__()\n",
+    "        self._rotary_pos_emb = VisionRotaryEmbedding(embed_dim)\n",
+    "        self.spatial_merge_size = spatial_merge_size\n",
+    "    \n",
+    "    def forward(self, grid_thw):\n",
+    "        t, h, w = grid_thw\n",
+    "        pos_ids = []\n",
+    "        # for t, h, w in grid_thw:\n",
+    "\n",
+    "        hpos_ids = torch.arange(h).unsqueeze(1).expand(-1, w)\n",
+    "        hpos_ids = hpos_ids.reshape(\n",
+    "            h // self.spatial_merge_size,\n",
+    "            self.spatial_merge_size,\n",
+    "            w // self.spatial_merge_size,\n",
+    "            self.spatial_merge_size,\n",
+    "        )\n",
+    "        hpos_ids = hpos_ids.permute(0, 2, 1, 3)\n",
+    "        hpos_ids = hpos_ids.flatten()\n",
+    "\n",
+    "        wpos_ids = torch.arange(w).unsqueeze(0).expand(h, -1)\n",
+    "        wpos_ids = wpos_ids.reshape(\n",
+    "            h // self.spatial_merge_size,\n",
+    "            self.spatial_merge_size,\n",
+    "            w // self.spatial_merge_size,\n",
+    "            self.spatial_merge_size,\n",
+    "        )\n",
+    "        wpos_ids = wpos_ids.permute(0, 2, 1, 3)\n",
+    "        wpos_ids = wpos_ids.flatten()\n",
+    "        pos_ids.append(torch.stack([hpos_ids, wpos_ids], dim=-1).repeat(t, 1))\n",
+    "        pos_ids = torch.cat(pos_ids, dim=0)\n",
+    "        max_grid_size = grid_thw.max()\n",
+    "        rotary_pos_emb_full = self._rotary_pos_emb(max_grid_size)\n",
+    "        rotary_pos_emb = rotary_pos_emb_full[pos_ids].flatten(1)\n",
+    "        return rotary_pos_emb\n",
+    "\n",
+    "\n",
+    "\n",
+    "vision_rotary_embedding = RotaryEmbedding(config.vision_config.embed_dim // config.vision_config.num_heads // 2, config.vision_config.spatial_merge_size)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_33347/1989675311.py:15: TracerWarning: Iterating over a tensor might cause the trace to be incorrect. Passing a tensor of different shape won't change the number of iterations executed (and might lead to errors or silently give incorrect results).\n",
+      "  t, h, w = grid_thw\n"
+     ]
+    }
+   ],
+   "source": [
+    "import openvino as ov\n",
+    "\n",
+    "vision_embedding_ov = ov.convert_model(\n",
+    "    vision_rotary_embedding,\n",
+    "    example_input={\n",
+    "        \"grid_thw\": torch.tensor([1, 98, 146]),\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "# Save the OpenVINO model\n",
+    "ov.save_model(vision_embedding_ov, model_dir/\"openvino_rotary_embeddings_model.xml\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MergeMultiModalInputs(torch.nn.Module):\n",
+    "    def __init__(self,image_token_index=151655):\n",
+    "        super().__init__()\n",
+    "        self.image_token_index = image_token_index\n",
+    "\n",
+    "    def forward(\n",
+    "        self,\n",
+    "        vision_embeds,\n",
+    "        inputs_embeds,\n",
+    "        input_ids,\n",
+    "    ):\n",
+    "        image_features = vision_embeds\n",
+    "        inputs_embeds = inputs_embeds\n",
+    "        special_image_mask = (input_ids == self.image_token_index).unsqueeze(-1).expand_as(inputs_embeds)\n",
+    "        # image_features = image_features.to(inputs_embeds.dtype)\n",
+    "        final_embedding = inputs_embeds.masked_scatter(special_image_mask, image_features)\n",
+    "\n",
+    "        return {\n",
+    "            \"inputs_embeds\": final_embedding\n",
+    "        }\n",
+    "\n",
+    "torch_model_merge = MergeMultiModalInputs()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openvino as ov\n",
+    "\n",
+    "# convert MergeMultiModalInputs to OpenVINO IR\n",
+    "ov_model_merge = ov.convert_model(\n",
+    "    torch_model_merge,\n",
+    "    example_input={\n",
+    "        \"vision_embeds\": torch.randn((3577, 1536), dtype=torch.float32),\n",
+    "        \"inputs_embeds\": torch.randn((1, 3602, 1536), dtype=torch.float32),\n",
+    "        \"input_ids\": torch.randint(0, 151656, (1, 3602), dtype=torch.long),\n",
+    "    }\n",
+    ")\n",
+    "ov.save_model(ov_model_merge, model_dir/\"openvino_multimodal_merge_model.xml\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2 Load openvino models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "LANGUAGE_MODEL_NAME = \"openvino_language_model.xml\"\n",
+    "IMAGE_EMBEDDING_NAME = \"openvino_vision_embeddings_model.xml\"\n",
+    "IMAGE_EMBEDDING_MERGER_NAME = \"openvino_vision_embeddings_merger_model.xml\"\n",
+    "TEXT_EMBEDDING_NAME = \"openvino_text_embeddings_model.xml\"\n",
+    "ROTARY_EMBEDDING_NAME = \"openvino_rotary_embeddings_model.xml\"\n",
+    "PATCH_RESHAPE_NAME = \"openvino_patch_reshape_model.xml\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openvino as ov\n",
+    "import gc\n",
+    "\n",
+    "core = ov.Core()\n",
+    "model_path = model_dir\n",
+    "\n",
+    "language_model = core.read_model(model_path / LANGUAGE_MODEL_NAME)\n",
+    "compiled_language_model = core.compile_model(language_model, \"CPU\")\n",
+    "request = compiled_language_model.create_infer_request()\n",
+    "\n",
+    "image_embedding = core.compile_model(model_path / IMAGE_EMBEDDING_NAME, \"CPU\")\n",
+    "image_embedding_merger = core.compile_model(model_path / IMAGE_EMBEDDING_MERGER_NAME, \"CPU\")\n",
+    "text_embedding = core.compile_model(model_path / TEXT_EMBEDDING_NAME, \"CPU\")\n",
+    "rotary_embedding = core.compile_model(model_path / ROTARY_EMBEDDING_NAME, \"CPU\")\n",
+    "patch_reshape = core.compile_model(model_path / PATCH_RESHAPE_NAME, \"CPU\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "⌛ Check if all models are converted\n",
+      "✅ All models are converted. You can find results in Qwen2-VL-2B-Instruct\n"
+     ]
+    }
+   ],
+   "source": [
+    "# check if all the models are converted\n",
+    "\n",
+    "print(\"⌛ Check if all models are converted\")\n",
+    "language_model_path = model_dir / LANGUAGE_MODEL_NAME\n",
+    "image_embed_path = model_dir / IMAGE_EMBEDDING_NAME\n",
+    "image_merger_path = model_dir / IMAGE_EMBEDDING_MERGER_NAME\n",
+    "text_embed_path = model_dir / TEXT_EMBEDDING_NAME\n",
+    "rotary_embed_path = model_dir / ROTARY_EMBEDDING_NAME\n",
+    "patch_reshape_path = model_dir / PATCH_RESHAPE_NAME\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "if all(\n",
+    "    [\n",
+    "        language_model_path.exists(),\n",
+    "        image_embed_path.exists(),\n",
+    "        image_merger_path.exists(),\n",
+    "        text_embed_path.exists(),\n",
+    "        rotary_embed_path.exists(),\n",
+    "        patch_reshape_path.exists(),\n",
+    "    ]\n",
+    "):\n",
+    "    print(f\"✅ All models are converted. You can find results in {model_dir}\")\n",
+    "else:\n",
+    "    print(\"❌ Not all models are converted. Please check the conversion process\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2 Copy assets to the assets folder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assets_dir = model_dir / \"assets\"\n",
+    "assets_dir.mkdir(exist_ok=True)\n",
+    "\n",
+    "# copy all the assets to the assets directory (json files, vocab files, etc.)\n",
+    "\n",
+    "import shutil\n",
+    "\n",
+    "# copy all json files\n",
+    "\n",
+    "for file in model_dir.glob(\"*.json\"):\n",
+    "    shutil.copy(file, assets_dir)\n",
+    "\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 1.7G\n",
+      "-rw-rw-r-- 1 prabod prabod  392 Feb 13 22:58 added_tokens.json\n",
+      "drwxrwxr-x 2 prabod prabod 4.0K Feb 13 23:03 assets\n",
+      "-rw-rw-r-- 1 prabod prabod 1.1K Feb 13 22:58 chat_template.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.2K Feb 13 22:58 config.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.6M Feb 13 22:58 merges.txt\n",
+      "-rw-rw-r-- 1 prabod prabod 873M Feb 13 23:00 openvino_language_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 3.4M Feb 13 23:00 openvino_language_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod   40 Feb 13 23:01 openvino_multimodal_merge_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 9.8K Feb 13 23:01 openvino_multimodal_merge_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  132 Feb 13 23:00 openvino_patch_reshape_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod  24K Feb 13 23:00 openvino_patch_reshape_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  132 Feb 13 23:00 openvino_rotary_embeddings_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod  30K Feb 13 23:00 openvino_rotary_embeddings_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 446M Feb 13 22:58 openvino_text_embeddings_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 2.9K Feb 13 22:58 openvino_text_embeddings_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 334M Feb 13 23:00 openvino_vision_embeddings_merger_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 2.1M Feb 13 23:00 openvino_vision_embeddings_merger_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod 2.9M Feb 13 23:00 openvino_vision_embeddings_model.bin\n",
+      "-rw-rw-r-- 1 prabod prabod 4.4K Feb 13 23:00 openvino_vision_embeddings_model.xml\n",
+      "-rw-rw-r-- 1 prabod prabod  567 Feb 13 22:58 preprocessor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  613 Feb 13 22:58 special_tokens_map.json\n",
+      "-rw-rw-r-- 1 prabod prabod 4.3K Feb 13 22:58 tokenizer_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  11M Feb 13 22:58 tokenizer.json\n",
+      "-rw-rw-r-- 1 prabod prabod 2.7M Feb 13 22:58 vocab.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh {model_dir}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 14M\n",
+      "-rw-rw-r-- 1 prabod prabod  392 Feb 13 23:03 added_tokens.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.1K Feb 13 23:03 chat_template.json\n",
+      "-rw-rw-r-- 1 prabod prabod 1.2K Feb 13 23:03 config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  567 Feb 13 23:03 preprocessor_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  613 Feb 13 23:03 special_tokens_map.json\n",
+      "-rw-rw-r-- 1 prabod prabod 4.3K Feb 13 23:03 tokenizer_config.json\n",
+      "-rw-rw-r-- 1 prabod prabod  11M Feb 13 23:03 tokenizer.json\n",
+      "-rw-rw-r-- 1 prabod prabod 2.7M Feb 13 23:03 vocab.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh {assets_dir}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Import and Save Qwen2VL in Spark NLP\n",
+    "\n",
+    "- Let's install and setup Spark NLP in Google Colab\n",
+    "- This part is pretty easy via our simple script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's start Spark with Spark NLP included via our simple `start()` function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "24/11/07 09:56:55 WARN Utils: Your hostname, minotaur resolves to a loopback address: 127.0.1.1; using 192.168.1.4 instead (on interface eno1)\n",
+      "24/11/07 09:56:55 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n",
+      "24/11/07 09:56:55 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting default log level to \"WARN\".\n",
+      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sparknlp\n",
+    "\n",
+    "# let's start Spark with Spark NLP\n",
+    "spark = sparknlp.start()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "25/02/14 00:53:12 WARN NativeLibrary: Failed to load library null: java.lang.UnsatisfiedLinkError: Can't load library: /tmp/openvino-native16473116188009294604/libtbb.so.2\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING: An illegal reflective access operation has occurred\n",
+      "WARNING: Illegal reflective access by org.apache.spark.util.SizeEstimator$ (file:/home/prabod/spark/jars/spark-core_2.12-3.3.2.jar) to field java.util.regex.Pattern.pattern\n",
+      "WARNING: Please consider reporting this to the maintainers of org.apache.spark.util.SizeEstimator$\n",
+      "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n",
+      "WARNING: All illegal access operations will be denied in a future release\n"
+     ]
+    }
+   ],
+   "source": [
+    "imageClassifier = Qwen2VLTransformer.loadSavedModel(str(model_path),spark) \\\n",
+    "            .setInputCols(\"image_assembler\") \\\n",
+    "            .setOutputCol(\"answer\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    }
+   ],
+   "source": [
+    "imageClassifier.write().overwrite().save(\"Qwen2VL_spark_nlp\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 1.7G\n",
+      "drwxr-xr-x  4 prabod prabod 4.0K Feb 14 00:53 .\n",
+      "drwxr-xr-x 12 prabod root   4.0K Feb 14 00:53 ..\n",
+      "drwxr-xr-x  6 prabod prabod 4.0K Feb 14 00:53 fields\n",
+      "drwxr-xr-x  2 prabod prabod 4.0K Feb 14 00:53 metadata\n",
+      "-rw-r--r--  1 prabod prabod 876M Feb 14 00:53 openvino_language_model.xml\n",
+      "-rw-r--r--  1 prabod prabod 6.9M Feb 14 00:53 .openvino_language_model.xml.crc\n",
+      "-rw-r--r--  1 prabod prabod  11K Feb 14 00:53 openvino_multimodal_merge_model.xml\n",
+      "-rw-r--r--  1 prabod prabod   92 Feb 14 00:53 .openvino_multimodal_merge_model.xml.crc\n",
+      "-rw-r--r--  1 prabod prabod  24K Feb 14 00:53 openvino_patch_reshape_model.xml\n",
+      "-rw-r--r--  1 prabod prabod  200 Feb 14 00:53 .openvino_patch_reshape_model.xml.crc\n",
+      "-rw-r--r--  1 prabod prabod  30K Feb 14 00:53 openvino_rotary_embeddings_model.xml\n",
+      "-rw-r--r--  1 prabod prabod  248 Feb 14 00:53 .openvino_rotary_embeddings_model.xml.crc\n",
+      "-rw-r--r--  1 prabod prabod 446M Feb 14 00:53 openvino_text_embeddings_model.xml\n",
+      "-rw-r--r--  1 prabod prabod 3.5M Feb 14 00:53 .openvino_text_embeddings_model.xml.crc\n",
+      "-rw-r--r--  1 prabod prabod 336M Feb 14 00:53 openvino_vision_embeddings_merger_model.xml\n",
+      "-rw-r--r--  1 prabod prabod 2.7M Feb 14 00:53 .openvino_vision_embeddings_merger_model.xml.crc\n",
+      "-rw-r--r--  1 prabod prabod 2.9M Feb 14 00:53 openvino_vision_embeddings_model.xml\n",
+      "-rw-r--r--  1 prabod prabod  24K Feb 14 00:53 .openvino_vision_embeddings_model.xml.crc\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lah Qwen2VL_spark_nlp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sparknlp\n",
+    "from sparknlp.base import *\n",
+    "from sparknlp.annotator import *\n",
+    "from pyspark.sql.functions import lit\n",
+    "from pyspark.ml import Pipeline\n",
+    "from pathlib import Path\n",
+    "import os\n",
+    "\n",
+    "# download two images to test into ./images folder\n",
+    "\n",
+    "url1 = \"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/d5fbbd1a-d484-415c-88cb-9986625b7b11\"\n",
+    "url2 = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n",
+    "\n",
+    "Path(\"images\").mkdir(exist_ok=True)\n",
+    "\n",
+    "!wget -q -O images/image1.jpg {url1}\n",
+    "!wget -q -O images/image2.jpg {url2}\n",
+    "\n",
+    "\n",
+    "\n",
+    "images_path = \"file://\" + os.getcwd() + \"/images/\"\n",
+    "image_df = spark.read.format(\"image\").load(\n",
+    "    path=images_path\n",
+    ")\n",
+    "\n",
+    "test_df = image_df.withColumn(\"text\", lit(\"<|im_start|>system\\nYou are a helpful assistant.<|im_end|>\\n<|im_start|>user\\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\\n<|im_start|>assistant\\n\"))\n",
+    "\n",
+    "image_assembler = ImageAssembler().setInputCol(\"image\").setOutputCol(\"image_assembler\")\n",
+    "\n",
+    "imageClassifier = Qwen2VLTransformer.load(\"Qwen2VL_spark_nlp\")\\\n",
+    "            .setMaxOutputLength(50) \\\n",
+    "            .setInputCols(\"image_assembler\") \\\n",
+    "            .setOutputCol(\"answer\")\n",
+    "\n",
+    "pipeline = Pipeline(\n",
+    "            stages=[\n",
+    "                image_assembler,\n",
+    "                imageClassifier,\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "model = pipeline.fit(test_df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "image_path: /home/prabod/Projects/spark-nlp/examples/python/transformers/openvino/images/image1.jpg\n",
+      "[Annotation(document, 0, 245, The image shows a cat lying inside a cardboard box. The cat appears to be relaxed and comfortable, with its eyes closed, suggesting it is resting or sleeping. The box is placed on a light-colored carpet, and the background includes a portion of a, Map(), [])]\n"
+     ]
+    }
+   ],
+   "source": [
+    "light_pipeline = LightPipeline(model)\n",
+    "image_path = os.getcwd() + \"/images/\" + \"image1.jpg\"\n",
+    "print(\"image_path: \" + image_path)\n",
+    "annotations_result = light_pipeline.fullAnnotateImage(\n",
+    "    image_path,\n",
+    "    \"<|im_start|>system\\nYou are a helpful assistant.<|im_end|>\\n<|im_start|>user\\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\\n<|im_start|>assistant\\n\"\n",
+    ")\n",
+    "\n",
+    "for result in annotations_result:\n",
+    "    print(result[\"answer\"])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pth23",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_RoBERTaForMultipleChoice.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_RoBERTaForMultipleChoice.ipynb
new file mode 100644
index 00000000000000..88f94cd03e5629
--- /dev/null
+++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_RoBERTaForMultipleChoice.ipynb
@@ -0,0 +1,3231 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_V5XcDCnVgSi"
+   },
+   "source": [
+    "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_RoBERTaForMultipleChoice.ipynb)\n",
+    "\n",
+    "# Import OpenVINO RoBertaForMultipleChoice models from HuggingFace 🤗 into Spark NLP 🚀\n",
+    "\n",
+    "This notebook provides a detailed walkthrough on optimizing and exporting RoBertaForMultipleChoice  models from HuggingFace for use in Spark NLP, leveraging the various tools provided in the [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html) ecosystem.\n",
+    "\n",
+    "Let's keep in mind a few things before we start 😊\n",
+    "\n",
+    "- OpenVINO support was introduced in  `Spark NLP 5.4.0`, enabling high performance inference for models. Please make sure you have upgraded to the latest Spark NLP release.\n",
+    "- You can import models for RoBertaForMultipleChoice from RoBertaForMultipleChoice  and they have to be in `Multiple Choice` category."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "aghasVppVgSk"
+   },
+   "source": [
+    "## 1. Export and Save the HuggingFace model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "be4HsTDMVgSk"
+   },
+   "source": [
+    "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n",
+    "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future releases, but we wanted you to know which versions have been tested successfully."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vI7uz_6hVgSl"
+   },
+   "source": [
+    "[Optimum Intel](https://github.com/huggingface/optimum-intel?tab=readme-ov-file#openvino) is the interface between the Transformers library and the various model optimization and acceleration tools provided by Intel. HuggingFace models loaded with optimum-intel are automatically optimized for OpenVINO, while being compatible with the Transformers API.\n",
+    "- Normally, to load a HuggingFace model directly for inference/export, just replace the `AutoModelForXxx` class with the corresponding `OVModelForXxx` class. However, ForMultipleChoice is not yet available so we will use `openvino.convert_model()` after exporting ONNX model\n",
+    "- We'll use [SyedArsal/roberta-urdu-small-finetuned-news](https://huggingface.co/SyedArsal/roberta-urdu-small-finetuned-news) model from HuggingFace as an example\n",
+    "- We also need the `vocab.txt` saved from `AutoTokenizer`. This is the same for every model, these are assets (saved in `/assets`) needed for tokenization inside Spark NLP."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "TDapJ_09nqXQ",
+    "outputId": "ebd3710c-cc11-4a15-e68b-a00abe2c2b5e"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: pip in /usr/local/lib/python3.10/dist-packages (24.1.2)\n",
+      "Collecting pip\n",
+      "  Downloading pip-24.3.1-py3-none-any.whl.metadata (3.7 kB)\n",
+      "Downloading pip-24.3.1-py3-none-any.whl (1.8 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m58.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hInstalling collected packages: pip\n",
+      "  Attempting uninstall: pip\n",
+      "    Found existing installation: pip 24.1.2\n",
+      "    Uninstalling pip-24.1.2:\n",
+      "      Successfully uninstalled pip-24.1.2\n",
+      "Successfully installed pip-24.3.1\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m38.7/38.7 MB\u001b[0m \u001b[31m134.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m170.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m62.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m182.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\n",
+      "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.2 which is incompatible.\n",
+      "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\n",
+      "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\u001b[0m\u001b[31m\n",
+      "\u001b[0m"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install --upgrade pip\n",
+    "!pip install -q --upgrade transformers[onnx] optimum openvino==2024.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 345,
+     "referenced_widgets": [
+      "e8de475f418a466b96ad9dc8092ec472",
+      "a03515b35f204995bf9d6defc615f470",
+      "54956d4234d94187bdb65e4579d2835c",
+      "57e03f6690a1432ba954fee43cc1fcd6",
+      "d880034ea2dd49dd82302278d8010880",
+      "687333d4a91642d181fb77bbc9a78804",
+      "9cb8c3de61104d4c9881eaad96e18026",
+      "8267faf0d96144bc942268a47ac8110c",
+      "6fa07016fc924c88b6a11ada1c29120a",
+      "f94465b9d7d54045a915001d31b70521",
+      "0fb89a9abe2c4e8da648888e3fc7e2c9",
+      "b3eae74cf64b4d3ab0e078fa5030b250",
+      "522072c6408b4d6fae0fbb2f2a6b7148",
+      "08f471f23ae646f180039978795e8a33",
+      "63f117a26eea4a7fa1ab3045e44f8cce",
+      "53aaf71f49bc49cfa9e095ef69e2e698",
+      "dcd36b74d4e944b884469f3ae05a1965",
+      "9bc404edcf0f4c56adb5dfbd35efeddb",
+      "70fd078fcbce4adca6d0b64be8bb776d",
+      "8ce761e53ee4462d9fcad5417b59cb0e",
+      "875c8f1d490b48588cfc9b0def454697",
+      "977f303d2bb541b8af9010ff27c6ebe5",
+      "3d93a8c90a764aa4aeeaa3c1fb6e0233",
+      "dd62c16436cc478eac789142f6777372",
+      "55de1efb39294f9381a212377046996c",
+      "fbbfa821015340e0a975594e30f39610",
+      "0709e7324f8140bfaef6c89dca53ad44",
+      "abff1dfbd61e4f47b96d159bc2f991cd",
+      "340409d1364548be87c0642dde478afd",
+      "dd45d5f6018740d8a77c22feb3a9a577",
+      "e9930cf218fe4a359d90acda9c151f95",
+      "c13a533d9f6d4504a10a4be4899c73b0",
+      "1227c0df3a70454ba87433b69da0f7bb",
+      "21a7a154169942a1a1a0d63bc90e8e4e",
+      "ce914dd2436848cab32e25ace7e197df",
+      "19258ca4d31c41a097aba309eb0e611a",
+      "57036535951648b2aea21e0666976fb3",
+      "047394b2e37a4f9dbb484202cefd68b2",
+      "7da322004e0744fa9b680d9db35bc482",
+      "6483fb6eaaee48efb60d84d9c7f9e208",
+      "a2e847b1391d4dfa87601e2a8fccd4d4",
+      "c7f1d71711e84ee3bfa78ba4c441c845",
+      "24fe95a1aeec4cd59b834bac38a2c01b",
+      "d8800789f1444604a0a8973b1f030870",
+      "1d03f704409c4dc088ec82e9c5051735",
+      "fd50ff10d8dd488cacf80b2a33eb6dbd",
+      "5f8534acd76b4d1ba2ffface18e74c16",
+      "d0a1693ed7af4e6c995492c16428475b",
+      "ffdc0841c8b24dd098728aafee63af12",
+      "68b64710efbb4b40aaa0040614c9a165",
+      "1170d2bfb83a4a76845f83a238e60f45",
+      "2a5fd903f52d4486936b7ec5d8c0392f",
+      "57896ba3021b408a83430ef592415e03",
+      "5dd793253ae647578ece380a8dea82eb",
+      "5380bbfd60d849028ec577222997a68e",
+      "ded0269796e04d91a76e501767aa7574",
+      "1ef03d592187402abf68d9a4c73246df",
+      "9c6f5f3bd27f417c9eff2f410d015136",
+      "e9c87a756e944c10bb5279cc676e5447",
+      "fe7ca09bb6604c429d8200fba84a0739",
+      "caa5b14ea26043e8b02d82867d492199",
+      "62f5d8b2dfad403a9364f13bdcc6ed18",
+      "c2e9a901ea354b5cb0b32f4802118a3f",
+      "2f19ed6e6c304f7a82bca722367f4fe5",
+      "4f916f48e3b14fa094fc8c8829d218d3",
+      "87d837fa24984ddb965ed9662a49db26",
+      "f8cefe5fd5ca474080e95ec751fd2d9a",
+      "c78290cc75f04ab996fd9f73d24a2bf1",
+      "af8eb3352b4c425091770aa8616b2d6a",
+      "a69b6cfa6ce34493ba4001bbfa172d7d",
+      "f9927a5ce3364365bd3eee07bb7c70a6",
+      "2e8b0888ec9a4dceb898d4e866350f34",
+      "e7bc78719c7946df8830605dc8e1fb51",
+      "0f7e9d2318794736b1936d3dea7d32fc",
+      "8a8299fa5a0b41c09d67e0f1a92d5ef5",
+      "60477dc2daa74dc38d82153b7913d57b",
+      "51d12fc137764be6bcb9222dabbf9dab"
+     ]
+    },
+    "id": "_b89GvQKosA0",
+    "outputId": "d2db5db6-a676-4cfd-e91e-3f91628463a2"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n",
+      "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+      "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+      "You will be able to reuse this secret in all of your notebooks.\n",
+      "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e8de475f418a466b96ad9dc8092ec472",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/728 [00:00 0, chunk -> 0, score -> 0.60569566}, []}]|\n",
+      "|[{chunk, 0, 6, Germany, {sentence -> 0, chunk -> 0, score -> 0.33706638}, []}]                             |\n",
+      "|[{chunk, 0, 5,  Tiger, {sentence -> 0, chunk -> 0, score -> 0.25371727}, []}]                              |\n",
+      "|[{chunk, 0, 3, 90°C, {sentence -> 0, chunk -> 0, score -> 0.336369}, []}]                                  |\n",
+      "|[{chunk, 0, 6, Jupiter, {sentence -> 0, chunk -> 0, score -> 0.37836587}, []}]                             |\n",
+      "|[{chunk, 0, 7,  English, {sentence -> 0, chunk -> 0, score -> 0.339204}, []}]                              |\n",
+      "|[{chunk, 0, 9, The Greeks, {sentence -> 0, chunk -> 0, score -> 0.2771055}, []}]                           |\n",
+      "|[{chunk, 0, 5,  Ozone, {sentence -> 0, chunk -> 0, score -> 0.58542985}, []}]                              |\n",
+      "|[{chunk, 0, 6,  Africa, {sentence -> 0, chunk -> 0, score -> 0.34312767}, []}]                             |\n",
+      "|[{chunk, 0, 13,  Pablo Picasso, {sentence -> 0, chunk -> 0, score -> 0.34392032}, []}]                     |\n",
+      "+-----------------------------------------------------------------------------------------------------------+\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sparknlp.base import *\n",
+    "from sparknlp.annotator import *\n",
+    "from pyspark.ml import Pipeline, PipelineModel\n",
+    "\n",
+    "document_assembler = MultiDocumentAssembler() \\\n",
+    "            .setInputCols([\"question\", \"choices\"]) \\\n",
+    "            .setOutputCols([\"document_question\", \"document_choices\"])\n",
+    "\n",
+    "roberta_for_multiple_choice = RoBertaForMultipleChoice() \\\n",
+    "  .load(f\"{MODEL_NAME}_spark_nlp_openvino\") \\\n",
+    "  .setInputCols([\"document_question\", \"document_choices\"])\\\n",
+    "  .setOutputCol(\"answer\") \\\n",
+    "  .setBatchSize(4)\n",
+    "\n",
+    "pipeline = Pipeline(stages=[document_assembler, roberta_for_multiple_choice])\n",
+    "pipeline_model = pipeline.fit(testing_df)\n",
+    "\n",
+    "pipeline_df = pipeline_model.transform(testing_df)\n",
+    "\n",
+    "pipeline_df.select(\"answer\").show(truncate=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lpxiq1igoj6c"
+   },
+   "source": [
+    "That's it! You can now go wild and use hundreds of `RoBertaForMultipleChoice` models from HuggingFace 🤗 in Spark NLP 🚀\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "A100",
+   "machine_shape": "hm",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "047394b2e37a4f9dbb484202cefd68b2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0709e7324f8140bfaef6c89dca53ad44": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "08f471f23ae646f180039978795e8a33": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_70fd078fcbce4adca6d0b64be8bb776d",
+      "max": 503987181,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8ce761e53ee4462d9fcad5417b59cb0e",
+      "value": 503987181
+     }
+    },
+    "0f7e9d2318794736b1936d3dea7d32fc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0fb89a9abe2c4e8da648888e3fc7e2c9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1170d2bfb83a4a76845f83a238e60f45": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1227c0df3a70454ba87433b69da0f7bb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "19258ca4d31c41a097aba309eb0e611a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a2e847b1391d4dfa87601e2a8fccd4d4",
+      "max": 1503982,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c7f1d71711e84ee3bfa78ba4c441c845",
+      "value": 1503982
+     }
+    },
+    "1d03f704409c4dc088ec82e9c5051735": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_fd50ff10d8dd488cacf80b2a33eb6dbd",
+       "IPY_MODEL_5f8534acd76b4d1ba2ffface18e74c16",
+       "IPY_MODEL_d0a1693ed7af4e6c995492c16428475b"
+      ],
+      "layout": "IPY_MODEL_ffdc0841c8b24dd098728aafee63af12"
+     }
+    },
+    "1ef03d592187402abf68d9a4c73246df": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_caa5b14ea26043e8b02d82867d492199",
+      "placeholder": "​",
+      "style": "IPY_MODEL_62f5d8b2dfad403a9364f13bdcc6ed18",
+      "value": "tokenizer.json: 100%"
+     }
+    },
+    "21a7a154169942a1a1a0d63bc90e8e4e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_ce914dd2436848cab32e25ace7e197df",
+       "IPY_MODEL_19258ca4d31c41a097aba309eb0e611a",
+       "IPY_MODEL_57036535951648b2aea21e0666976fb3"
+      ],
+      "layout": "IPY_MODEL_047394b2e37a4f9dbb484202cefd68b2"
+     }
+    },
+    "24fe95a1aeec4cd59b834bac38a2c01b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2a5fd903f52d4486936b7ec5d8c0392f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2e8b0888ec9a4dceb898d4e866350f34": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2f19ed6e6c304f7a82bca722367f4fe5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "340409d1364548be87c0642dde478afd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3d93a8c90a764aa4aeeaa3c1fb6e0233": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_dd62c16436cc478eac789142f6777372",
+       "IPY_MODEL_55de1efb39294f9381a212377046996c",
+       "IPY_MODEL_fbbfa821015340e0a975594e30f39610"
+      ],
+      "layout": "IPY_MODEL_0709e7324f8140bfaef6c89dca53ad44"
+     }
+    },
+    "4f916f48e3b14fa094fc8c8829d218d3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "51d12fc137764be6bcb9222dabbf9dab": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "522072c6408b4d6fae0fbb2f2a6b7148": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dcd36b74d4e944b884469f3ae05a1965",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9bc404edcf0f4c56adb5dfbd35efeddb",
+      "value": "pytorch_model.bin: 100%"
+     }
+    },
+    "5380bbfd60d849028ec577222997a68e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "53aaf71f49bc49cfa9e095ef69e2e698": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "54956d4234d94187bdb65e4579d2835c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8267faf0d96144bc942268a47ac8110c",
+      "max": 728,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6fa07016fc924c88b6a11ada1c29120a",
+      "value": 728
+     }
+    },
+    "55de1efb39294f9381a212377046996c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dd45d5f6018740d8a77c22feb3a9a577",
+      "max": 1385,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_e9930cf218fe4a359d90acda9c151f95",
+      "value": 1385
+     }
+    },
+    "57036535951648b2aea21e0666976fb3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_24fe95a1aeec4cd59b834bac38a2c01b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d8800789f1444604a0a8973b1f030870",
+      "value": " 1.50M/1.50M [00:01<00:00, 864kB/s]"
+     }
+    },
+    "57896ba3021b408a83430ef592415e03": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "57e03f6690a1432ba954fee43cc1fcd6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f94465b9d7d54045a915001d31b70521",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0fb89a9abe2c4e8da648888e3fc7e2c9",
+      "value": " 728/728 [00:00<00:00, 60.0kB/s]"
+     }
+    },
+    "5dd793253ae647578ece380a8dea82eb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5f8534acd76b4d1ba2ffface18e74c16": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2a5fd903f52d4486936b7ec5d8c0392f",
+      "max": 1150157,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_57896ba3021b408a83430ef592415e03",
+      "value": 1150157
+     }
+    },
+    "60477dc2daa74dc38d82153b7913d57b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "62f5d8b2dfad403a9364f13bdcc6ed18": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "63f117a26eea4a7fa1ab3045e44f8cce": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_875c8f1d490b48588cfc9b0def454697",
+      "placeholder": "​",
+      "style": "IPY_MODEL_977f303d2bb541b8af9010ff27c6ebe5",
+      "value": " 504M/504M [00:02<00:00, 244MB/s]"
+     }
+    },
+    "6483fb6eaaee48efb60d84d9c7f9e208": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "687333d4a91642d181fb77bbc9a78804": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "68b64710efbb4b40aaa0040614c9a165": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6fa07016fc924c88b6a11ada1c29120a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "70fd078fcbce4adca6d0b64be8bb776d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7da322004e0744fa9b680d9db35bc482": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8267faf0d96144bc942268a47ac8110c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "875c8f1d490b48588cfc9b0def454697": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "87d837fa24984ddb965ed9662a49db26": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8a8299fa5a0b41c09d67e0f1a92d5ef5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8ce761e53ee4462d9fcad5417b59cb0e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "977f303d2bb541b8af9010ff27c6ebe5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9bc404edcf0f4c56adb5dfbd35efeddb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9c6f5f3bd27f417c9eff2f410d015136": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c2e9a901ea354b5cb0b32f4802118a3f",
+      "max": 3537507,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2f19ed6e6c304f7a82bca722367f4fe5",
+      "value": 3537507
+     }
+    },
+    "9cb8c3de61104d4c9881eaad96e18026": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a03515b35f204995bf9d6defc615f470": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_687333d4a91642d181fb77bbc9a78804",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9cb8c3de61104d4c9881eaad96e18026",
+      "value": "config.json: 100%"
+     }
+    },
+    "a2e847b1391d4dfa87601e2a8fccd4d4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a69b6cfa6ce34493ba4001bbfa172d7d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_60477dc2daa74dc38d82153b7913d57b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_51d12fc137764be6bcb9222dabbf9dab",
+      "value": " 957/957 [00:00<00:00, 84.3kB/s]"
+     }
+    },
+    "abff1dfbd61e4f47b96d159bc2f991cd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "af8eb3352b4c425091770aa8616b2d6a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0f7e9d2318794736b1936d3dea7d32fc",
+      "max": 957,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8a8299fa5a0b41c09d67e0f1a92d5ef5",
+      "value": 957
+     }
+    },
+    "b3eae74cf64b4d3ab0e078fa5030b250": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_522072c6408b4d6fae0fbb2f2a6b7148",
+       "IPY_MODEL_08f471f23ae646f180039978795e8a33",
+       "IPY_MODEL_63f117a26eea4a7fa1ab3045e44f8cce"
+      ],
+      "layout": "IPY_MODEL_53aaf71f49bc49cfa9e095ef69e2e698"
+     }
+    },
+    "c13a533d9f6d4504a10a4be4899c73b0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c2e9a901ea354b5cb0b32f4802118a3f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c78290cc75f04ab996fd9f73d24a2bf1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2e8b0888ec9a4dceb898d4e866350f34",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e7bc78719c7946df8830605dc8e1fb51",
+      "value": "special_tokens_map.json: 100%"
+     }
+    },
+    "c7f1d71711e84ee3bfa78ba4c441c845": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "caa5b14ea26043e8b02d82867d492199": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ce914dd2436848cab32e25ace7e197df": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7da322004e0744fa9b680d9db35bc482",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6483fb6eaaee48efb60d84d9c7f9e208",
+      "value": "vocab.json: 100%"
+     }
+    },
+    "d0a1693ed7af4e6c995492c16428475b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5dd793253ae647578ece380a8dea82eb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5380bbfd60d849028ec577222997a68e",
+      "value": " 1.15M/1.15M [00:00<00:00, 1.70MB/s]"
+     }
+    },
+    "d880034ea2dd49dd82302278d8010880": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d8800789f1444604a0a8973b1f030870": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dcd36b74d4e944b884469f3ae05a1965": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dd45d5f6018740d8a77c22feb3a9a577": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dd62c16436cc478eac789142f6777372": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_abff1dfbd61e4f47b96d159bc2f991cd",
+      "placeholder": "​",
+      "style": "IPY_MODEL_340409d1364548be87c0642dde478afd",
+      "value": "tokenizer_config.json: 100%"
+     }
+    },
+    "ded0269796e04d91a76e501767aa7574": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1ef03d592187402abf68d9a4c73246df",
+       "IPY_MODEL_9c6f5f3bd27f417c9eff2f410d015136",
+       "IPY_MODEL_e9c87a756e944c10bb5279cc676e5447"
+      ],
+      "layout": "IPY_MODEL_fe7ca09bb6604c429d8200fba84a0739"
+     }
+    },
+    "e7bc78719c7946df8830605dc8e1fb51": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e8de475f418a466b96ad9dc8092ec472": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a03515b35f204995bf9d6defc615f470",
+       "IPY_MODEL_54956d4234d94187bdb65e4579d2835c",
+       "IPY_MODEL_57e03f6690a1432ba954fee43cc1fcd6"
+      ],
+      "layout": "IPY_MODEL_d880034ea2dd49dd82302278d8010880"
+     }
+    },
+    "e9930cf218fe4a359d90acda9c151f95": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "e9c87a756e944c10bb5279cc676e5447": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4f916f48e3b14fa094fc8c8829d218d3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_87d837fa24984ddb965ed9662a49db26",
+      "value": " 3.54M/3.54M [00:01<00:00, 3.12MB/s]"
+     }
+    },
+    "f8cefe5fd5ca474080e95ec751fd2d9a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c78290cc75f04ab996fd9f73d24a2bf1",
+       "IPY_MODEL_af8eb3352b4c425091770aa8616b2d6a",
+       "IPY_MODEL_a69b6cfa6ce34493ba4001bbfa172d7d"
+      ],
+      "layout": "IPY_MODEL_f9927a5ce3364365bd3eee07bb7c70a6"
+     }
+    },
+    "f94465b9d7d54045a915001d31b70521": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f9927a5ce3364365bd3eee07bb7c70a6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fbbfa821015340e0a975594e30f39610": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c13a533d9f6d4504a10a4be4899c73b0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1227c0df3a70454ba87433b69da0f7bb",
+      "value": " 1.39k/1.39k [00:00<00:00, 96.4kB/s]"
+     }
+    },
+    "fd50ff10d8dd488cacf80b2a33eb6dbd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_68b64710efbb4b40aaa0040614c9a165",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1170d2bfb83a4a76845f83a238e60f45",
+      "value": "merges.txt: 100%"
+     }
+    },
+    "fe7ca09bb6604c429d8200fba84a0739": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ffdc0841c8b24dd098728aafee63af12": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_XLMRoBERTaForMultipleChoice.ipynb b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_XLMRoBERTaForMultipleChoice.ipynb
new file mode 100644
index 00000000000000..a853de122ef287
--- /dev/null
+++ b/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_XLMRoBERTaForMultipleChoice.ipynb
@@ -0,0 +1,2840 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_V5XcDCnVgSi"
+   },
+   "source": [
+    "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/transformers/openvino/HuggingFace_OpenVINO_in_Spark_NLP_XLMRoBERTaForMultipleChoice.ipynb)\n",
+    "\n",
+    "# Import OpenVINO XlmRoBertaForMultipleChoice models from HuggingFace 🤗 into Spark NLP 🚀\n",
+    "\n",
+    "This notebook provides a detailed walkthrough on optimizing and exporting XlmRoBertaForMultipleChoice  models from HuggingFace for use in Spark NLP, leveraging the various tools provided in the [Intel OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html) ecosystem.\n",
+    "\n",
+    "Let's keep in mind a few things before we start 😊\n",
+    "\n",
+    "- OpenVINO support was introduced in  `Spark NLP 5.4.0`, enabling high performance inference for models. Please make sure you have upgraded to the latest Spark NLP release.\n",
+    "- You can import models for XlmRoBertaForMultipleChoice from XlmRoBertaForMultipleChoice  and they have to be in `Multiple Choice` category."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "aghasVppVgSk"
+   },
+   "source": [
+    "## 1. Export and Save the HuggingFace model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "be4HsTDMVgSk"
+   },
+   "source": [
+    "- Let's install `transformers` and `openvino` packages with other dependencies. You don't need `openvino` to be installed for Spark NLP, however, we need it to load and save models from HuggingFace.\n",
+    "- We lock `transformers` on version `4.41.2`. This doesn't mean it won't work with the future releases, but we wanted you to know which versions have been tested successfully."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vI7uz_6hVgSl"
+   },
+   "source": [
+    "[Optimum Intel](https://github.com/huggingface/optimum-intel?tab=readme-ov-file#openvino) is the interface between the Transformers library and the various model optimization and acceleration tools provided by Intel. HuggingFace models loaded with optimum-intel are automatically optimized for OpenVINO, while being compatible with the Transformers API.\n",
+    "- Normally, to load a HuggingFace model directly for inference/export, just replace the `AutoModelForXxx` class with the corresponding `OVModelForXxx` class. However, ForMultipleChoice is not yet available so we will use `openvino.convert_model()` after exporting ONNX model\n",
+    "- We'll use [lenatr99/fine_tuned_copa_XLMroberta](https://huggingface.co/lenatr99/fine_tuned_copa_XLMroberta) model from HuggingFace as an example\n",
+    "- We also need the `sentencepiece.bpe.model`. This is the same for every model, these are assets (saved in `/assets`) needed for tokenization inside Spark NLP."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "TDapJ_09nqXQ",
+    "outputId": "afae95f6-3beb-40aa-947e-37219bcfead4"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: pip in /usr/local/lib/python3.10/dist-packages (24.1.2)\n",
+      "Collecting pip\n",
+      "  Downloading pip-24.3.1-py3-none-any.whl.metadata (3.7 kB)\n",
+      "Downloading pip-24.3.1-py3-none-any.whl (1.8 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m60.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hInstalling collected packages: pip\n",
+      "  Attempting uninstall: pip\n",
+      "    Found existing installation: pip 24.1.2\n",
+      "    Uninstalling pip-24.1.2:\n",
+      "      Successfully uninstalled pip-24.1.2\n",
+      "Successfully installed pip-24.3.1\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m38.7/38.7 MB\u001b[0m \u001b[31m1.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m27.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m9.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m51.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\n",
+      "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.2 which is incompatible.\n",
+      "tensorflow 2.17.1 requires protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\n",
+      "tensorflow-metadata 1.13.1 requires protobuf<5,>=3.20.3, but you have protobuf 3.20.2 which is incompatible.\u001b[0m\u001b[31m\n",
+      "\u001b[0m"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install --upgrade pip\n",
+    "!pip install -q --upgrade transformers[onnx] optimum openvino==2024.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 313,
+     "referenced_widgets": [
+      "97195a37295742dcb1b15eefa7b44560",
+      "8e8d24929a274d9fbc9a7d22004d8213",
+      "d7310ef446fd4897800463fed902154c",
+      "4a377a786202461f8fe4ec0111724e34",
+      "e004ccdca9b1475787c8fc487702eeb5",
+      "2827ebeb3bd741aeaa051701b56e4deb",
+      "85f519a2de764e63854f7909b624f045",
+      "37ed9cd7ded147e799f6189674e2bf04",
+      "701fe16af2334f24b0118a14337c1aec",
+      "4b5326e1ba734dc390614efe2a9b8749",
+      "aeba7e7c8bcc4cbeb8aec2247405ed5b",
+      "30590aca6f214f3c93d12a7e9f59de87",
+      "c7f0c5b70e9c4b9892176803037ab78a",
+      "f61b12c8e7ae4496a177e6a23c67a8ce",
+      "c9f3daa829be4893ad565003eb75a951",
+      "bd9b2d2e0ef94961a909a7b9d87de7a1",
+      "76da4d5463c44066aaeacc5df4de11c1",
+      "bd6fcd2a072c41188703e049129cae05",
+      "ff7fb85730024477bdfbc1b0ff6bddba",
+      "4f901bcfbfb9472c840c2c0baf165999",
+      "3859cdb6c83e4a2ca51c94dd0e3f1daa",
+      "f176f44c803e4dbcafba8d2825d109e9",
+      "a437067aefae4533b34348e62d50f90c",
+      "c2bc4ed51b934e3facd8afa4c4426303",
+      "d36b9c913da8412f80b9af477eef7268",
+      "24d1dc375a624d14bc78444c3355bbaf",
+      "ee91ca47564d4c7f9bbc409496e37e24",
+      "2d5e76d1457a4fd0bea5e1527463fdc7",
+      "3b19fd18c04b41e4ae05b56d79bef587",
+      "e1788e4cb5af484c9c8f0ffa7fee35b9",
+      "cf82075e7b3842d9bde89017100b586e",
+      "daa78c3807ff4114853b874edead049d",
+      "59c6f2d3ff3743d98411e31736f0bdd6",
+      "70f36d5b6be14f99a91c05d2f67ab611",
+      "f8bf9a06d65246ed80ff4b2292fff85c",
+      "0b0e3911eb0c48bc82e7608591c5b89b",
+      "b7d97ae23d314f84a5f992a9d408c49b",
+      "6796196831b24a0689c3ad9f63976050",
+      "e988036ff3d4430889e0ac17ee63a8d7",
+      "df671ae0aa504726b37f05aa847a32f3",
+      "88e486e6064941c08790a3b98dad510f",
+      "a74ba613bffb489ebd05e7e120cf74d8",
+      "4b65083dcf7a415d8e349434f46e8c3a",
+      "66eeed186cc74b119c823b70dbf65f3c",
+      "3286831c191f41679a4a37fa80f95ca0",
+      "0630bbae098d4d808ea95646b758efa4",
+      "73000faa2fe84ae2924199ff1739d6bc",
+      "de00fcd2ab0d41f6bd1c26b35a890216",
+      "789617a387b544279cc45291830026e0",
+      "dca3f945a8554ea1bcc0619dd8532c00",
+      "a2b9c64ccafe41558a15ceaaf6521f91",
+      "9d08ee3285754d5abf452c9bbbf8efd3",
+      "4f014d7ebc60458983c135ab7de464cd",
+      "425f6f30d4f240d0a6bd13286672a8b0",
+      "1c945394dcfc4bb9a784a8422737bf2d",
+      "d1fcb19afb064a5eab483c52b5fe8f58",
+      "002ec56f607c4121ae6afeaf5eed3886",
+      "5e34c29fceee4d60a93c1d0bbe4df33a",
+      "e02949629ba9482a97521cae4f997145",
+      "7f4dd96c7c7848eeaa1e7a7a0f87cb4a",
+      "6f4a062bf41d422cbf0bedd5dd05a038",
+      "4709b2e45b4d457d84baca06c5344794",
+      "2acecd6cbb6248e481db26ad181de982",
+      "8fb190b88e984e94be552bbec6da85ad",
+      "a3e4299d9f29480184e5e8fe394ed2e6",
+      "1072ff4c7c3b46e684b786d7da8b9cf2"
+     ]
+    },
+    "id": "_b89GvQKosA0",
+    "outputId": "95837a5d-4d3b-4516-d208-d209eba3657f"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n",
+      "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+      "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+      "You will be able to reuse this secret in all of your notebooks.\n",
+      "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "97195a37295742dcb1b15eefa7b44560",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/714 [00:00 0, chunk -> 0, score -> 0.5}, []}]|\n",
+      "|[{chunk, 0, 6, Germany, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}]                      |\n",
+      "|[{chunk, 0, 3, Lion, {sentence -> 0, chunk -> 0, score -> 0.25}, []}]                               |\n",
+      "|[{chunk, 0, 3, 90°C, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}]                         |\n",
+      "|[{chunk, 0, 6, Jupiter, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}]                      |\n",
+      "|[{chunk, 0, 6, Spanish, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}]                      |\n",
+      "|[{chunk, 0, 9, The Greeks, {sentence -> 0, chunk -> 0, score -> 0.25}, []}]                         |\n",
+      "|[{chunk, 0, 6, Oxygenm, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}]                      |\n",
+      "|[{chunk, 0, 3, Asia, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}]                         |\n",
+      "|[{chunk, 0, 15, Vincent van Gogh, {sentence -> 0, chunk -> 0, score -> 0.33333334}, []}]            |\n",
+      "+----------------------------------------------------------------------------------------------------+\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sparknlp.base import *\n",
+    "from sparknlp.annotator import *\n",
+    "from pyspark.ml import Pipeline, PipelineModel\n",
+    "\n",
+    "document_assembler = MultiDocumentAssembler() \\\n",
+    "            .setInputCols([\"question\", \"choices\"]) \\\n",
+    "            .setOutputCols([\"document_question\", \"document_choices\"])\n",
+    "\n",
+    "xlm_roberta_for_multiple_choice = XlmRoBertaForMultipleChoice() \\\n",
+    "  .load(f\"{MODEL_NAME}_spark_nlp_openvino\") \\\n",
+    "  .setInputCols([\"document_question\", \"document_choices\"])\\\n",
+    "  .setOutputCol(\"answer\") \\\n",
+    "  .setBatchSize(4)\n",
+    "\n",
+    "pipeline = Pipeline(stages=[document_assembler, xlm_roberta_for_multiple_choice])\n",
+    "pipeline_model = pipeline.fit(testing_df)\n",
+    "\n",
+    "pipeline_df = pipeline_model.transform(testing_df)\n",
+    "\n",
+    "pipeline_df.select(\"answer\").show(truncate=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lpxiq1igoj6c"
+   },
+   "source": [
+    "That's it! You can now go wild and use hundreds of `XlmRoBertaForMultipleChoice` models from HuggingFace 🤗 in Spark NLP 🚀\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "L4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "002ec56f607c4121ae6afeaf5eed3886": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6f4a062bf41d422cbf0bedd5dd05a038",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4709b2e45b4d457d84baca06c5344794",
+      "value": "special_tokens_map.json: 100%"
+     }
+    },
+    "0630bbae098d4d808ea95646b758efa4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dca3f945a8554ea1bcc0619dd8532c00",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a2b9c64ccafe41558a15ceaaf6521f91",
+      "value": "tokenizer.json: 100%"
+     }
+    },
+    "0b0e3911eb0c48bc82e7608591c5b89b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_88e486e6064941c08790a3b98dad510f",
+      "max": 5069051,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_a74ba613bffb489ebd05e7e120cf74d8",
+      "value": 5069051
+     }
+    },
+    "1072ff4c7c3b46e684b786d7da8b9cf2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1c945394dcfc4bb9a784a8422737bf2d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "24d1dc375a624d14bc78444c3355bbaf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_daa78c3807ff4114853b874edead049d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_59c6f2d3ff3743d98411e31736f0bdd6",
+      "value": " 1.15k/1.15k [00:00<00:00, 97.7kB/s]"
+     }
+    },
+    "2827ebeb3bd741aeaa051701b56e4deb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2acecd6cbb6248e481db26ad181de982": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2d5e76d1457a4fd0bea5e1527463fdc7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "30590aca6f214f3c93d12a7e9f59de87": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c7f0c5b70e9c4b9892176803037ab78a",
+       "IPY_MODEL_f61b12c8e7ae4496a177e6a23c67a8ce",
+       "IPY_MODEL_c9f3daa829be4893ad565003eb75a951"
+      ],
+      "layout": "IPY_MODEL_bd9b2d2e0ef94961a909a7b9d87de7a1"
+     }
+    },
+    "3286831c191f41679a4a37fa80f95ca0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0630bbae098d4d808ea95646b758efa4",
+       "IPY_MODEL_73000faa2fe84ae2924199ff1739d6bc",
+       "IPY_MODEL_de00fcd2ab0d41f6bd1c26b35a890216"
+      ],
+      "layout": "IPY_MODEL_789617a387b544279cc45291830026e0"
+     }
+    },
+    "37ed9cd7ded147e799f6189674e2bf04": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3859cdb6c83e4a2ca51c94dd0e3f1daa": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3b19fd18c04b41e4ae05b56d79bef587": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "425f6f30d4f240d0a6bd13286672a8b0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4709b2e45b4d457d84baca06c5344794": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4a377a786202461f8fe4ec0111724e34": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4b5326e1ba734dc390614efe2a9b8749",
+      "placeholder": "​",
+      "style": "IPY_MODEL_aeba7e7c8bcc4cbeb8aec2247405ed5b",
+      "value": " 714/714 [00:00<00:00, 56.6kB/s]"
+     }
+    },
+    "4b5326e1ba734dc390614efe2a9b8749": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4b65083dcf7a415d8e349434f46e8c3a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4f014d7ebc60458983c135ab7de464cd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "4f901bcfbfb9472c840c2c0baf165999": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "59c6f2d3ff3743d98411e31736f0bdd6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5e34c29fceee4d60a93c1d0bbe4df33a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2acecd6cbb6248e481db26ad181de982",
+      "max": 280,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8fb190b88e984e94be552bbec6da85ad",
+      "value": 280
+     }
+    },
+    "66eeed186cc74b119c823b70dbf65f3c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6796196831b24a0689c3ad9f63976050": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6f4a062bf41d422cbf0bedd5dd05a038": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "701fe16af2334f24b0118a14337c1aec": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "70f36d5b6be14f99a91c05d2f67ab611": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f8bf9a06d65246ed80ff4b2292fff85c",
+       "IPY_MODEL_0b0e3911eb0c48bc82e7608591c5b89b",
+       "IPY_MODEL_b7d97ae23d314f84a5f992a9d408c49b"
+      ],
+      "layout": "IPY_MODEL_6796196831b24a0689c3ad9f63976050"
+     }
+    },
+    "73000faa2fe84ae2924199ff1739d6bc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9d08ee3285754d5abf452c9bbbf8efd3",
+      "max": 17082832,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_4f014d7ebc60458983c135ab7de464cd",
+      "value": 17082832
+     }
+    },
+    "76da4d5463c44066aaeacc5df4de11c1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "789617a387b544279cc45291830026e0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7f4dd96c7c7848eeaa1e7a7a0f87cb4a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "85f519a2de764e63854f7909b624f045": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "88e486e6064941c08790a3b98dad510f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8e8d24929a274d9fbc9a7d22004d8213": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2827ebeb3bd741aeaa051701b56e4deb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_85f519a2de764e63854f7909b624f045",
+      "value": "config.json: 100%"
+     }
+    },
+    "8fb190b88e984e94be552bbec6da85ad": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "97195a37295742dcb1b15eefa7b44560": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8e8d24929a274d9fbc9a7d22004d8213",
+       "IPY_MODEL_d7310ef446fd4897800463fed902154c",
+       "IPY_MODEL_4a377a786202461f8fe4ec0111724e34"
+      ],
+      "layout": "IPY_MODEL_e004ccdca9b1475787c8fc487702eeb5"
+     }
+    },
+    "9d08ee3285754d5abf452c9bbbf8efd3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a2b9c64ccafe41558a15ceaaf6521f91": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a3e4299d9f29480184e5e8fe394ed2e6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a437067aefae4533b34348e62d50f90c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c2bc4ed51b934e3facd8afa4c4426303",
+       "IPY_MODEL_d36b9c913da8412f80b9af477eef7268",
+       "IPY_MODEL_24d1dc375a624d14bc78444c3355bbaf"
+      ],
+      "layout": "IPY_MODEL_ee91ca47564d4c7f9bbc409496e37e24"
+     }
+    },
+    "a74ba613bffb489ebd05e7e120cf74d8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "aeba7e7c8bcc4cbeb8aec2247405ed5b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b7d97ae23d314f84a5f992a9d408c49b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4b65083dcf7a415d8e349434f46e8c3a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_66eeed186cc74b119c823b70dbf65f3c",
+      "value": " 5.07M/5.07M [00:00<00:00, 27.7MB/s]"
+     }
+    },
+    "bd6fcd2a072c41188703e049129cae05": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bd9b2d2e0ef94961a909a7b9d87de7a1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c2bc4ed51b934e3facd8afa4c4426303": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2d5e76d1457a4fd0bea5e1527463fdc7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3b19fd18c04b41e4ae05b56d79bef587",
+      "value": "tokenizer_config.json: 100%"
+     }
+    },
+    "c7f0c5b70e9c4b9892176803037ab78a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_76da4d5463c44066aaeacc5df4de11c1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bd6fcd2a072c41188703e049129cae05",
+      "value": "model.safetensors: 100%"
+     }
+    },
+    "c9f3daa829be4893ad565003eb75a951": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3859cdb6c83e4a2ca51c94dd0e3f1daa",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f176f44c803e4dbcafba8d2825d109e9",
+      "value": " 1.11G/1.11G [00:26<00:00, 42.7MB/s]"
+     }
+    },
+    "cf82075e7b3842d9bde89017100b586e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d1fcb19afb064a5eab483c52b5fe8f58": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_002ec56f607c4121ae6afeaf5eed3886",
+       "IPY_MODEL_5e34c29fceee4d60a93c1d0bbe4df33a",
+       "IPY_MODEL_e02949629ba9482a97521cae4f997145"
+      ],
+      "layout": "IPY_MODEL_7f4dd96c7c7848eeaa1e7a7a0f87cb4a"
+     }
+    },
+    "d36b9c913da8412f80b9af477eef7268": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e1788e4cb5af484c9c8f0ffa7fee35b9",
+      "max": 1147,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_cf82075e7b3842d9bde89017100b586e",
+      "value": 1147
+     }
+    },
+    "d7310ef446fd4897800463fed902154c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_37ed9cd7ded147e799f6189674e2bf04",
+      "max": 714,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_701fe16af2334f24b0118a14337c1aec",
+      "value": 714
+     }
+    },
+    "daa78c3807ff4114853b874edead049d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dca3f945a8554ea1bcc0619dd8532c00": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "de00fcd2ab0d41f6bd1c26b35a890216": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_425f6f30d4f240d0a6bd13286672a8b0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1c945394dcfc4bb9a784a8422737bf2d",
+      "value": " 17.1M/17.1M [00:01<00:00, 14.2MB/s]"
+     }
+    },
+    "df671ae0aa504726b37f05aa847a32f3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e004ccdca9b1475787c8fc487702eeb5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e02949629ba9482a97521cae4f997145": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a3e4299d9f29480184e5e8fe394ed2e6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1072ff4c7c3b46e684b786d7da8b9cf2",
+      "value": " 280/280 [00:00<00:00, 25.2kB/s]"
+     }
+    },
+    "e1788e4cb5af484c9c8f0ffa7fee35b9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e988036ff3d4430889e0ac17ee63a8d7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ee91ca47564d4c7f9bbc409496e37e24": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f176f44c803e4dbcafba8d2825d109e9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f61b12c8e7ae4496a177e6a23c67a8ce": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ff7fb85730024477bdfbc1b0ff6bddba",
+      "max": 1112201908,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_4f901bcfbfb9472c840c2c0baf165999",
+      "value": 1112201908
+     }
+    },
+    "f8bf9a06d65246ed80ff4b2292fff85c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e988036ff3d4430889e0ac17ee63a8d7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_df671ae0aa504726b37f05aa847a32f3",
+      "value": "sentencepiece.bpe.model: 100%"
+     }
+    },
+    "ff7fb85730024477bdfbc1b0ff6bddba": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index fae6267df57f21..88ec9e2e25ec21 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -128,13 +128,14 @@ object Dependencies {
   val azureIdentity = "com.azure" % "azure-identity" % azureIdentityVersion % Provided
   val azureStorage = "com.azure" % "azure-storage-blob" % azureStorageVersion % Provided
 
-  val llamaCppVersion = "0.1.4"
+  val llamaCppVersion = "0.1.6"
   val llamaCppCPU = "com.johnsnowlabs.nlp" %% "jsl-llamacpp-cpu" % llamaCppVersion
   val llamaCppGPU = "com.johnsnowlabs.nlp" %% "jsl-llamacpp-gpu" % llamaCppVersion
   val llamaCppSilicon = "com.johnsnowlabs.nlp" %% "jsl-llamacpp-silicon" % llamaCppVersion
   val llamaCppAarch64 = "com.johnsnowlabs.nlp" %% "jsl-llamacpp-aarch64" % llamaCppVersion
 
   val jsoupVersion = "1.18.2"
+
   val jsoup = "org.jsoup" % "jsoup" % jsoupVersion
 
   val jakartaMailVersion = "2.1.3"
@@ -146,5 +147,7 @@ object Dependencies {
   val poiDocx = "org.apache.poi" % "poi-ooxml" % poiVersion
   val scratchpad = "org.apache.poi" % "poi-scratchpad" % poiVersion
 
+  val pdfBoxVersion = "2.0.28"
+  val pdfBox = "org.apache.pdfbox" % "pdfbox" % pdfBoxVersion
   /** ------- Dependencies end  ------- */
 }
diff --git a/python/sparknlp/annotator/classifier_dl/__init__.py b/python/sparknlp/annotator/classifier_dl/__init__.py
index 2b5e30fc3ff359..70c234419ef651 100644
--- a/python/sparknlp/annotator/classifier_dl/__init__.py
+++ b/python/sparknlp/annotator/classifier_dl/__init__.py
@@ -55,3 +55,7 @@
 from sparknlp.annotator.classifier_dl.albert_for_zero_shot_classification import *
 from sparknlp.annotator.classifier_dl.camembert_for_zero_shot_classification import *
 from sparknlp.annotator.classifier_dl.bert_for_multiple_choice import *
+from sparknlp.annotator.classifier_dl.xlm_roberta_for_multiple_choice import *
+from sparknlp.annotator.classifier_dl.roberta_for_multiple_choice import *
+from sparknlp.annotator.classifier_dl.distilbert_for_multiple_choice import *
+from sparknlp.annotator.classifier_dl.albert_for_multiple_choice import *
diff --git a/python/sparknlp/annotator/classifier_dl/albert_for_multiple_choice.py b/python/sparknlp/annotator/classifier_dl/albert_for_multiple_choice.py
new file mode 100644
index 00000000000000..7dc610b256f687
--- /dev/null
+++ b/python/sparknlp/annotator/classifier_dl/albert_for_multiple_choice.py
@@ -0,0 +1,161 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+class AlbertForMultipleChoice(AnnotatorModel,
+                              HasCaseSensitiveProperties,
+                              HasBatchedAnnotate,
+                              HasEngine,
+                              HasMaxSentenceLengthLimit):
+    """AlbertForMultipleChoice can load ALBERT Models with a multiple choice classification head on top
+    (a linear layer on top of the pooled output and a softmax) e.g. for RocStories/SWAG tasks.
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion
+    object:
+
+    >>> spanClassifier = AlbertForMultipleChoice.pretrained() \\
+    ...     .setInputCols(["document_question", "document_context"]) \\
+    ...     .setOutputCol("answer")
+
+    The default model is ``"albert_base_uncased_multiple_choice"``, if no name is
+    provided.
+
+    For available pretrained models please see the `Models Hub
+    `__.
+
+    To see which models are compatible and how to import them see
+    `Import Transformers into Spark NLP 🚀
+    `_.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``DOCUMENT, DOCUMENT``    ``CHUNK``
+    ====================== ======================
+
+    Parameters
+    ----------
+    batchSize
+        Batch size. Large values allows faster processing but requires more
+        memory, by default 8
+    caseSensitive
+        Whether to ignore case in tokens for embeddings matching, by default
+        False
+    maxSentenceLength
+        Max sentence length to process, by default 512
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> documentAssembler = MultiDocumentAssembler() \\
+    ...     .setInputCols(["question", "context"]) \\
+    ...     .setOutputCols(["document_question", "document_context"])
+    >>> questionAnswering = AlbertForMultipleChoice.pretrained() \\
+    ...     .setInputCols(["document_question", "document_context"]) \\
+    ...     .setOutputCol("answer") \\
+    ...     .setCaseSensitive(False)
+    >>> pipeline = Pipeline().setStages([
+    ...     documentAssembler,
+    ...     questionAnswering
+    ... ])
+    >>> data = spark.createDataFrame([["The Eiffel Tower is located in which country??", "Germany, France, Italy"]]).toDF("question", "context")
+    >>> result = pipeline.fit(data).transform(data)
+    >>> result.select("answer.result").show(truncate=False)
+    +--------------------+
+    |result              |
+    +--------------------+
+    |[France]             |
+    +--------------------+
+    """
+    name = "AlbertForMultipleChoice"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT, AnnotatorType.DOCUMENT]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    choicesDelimiter = Param(Params._dummy(),
+                             "choicesDelimiter",
+                             "Delimiter character use to split the choices",
+                             TypeConverters.toString)
+
+    def setChoicesDelimiter(self, value):
+        """Sets delimiter character use to split the choices
+
+        Parameters
+        ----------
+        value : string
+            Delimiter character use to split the choices
+        """
+        return self._set(caseSensitive=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.classifier.dl.AlbertForMultipleChoice",
+                 java_model=None):
+        super(AlbertForMultipleChoice, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=4,
+            maxSentenceLength=512,
+            caseSensitive=False,
+            choicesDelimiter = ","
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        BertForQuestionAnswering
+            The restored model
+        """
+        from sparknlp.internal import _AlbertMultipleChoiceLoader
+        jModel = _AlbertMultipleChoiceLoader(folder, spark_session._jsparkSession)._java_obj
+        return AlbertForMultipleChoice(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="albert_base_uncased_multiple_choice", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "bert_base_uncased_multiple_choice"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        BertForQuestionAnswering
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(AlbertForMultipleChoice, name, lang, remote_loc)
\ No newline at end of file
diff --git a/python/sparknlp/annotator/classifier_dl/bert_for_multiple_choice.py b/python/sparknlp/annotator/classifier_dl/bert_for_multiple_choice.py
index 2c27f913e56fcc..045e8d64180b53 100644
--- a/python/sparknlp/annotator/classifier_dl/bert_for_multiple_choice.py
+++ b/python/sparknlp/annotator/classifier_dl/bert_for_multiple_choice.py
@@ -130,7 +130,7 @@ def loadSavedModel(folder, spark_session):
 
         Returns
         -------
-        BertForQuestionAnswering
+        BertForMultipleChoice
             The restored model
         """
         from sparknlp.internal import _BertMultipleChoiceLoader
@@ -154,7 +154,7 @@ def pretrained(name="bert_base_uncased_multiple_choice", lang="en", remote_loc=N
 
         Returns
         -------
-        BertForQuestionAnswering
+        BertForMultipleChoice
             The restored model
         """
         from sparknlp.pretrained import ResourceDownloader
diff --git a/python/sparknlp/annotator/classifier_dl/distilbert_for_multiple_choice.py b/python/sparknlp/annotator/classifier_dl/distilbert_for_multiple_choice.py
new file mode 100644
index 00000000000000..f76aa3859c307e
--- /dev/null
+++ b/python/sparknlp/annotator/classifier_dl/distilbert_for_multiple_choice.py
@@ -0,0 +1,161 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+class DistilBertForMultipleChoice(AnnotatorModel,
+                                HasCaseSensitiveProperties,
+                                HasBatchedAnnotate,
+                                HasEngine,
+                                HasMaxSentenceLengthLimit):
+    """DistilBertForMultipleChoice can load DistilBert Models with a multiple choice classification head on top
+    (a linear layer on top of the pooled output and a softmax) e.g. for RocStories/SWAG tasks.
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion
+    object:
+
+    >>> spanClassifier = DistilBertForMultipleChoice.pretrained() \\
+    ...     .setInputCols(["document_question", "document_context"]) \\
+    ...     .setOutputCol("answer")
+
+    The default model is ``"bert_base_uncased_multiple_choice"``, if no name is
+    provided.
+
+    For available pretrained models please see the `Models Hub
+    `__.
+
+    To see which models are compatible and how to import them see
+    `Import Transformers into Spark NLP 🚀
+    `_.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``DOCUMENT, DOCUMENT``    ``CHUNK``
+    ====================== ======================
+
+    Parameters
+    ----------
+    batchSize
+        Batch size. Large values allows faster processing but requires more
+        memory, by default 8
+    caseSensitive
+        Whether to ignore case in tokens for embeddings matching, by default
+        False
+    maxSentenceLength
+        Max sentence length to process, by default 512
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> documentAssembler = MultiDocumentAssembler() \\
+    ...     .setInputCols(["question", "context"]) \\
+    ...     .setOutputCols(["document_question", "document_context"])
+    >>> questionAnswering = DistilBertForMultipleChoice.pretrained() \\
+    ...     .setInputCols(["document_question", "document_context"]) \\
+    ...     .setOutputCol("answer") \\
+    ...     .setCaseSensitive(False)
+    >>> pipeline = Pipeline().setStages([
+    ...     documentAssembler,
+    ...     questionAnswering
+    ... ])
+    >>> data = spark.createDataFrame([["The Eiffel Tower is located in which country??", "Germany, France, Italy"]]).toDF("question", "context")
+    >>> result = pipeline.fit(data).transform(data)
+    >>> result.select("answer.result").show(truncate=False)
+    +--------------------+
+    |result              |
+    +--------------------+
+    |[France]             |
+    +--------------------+
+    """
+    name = "DistilBertForMultipleChoice"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT, AnnotatorType.DOCUMENT]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    choicesDelimiter = Param(Params._dummy(),
+                             "choicesDelimiter",
+                             "Delimiter character use to split the choices",
+                             TypeConverters.toString)
+
+    def setChoicesDelimiter(self, value):
+        """Sets delimiter character use to split the choices
+
+        Parameters
+        ----------
+        value : string
+            Delimiter character use to split the choices
+        """
+        return self._set(caseSensitive=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.classifier.dl.DistilBertForMultipleChoice",
+                 java_model=None):
+        super(DistilBertForMultipleChoice, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=4,
+            maxSentenceLength=512,
+            caseSensitive=False,
+            choicesDelimiter = ","
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        DistilBertForMultipleChoice
+            The restored model
+        """
+        from sparknlp.internal import _DistilBertMultipleChoiceLoader
+        jModel = _DistilBertMultipleChoiceLoader(folder, spark_session._jsparkSession)._java_obj
+        return DistilBertForMultipleChoice(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="distilbert_base_uncased_multiple_choice", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "bert_base_uncased_multiple_choice"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        DistilBertForMultipleChoice
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(DistilBertForMultipleChoice, name, lang, remote_loc)
\ No newline at end of file
diff --git a/python/sparknlp/annotator/classifier_dl/roberta_for_multiple_choice.py b/python/sparknlp/annotator/classifier_dl/roberta_for_multiple_choice.py
new file mode 100644
index 00000000000000..7ad4df59f08e0d
--- /dev/null
+++ b/python/sparknlp/annotator/classifier_dl/roberta_for_multiple_choice.py
@@ -0,0 +1,161 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+class RoBertaForMultipleChoice(AnnotatorModel,
+                               HasCaseSensitiveProperties,
+                               HasBatchedAnnotate,
+                               HasEngine,
+                               HasMaxSentenceLengthLimit):
+    """RoBertaForMultipleChoice can load RoBERTa Models with a multiple choice classification head on top
+    (a linear layer on top of the pooled output and a softmax) e.g. for RocStories/SWAG tasks.
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion
+    object:
+
+    >>> spanClassifier = RoBertaForMultipleChoice.pretrained() \\
+    ...     .setInputCols(["document_question", "document_context"]) \\
+    ...     .setOutputCol("answer")
+
+    The default model is ``"roberta_base_uncased_multiple_choice"``, if no name is
+    provided.
+
+    For available pretrained models please see the `Models Hub
+    `__.
+
+    To see which models are compatible and how to import them see
+    `Import Transformers into Spark NLP 🚀
+    `_.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``DOCUMENT, DOCUMENT``    ``CHUNK``
+    ====================== ======================
+
+    Parameters
+    ----------
+    batchSize
+        Batch size. Large values allows faster processing but requires more
+        memory, by default 8
+    caseSensitive
+        Whether to ignore case in tokens for embeddings matching, by default
+        False
+    maxSentenceLength
+        Max sentence length to process, by default 512
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> documentAssembler = MultiDocumentAssembler() \\
+    ...     .setInputCols(["question", "context"]) \\
+    ...     .setOutputCols(["document_question", "document_context"])
+    >>> questionAnswering = RoBertaForMultipleChoice.pretrained() \\
+    ...     .setInputCols(["document_question", "document_context"]) \\
+    ...     .setOutputCol("answer") \\
+    ...     .setCaseSensitive(False)
+    >>> pipeline = Pipeline().setStages([
+    ...     documentAssembler,
+    ...     questionAnswering
+    ... ])
+    >>> data = spark.createDataFrame([["The Eiffel Tower is located in which country??", "Germany, France, Italy"]]).toDF("question", "context")
+    >>> result = pipeline.fit(data).transform(data)
+    >>> result.select("answer.result").show(truncate=False)
+    +--------------------+
+    |result              |
+    +--------------------+
+    |[France]             |
+    +--------------------+
+    """
+    name = "RobertaForMultipleChoice"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT, AnnotatorType.DOCUMENT]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    choicesDelimiter = Param(Params._dummy(),
+                             "choicesDelimiter",
+                             "Delimiter character use to split the choices",
+                             TypeConverters.toString)
+
+    def setChoicesDelimiter(self, value):
+        """Sets delimiter character use to split the choices
+
+        Parameters
+        ----------
+        value : string
+            Delimiter character use to split the choices
+        """
+        return self._set(caseSensitive=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.classifier.dl.RobertaForMultipleChoice",
+                 java_model=None):
+        super(RoBertaForMultipleChoice, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=4,
+            maxSentenceLength=512,
+            caseSensitive=False,
+            choicesDelimiter = ","
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        RobertaForQuestionAnswering
+            The restored model
+        """
+        from sparknlp.internal import _RoBertaMultipleChoiceLoader
+        jModel = _RoBertaMultipleChoiceLoader(folder, spark_session._jsparkSession)._java_obj
+        return RoBertaForMultipleChoice(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="Roberta_base_uncased_multiple_choice", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "Roberta_base_uncased_multiple_choice"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        RoBertaForMultipleChoice
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(RoBertaForMultipleChoice, name, lang, remote_loc)
\ No newline at end of file
diff --git a/python/sparknlp/annotator/classifier_dl/xlm_roberta_for_multiple_choice.py b/python/sparknlp/annotator/classifier_dl/xlm_roberta_for_multiple_choice.py
new file mode 100644
index 00000000000000..8da691d35cc091
--- /dev/null
+++ b/python/sparknlp/annotator/classifier_dl/xlm_roberta_for_multiple_choice.py
@@ -0,0 +1,149 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+
+class XlmRoBertaForMultipleChoice(AnnotatorModel,
+                                 HasCaseSensitiveProperties,
+                                 HasBatchedAnnotate,
+                                 HasEngine,
+                                 HasMaxSentenceLengthLimit):
+    """XlmRoBertaForMultipleChoice can load XLM-RoBERTa Models with a span classification head on top for extractive
+    question-answering tasks like SQuAD (a linear layer on top of the hidden-states output to compute span start
+    logits and span end logits).
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion
+    object:
+
+    >>> spanClassifier = XlmRoBertaForMultipleChoice.pretrained() \\
+    ...     .setInputCols(["document_question", "document_context"]) \\
+    ...     .setOutputCol("answer")
+
+    The default model is ``"xlm_roberta_base_qa_squad2"``, if no name is
+    provided.
+
+    For available pretrained models please see the `Models Hub
+    `__.
+
+    To see which models are compatible and how to import them see
+    `Import Transformers into Spark NLP 🚀
+    `_.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``DOCUMENT, DOCUMENT``    ``CHUNK``
+    ====================== ======================
+
+    Parameters
+    ----------
+    batchSize
+        Batch size. Large values allows faster processing but requires more
+        memory, by default 8
+    caseSensitive
+        Whether to ignore case in tokens for embeddings matching, by default
+        False
+    configProtoBytes
+        ConfigProto from tensorflow, serialized into byte array.
+    maxSentenceLength
+        Max sentence length to process, by default 128
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> documentAssembler = MultiDocumentAssembler() \\
+    ...     .setInputCols(["question", "context"]) \\
+    ...     .setOutputCol(["document_question", "document_context"])
+    >>> spanClassifier = XlmRoBertaForMultipleChoice.pretrained() \\
+    ...     .setInputCols(["document_question", "document_context"]) \\
+    ...     .setOutputCol("answer") \\
+    ...     .setCaseSensitive(False)
+    >>> pipeline = Pipeline().setStages([
+    ...     documentAssembler,
+    ...     spanClassifier
+    ... ])
+    >>> data = spark.createDataFrame([["What's my name?", "My name is Clara and I live in Berkeley."]]).toDF("question", "context")
+    >>> result = pipeline.fit(data).transform(data)
+    >>> result.select("answer.result").show(truncate=False)
+    +--------------------+
+    |result              |
+    +--------------------+
+    |[Clara]             |
+    +--------------------+
+    """
+    name = "XlmRoBertaForMultipleChoice"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT, AnnotatorType.DOCUMENT]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.classifier.dl.XlmRoBertaForMultipleChoice",
+                 java_model=None):
+        super(XlmRoBertaForMultipleChoice, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=8,
+            maxSentenceLength=128,
+            caseSensitive=False
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        XlmRoBertaForMultipleChoice
+            The restored model
+        """
+        from sparknlp.internal import _XlmRoBertaMultipleChoiceLoader
+        jModel = _XlmRoBertaMultipleChoiceLoader(folder, spark_session._jsparkSession)._java_obj
+        return XlmRoBertaForMultipleChoice(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="xlm_roberta_base_mc", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "xlm_roberta_base_qa_squad2"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        XlmRoBertaForMultipleChoice
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(XlmRoBertaForMultipleChoice, name, lang, remote_loc)
diff --git a/python/sparknlp/annotator/cleaners/__init__.py b/python/sparknlp/annotator/cleaners/__init__.py
new file mode 100644
index 00000000000000..38ba4d88294012
--- /dev/null
+++ b/python/sparknlp/annotator/cleaners/__init__.py
@@ -0,0 +1,15 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from sparknlp.annotator.cleaners.extractor import *
+from sparknlp.annotator.cleaners.cleaner import *
\ No newline at end of file
diff --git a/python/sparknlp/annotator/cleaners/cleaner.py b/python/sparknlp/annotator/cleaners/cleaner.py
new file mode 100644
index 00000000000000..d52affd4bb7d54
--- /dev/null
+++ b/python/sparknlp/annotator/cleaners/cleaner.py
@@ -0,0 +1,202 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for Cleaner."""
+from sparknlp.annotator import MarianTransformer
+from sparknlp.common import *
+
+class Cleaner(MarianTransformer):
+    name = "Cleaner"
+
+    inputAnnotatorTypes = [AnnotatorType.TOKEN]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    encoding = Param(Params._dummy(),
+                   "encoding",
+                   "The encoding to be used for decoding the byte string (default is utf-8)",
+                   typeConverter=TypeConverters.toString)
+
+    cleanPrefixPattern = Param(Params._dummy(),
+                     "cleanPrefixPattern",
+                     "The pattern for the prefix. Can be a simple string or a regex pattern.",
+                     typeConverter=TypeConverters.toString)
+
+    cleanPostfixPattern = Param(Params._dummy(),
+                               "cleanPostfixPattern",
+                               "The pattern for the postfix. Can be a simple string or a regex pattern.",
+                               typeConverter=TypeConverters.toString)
+
+    cleanerMode = Param(
+        Params._dummy(),
+        "cleanerMode",
+        "possible values: " +
+        "clean, bytes_string_to_string, clean_non_ascii_chars, clean_ordered_bullets, clean_postfix, clean_prefix, remove_punctuation, replace_unicode_quotes",
+        typeConverter=TypeConverters.toString
+    )
+
+    extraWhitespace = Param(Params._dummy(),
+                    "extraWhitespace",
+                    "Whether to remove extra whitespace.",
+                    typeConverter=TypeConverters.toBoolean)
+
+    dashes = Param(Params._dummy(),
+                "dashes",
+                "Whether to handle dashes in text.",
+                typeConverter=TypeConverters.toBoolean)
+
+    bullets = Param(Params._dummy(),
+                   "bullets",
+                   "Whether to handle bullets in text.",
+                   typeConverter=TypeConverters.toBoolean)
+
+    trailingPunctuation = Param(Params._dummy(),
+                    "trailingPunctuation",
+                    "Whether to remove trailing punctuation from text.",
+                    typeConverter=TypeConverters.toBoolean)
+
+    lowercase = Param(Params._dummy(),
+                "lowercase",
+                "Whether to convert text to lowercase.",
+                typeConverter=TypeConverters.toBoolean)
+
+    ignoreCase = Param(Params._dummy(),
+                      "ignoreCase",
+                      "If true, ignores case in the pattern.",
+                      typeConverter=TypeConverters.toBoolean)
+
+    strip = Param(Params._dummy(),
+               "strip",
+               "If true, removes leading or trailing whitespace from the cleaned string.",
+               typeConverter=TypeConverters.toBoolean)
+
+    def setEncoding(self, value):
+        """Sets the encoding to be used for decoding the byte string (default is utf-8).
+
+        Parameters
+        ----------
+        value : str
+            The encoding to be used for decoding the byte string (default is utf-8)
+        """
+        return self._set(encoding=value)
+
+    def setCleanPrefixPattern(self, value):
+        """Sets the pattern for the prefix. Can be a simple string or a regex pattern.
+
+        Parameters
+        ----------
+        value : str
+            The pattern for the prefix. Can be a simple string or a regex pattern.
+        """
+        return self._set(cleanPrefixPattern=value)
+
+    def setCleanPostfixPattern(self, value):
+        """Sets the pattern for the postfix. Can be a simple string or a regex pattern.
+
+        Parameters
+        ----------
+        value : str
+            The pattern for the postfix. Can be a simple string or a regex pattern.
+        """
+        return self._set(cleanPostfixPattern=value)
+
+    def setCleanerMode(self, value):
+        """Sets the cleaner mode.
+
+        Possible values:
+            clean, bytes_string_to_string, clean_non_ascii_chars, clean_ordered_bullets,
+            clean_postfix, clean_prefix, remove_punctuation, replace_unicode_quotes
+
+        Parameters
+        ----------
+        value : str
+            The mode for cleaning operations.
+        """
+        return self._set(cleanerMode=value)
+
+    def setExtraWhitespace(self, value):
+        """Sets whether to remove extra whitespace.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to remove extra whitespace.
+        """
+        return self._set(extraWhitespace=value)
+
+    def setDashes(self, value):
+        """Sets whether to handle dashes in text.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to handle dashes in text.
+        """
+        return self._set(dashes=value)
+
+    def setBullets(self, value):
+        """Sets whether to handle bullets in text.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to handle bullets in text.
+        """
+        return self._set(bullets=value)
+
+    def setTrailingPunctuation(self, value):
+        """Sets whether to remove trailing punctuation from text.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to remove trailing punctuation from text.
+        """
+        return self._set(trailingPunctuation=value)
+
+    def setLowercase(self, value):
+        """Sets whether to convert text to lowercase.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to convert text to lowercase.
+        """
+        return self._set(lowercase=value)
+
+    def setIgnoreCase(self, value):
+        """Sets whether to ignore case in the pattern.
+
+        Parameters
+        ----------
+        value : bool
+            If true, ignores case in the pattern.
+        """
+        return self._set(ignoreCase=value)
+
+    def setStrip(self, value):
+        """Sets whether to remove leading or trailing whitespace from the cleaned string.
+
+        Parameters
+        ----------
+        value : bool
+            If true, removes leading or trailing whitespace from the cleaned string.
+        """
+        return self._set(strip=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.cleaners.Cleaner", java_model=None):
+        super(Cleaner, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
\ No newline at end of file
diff --git a/python/sparknlp/annotator/cleaners/extractor.py b/python/sparknlp/annotator/cleaners/extractor.py
new file mode 100644
index 00000000000000..d1a2a1bbb1326e
--- /dev/null
+++ b/python/sparknlp/annotator/cleaners/extractor.py
@@ -0,0 +1,191 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for Extractor."""
+from sparknlp.common import *
+
+class Extractor(AnnotatorModel):
+    name = "Extractor"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    emailDateTimeTzPattern = Param(Params._dummy(),
+                                   "emailDateTimeTzPattern",
+                                   "Specifies the date-time pattern for email timestamps, including time zone formatting.",
+                                   typeConverter=TypeConverters.toString)
+
+    emailAddress = Param(
+        Params._dummy(),
+        "emailAddress",
+        "Specifies the pattern for email addresses.",
+        typeConverter=TypeConverters.toString
+    )
+
+    ipAddressPattern = Param(
+        Params._dummy(),
+        "ipAddressPattern",
+        "Specifies the pattern for IP addresses.",
+        typeConverter=TypeConverters.toString
+    )
+
+    ipAddressNamePattern = Param(
+        Params._dummy(),
+        "ipAddressNamePattern",
+        "Specifies the pattern for IP addresses with names.",
+        typeConverter=TypeConverters.toString
+    )
+
+    mapiIdPattern = Param(
+        Params._dummy(),
+        "mapiIdPattern",
+        "Specifies the pattern for MAPI IDs.",
+        typeConverter=TypeConverters.toString
+    )
+
+    usPhoneNumbersPattern = Param(
+        Params._dummy(),
+        "usPhoneNumbersPattern",
+        "Specifies the pattern for US phone numbers.",
+        typeConverter=TypeConverters.toString
+    )
+
+    imageUrlPattern = Param(
+        Params._dummy(),
+        "imageUrlPattern",
+        "Specifies the pattern for image URLs.",
+        typeConverter=TypeConverters.toString
+    )
+
+    textPattern = Param(
+        Params._dummy(),
+        "textPattern",
+        "Specifies the pattern for text after and before.",
+        typeConverter=TypeConverters.toString
+    )
+
+    extractorMode = Param(
+        Params._dummy(),
+        "extractorMode",
+        "possible values: " +
+        "email_date, email_address, ip_address, ip_address_name, mapi_id, us_phone_numbers, image_urls, bullets, text_after, text_before",
+        typeConverter=TypeConverters.toString
+    )
+
+    index = Param(
+        Params._dummy(),
+        "index",
+        "Specifies the index of the pattern to extract in text after or before",
+        typeConverter=TypeConverters.toInt
+    )
+
+    def setEmailDateTimeTzPattern(self, value):
+        """Sets specifies the date-time pattern for email timestamps, including time zone formatting.
+
+        Parameters
+        ----------
+        value : str
+            Specifies the date-time pattern for email timestamps, including time zone formatting.
+        """
+        return self._set(emailDateTimeTzPattern=value)
+
+    def setEmailAddress(self, value):
+        """Sets the pattern for email addresses.
+
+        Parameters
+        ----------
+        value : str
+            Specifies the pattern for email addresses.
+        """
+        return self._set(emailAddress=value)
+
+    def setIpAddressPattern(self, value):
+        """Sets the pattern for IP addresses.
+
+        Parameters
+        ----------
+        value : str
+            Specifies the pattern for IP addresses.
+        """
+        return self._set(ipAddressPattern=value)
+
+    def setIpAddressNamePattern(self, value):
+        """Sets the pattern for IP addresses with names.
+
+        Parameters
+        ----------
+        value : str
+            Specifies the pattern for IP addresses with names.
+        """
+        return self._set(ipAddressNamePattern=value)
+
+    def setMapiIdPattern(self, value):
+        """Sets the pattern for MAPI IDs.
+
+        Parameters
+        ----------
+        value : str
+            Specifies the pattern for MAPI IDs.
+        """
+        return self._set(mapiIdPattern=value)
+
+    def setUsPhoneNumbersPattern(self, value):
+        """Sets the pattern for US phone numbers.
+
+        Parameters
+        ----------
+        value : str
+            Specifies the pattern for US phone numbers.
+        """
+        return self._set(usPhoneNumbersPattern=value)
+
+    def setImageUrlPattern(self, value):
+        """Sets the pattern for image URLs.
+
+        Parameters
+        ----------
+        value : str
+            Specifies the pattern for image URLs.
+        """
+        return self._set(imageUrlPattern=value)
+
+    def setTextPattern(self, value):
+        """Sets the pattern for text after and before.
+
+        Parameters
+        ----------
+        value : str
+            Specifies the pattern for text after and before.
+        """
+        return self._set(textPattern=value)
+
+    def setExtractorMode(self, value):
+        return self._set(extractorMode=value)
+
+    def setIndex(self, value):
+        """Sets the index of the pattern to extract in text after or before.
+
+        Parameters
+        ----------
+        value : int
+            Specifies the index of the pattern to extract in text after or before.
+        """
+        return self._set(index=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.cleaners.Extractor", java_model=None):
+        super(Extractor, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
\ No newline at end of file
diff --git a/python/sparknlp/annotator/cv/__init__.py b/python/sparknlp/annotator/cv/__init__.py
index 37eeaf696bb2a8..425936df7ddf99 100644
--- a/python/sparknlp/annotator/cv/__init__.py
+++ b/python/sparknlp/annotator/cv/__init__.py
@@ -16,4 +16,9 @@
 from sparknlp.annotator.cv.convnext_for_image_classification import *
 from sparknlp.annotator.cv.vision_encoder_decoder_for_image_captioning import *
 from sparknlp.annotator.cv.clip_for_zero_shot_classification import *
-from sparknlp.annotator.cv.blip_for_question_answering import *
\ No newline at end of file
+from sparknlp.annotator.cv.blip_for_question_answering import *
+from sparknlp.annotator.cv.janus_for_multimodal import *
+from sparknlp.annotator.cv.mllama_for_multimodal import *
+from sparknlp.annotator.cv.qwen2vl_transformer import *
+from sparknlp.annotator.cv.llava_for_multimodal import *
+from sparknlp.annotator.cv.phi3_vision_for_multimodal import *
diff --git a/python/sparknlp/annotator/cv/janus_for_multimodal.py b/python/sparknlp/annotator/cv/janus_for_multimodal.py
new file mode 100644
index 00000000000000..5646815368808b
--- /dev/null
+++ b/python/sparknlp/annotator/cv/janus_for_multimodal.py
@@ -0,0 +1,356 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+class JanusForMultiModal(AnnotatorModel,
+                          HasBatchedAnnotateImage,
+                          HasImageFeatureProperties,
+                          HasEngine,
+                          HasCandidateLabelsProperties,
+                          HasRescaleFactor):
+    """
+    JanusForMultiModal can load Janus Vision models for visual question answering.
+    The model consists of a vision encoder, a text encoder, and a text decoder.
+    The vision encoder encodes the input image, the text encoder processes the input question
+    alongside the image encoding, and the text decoder generates the answer to the question.
+
+    Janus is a novel autoregressive framework that unifies multimodal understanding and generation.
+    It decouples visual encoding into separate pathways while utilizing a single, unified transformer architecture for processing.
+    This decoupling alleviates conflicts between the visual encoder’s roles in understanding and generation, enhancing the framework’s flexibility.
+
+    Janus surpasses previous unified models and matches or exceeds the performance of task-specific models.
+    It uses the DeepSeek-LLM-1.3b-base trained on approximately 500B text tokens.
+    For multimodal understanding, it employs the SigLIP-L vision encoder supporting 384 x 384 image input,
+    and for image generation, it uses a tokenizer with a downsample rate of 16.
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion object:
+    >>> visualQAClassifier = JanusForMultiModal.pretrained() \
+    ...     .setInputCols(["image_assembler"]) \
+    ...     .setOutputCol("answer")
+
+    The default model is `"janus_1_3b_int4"`, if no name is provided.
+    For available pretrained models, refer to the `Models Hub
+    `__.
+
+    Models from the HuggingFace 🧧 Transformers library are also compatible with Spark NLP 🚀.
+    To check compatibility and learn how to import them, see `Import Transformers into Spark NLP 🚀
+    `_.
+    For extended examples, refer to the `JanusForMultiModal Test Suite
+    `_.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``IMAGE``              ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    batchSize : int, optional
+        Batch size. Larger values allow faster processing but require more memory,
+        by default 2.
+    configProtoBytes : bytes, optional
+        ConfigProto from TensorFlow, serialized into a byte array.
+    maxSentenceLength : int, optional
+        Maximum sentence length to process, by default 50.
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> from pyspark.sql.functions import lit
+
+    >>> image_df = SparkSessionForTest.spark.read.format("image").load(path=images_path)
+    >>> test_df = image_df.withColumn(
+    ...     "text",
+    ...     lit("User: Describe image in details\n\nAssistant:")
+    ... )
+
+    >>> imageAssembler = ImageAssembler() \
+    ...     .setInputCol("image") \
+    ...     .setOutputCol("image_assembler")
+
+    >>> visualQAClassifier = JanusForMultiModal.pretrained() \
+    ...     .setInputCols("image_assembler") \
+    ...     .setOutputCol("answer")
+
+    >>> pipeline = Pipeline().setStages([
+    ...     imageAssembler,
+    ...     visualQAClassifier
+    ... ])
+
+    >>> result = pipeline.fit(test_df).transform(test_df)
+    >>> result.select("image_assembler.origin", "answer.result").show(truncate=False)
+
+    +--------------------------------------+----------------------------------------------------------------------+
+    |origin                                |result                                                                |
+    +--------------------------------------+----------------------------------------------------------------------+
+    |[file:///content/images/cat_image.jpg]|[The unusual aspect of this picture is the presence of two cats lying on a pink couch]|
+    +--------------------------------------+----------------------------------------------------------------------+
+    """
+
+
+
+    name = "JanusForMultiModal"
+
+    inputAnnotatorTypes = [AnnotatorType.IMAGE]
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    configProtoBytes = Param(Params._dummy(),
+                             "configProtoBytes",
+                             "ConfigProto from tensorflow, serialized into byte array. Get with "
+                             "config_proto.SerializeToString()",
+                             TypeConverters.toListInt)
+
+    minOutputLength = Param(Params._dummy(), "minOutputLength", "Minimum length of the sequence to be generated",
+                            typeConverter=TypeConverters.toInt)
+
+    maxOutputLength = Param(Params._dummy(), "maxOutputLength", "Maximum length of output text",
+                            typeConverter=TypeConverters.toInt)
+
+    doSample = Param(Params._dummy(), "doSample", "Whether or not to use sampling; use greedy decoding otherwise",
+                     typeConverter=TypeConverters.toBoolean)
+
+    temperature = Param(Params._dummy(), "temperature", "The value used to module the next token probabilities",
+                        typeConverter=TypeConverters.toFloat)
+
+    topK = Param(Params._dummy(), "topK",
+                 "The number of highest probability vocabulary tokens to keep for top-k-filtering",
+                 typeConverter=TypeConverters.toInt)
+
+    topP = Param(Params._dummy(), "topP",
+                 "If set to float < 1, only the most probable tokens with probabilities that add up to ``top_p`` or higher are kept for generation",
+                 typeConverter=TypeConverters.toFloat)
+
+    repetitionPenalty = Param(Params._dummy(), "repetitionPenalty",
+                              "The parameter for repetition penalty. 1.0 means no penalty. See `this paper `__ for more details",
+                              typeConverter=TypeConverters.toFloat)
+
+    noRepeatNgramSize = Param(Params._dummy(), "noRepeatNgramSize",
+                              "If set to int > 0, all ngrams of that size can only occur once",
+                              typeConverter=TypeConverters.toInt)
+
+    ignoreTokenIds = Param(Params._dummy(), "ignoreTokenIds",
+                           "A list of token ids which are ignored in the decoder's output",
+                           typeConverter=TypeConverters.toListInt)
+    beamSize = Param(Params._dummy(), "beamSize",
+                     "The Number of beams for beam search.",
+                     typeConverter=TypeConverters.toInt)
+    imageGenerateMode = Param(Params._dummy(), "imageGenerateMode",
+                      "Image generation mode",
+                      typeConverter=TypeConverters.toBoolean)
+    numOfParallelImages = Param(Params._dummy(), "numOfParallelImages",
+                    "Number of parallel images to Generate",
+                    typeConverter=TypeConverters.toInt)
+
+    def setMaxSentenceSize(self, value):
+        """Sets Maximum sentence length that the annotator will process, by
+        default 50.
+        Parameters
+        ----------
+        value : int
+            Maximum sentence length that the annotator will process
+        """
+        return self._set(maxSentenceLength=value)
+
+    def setIgnoreTokenIds(self, value):
+        """A list of token ids which are ignored in the decoder's output.
+        Parameters
+        ----------
+        value : List[int]
+            The words to be filtered out
+        """
+        return self._set(ignoreTokenIds=value)
+
+    def setConfigProtoBytes(self, b):
+        """Sets configProto from tensorflow, serialized into byte array.
+        Parameters
+        ----------
+        b : List[int]
+            ConfigProto from tensorflow, serialized into byte array
+        """
+        return self._set(configProtoBytes=b)
+
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
+
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
+
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
+
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
+
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
+
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
+
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation `__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
+
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
+        If set to int > 0, all ngrams of that size can only occur once.
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
+
+    def setBeamSize(self, value):
+        """Sets the number of beam size for beam search, by default `4`.
+        Parameters
+        ----------
+        value : int
+            Number of beam size for beam search
+        """
+        return self._set(beamSize=value)
+
+    def setImageGenerateMode(self, value):
+        """Sets the image generation mode.
+        Parameters
+        ----------
+        value : bool
+            Image generation mode
+        """
+        return self._set(imageGenerateMode=value)
+
+    def setNumOfParallelImages(self, value):
+        """Sets the number of parallel images to generate.
+        Parameters
+        ----------
+        value : int
+            Number of parallel images to generate
+        """
+        return self._set(numOfParallelImages=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.cv.JanusForMultiModal",
+                 java_model=None):
+        super(JanusForMultiModal, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=1,
+            minOutputLength=0,
+            maxOutputLength=50,
+            doSample=False,
+            temperature=1,
+            topK=50,
+            topP=1,
+            repetitionPenalty=1.0,
+            noRepeatNgramSize=0,
+            ignoreTokenIds=[],
+            beamSize=1,
+            imageGenerateMode=False,
+            numOfParallelImages=1
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session, use_openvino=False):
+        """Loads a locally saved model.
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+        Returns
+        -------
+        CLIPForZeroShotClassification
+            The restored model
+        """
+        from sparknlp.internal import _JanusForMultiModalLoader
+        jModel = _JanusForMultiModalLoader(folder, spark_session._jsparkSession, use_openvino)._java_obj
+        return JanusForMultiModal(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="janus_1_3b_int4", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "janus_1_3b_int4"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+        Returns
+        -------
+        CLIPForZeroShotClassification
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(JanusForMultiModal, name, lang, remote_loc)
\ No newline at end of file
diff --git a/python/sparknlp/annotator/cv/llava_for_multimodal.py b/python/sparknlp/annotator/cv/llava_for_multimodal.py
new file mode 100644
index 00000000000000..b203545b82f393
--- /dev/null
+++ b/python/sparknlp/annotator/cv/llava_for_multimodal.py
@@ -0,0 +1,328 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+class LLAVAForMultiModal(AnnotatorModel,
+                 HasBatchedAnnotateImage,
+                 HasImageFeatureProperties,
+                 HasEngine,
+                 HasCandidateLabelsProperties,
+                 HasRescaleFactor):
+    """LLAVAForMultiModal can load LLAVA models  for visual question answering.
+    The model consists of a vision encoder, a text encoder as well as a text decoder.
+    The vision encoder will encode the input image, the text encoder will encode the input question together
+    with the encoding of the image, and the text decoder will output the answer to the question.
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion
+    object:
+
+    >>> visualQAClassifier = LLAVAForMultiModal.pretrained() \\
+    ...     .setInputCols(["image_assembler"]) \\
+    ...     .setOutputCol("answer")
+
+    The default model is ``"llava_1_5_7b_hf"``, if no name is
+    provided.
+
+    For available pretrained models please see the `Models Hub
+    `__.
+
+    To see which models are compatible and how to import them see
+    `Import Transformers into Spark NLP 🚀
+    `_.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``IMAGE``              ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    batchSize
+        Batch size. Large values allows faster processing but requires more
+        memory, by default 2
+    configProtoBytes
+        ConfigProto from tensorflow, serialized into byte array.
+    maxSentenceLength
+        Max sentence length to process, by default 50
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> image_df = SparkSessionForTest.spark.read.format("image").load(path=images_path)
+    >>> test_df = image_df.withColumn("text", lit("USER: \n <|image|> \n What's this picture about? \n ASSISTANT:\n"))
+    >>> imageAssembler = ImageAssembler() \\
+    ...     .setInputCol("image") \\
+    ...     .setOutputCol("image_assembler")
+    >>> visualQAClassifier = LLAVAForMultiModal.pretrained() \\
+    ...     .setInputCols("image_assembler") \\
+    ...     .setOutputCol("answer")
+    >>> pipeline = Pipeline().setStages([
+    ...     imageAssembler,
+    ...     visualQAClassifier
+    ... ])
+    >>> result = pipeline.fit(test_df).transform(test_df)
+    >>> result.select("image_assembler.origin", "answer.result").show(false)
+    +--------------------------------------+------+
+    |origin                                |result|
+    +--------------------------------------+------+
+    |[file:///content/images/cat_image.jpg]|[The unusual aspect of this picture is the presence of two cats lying on a pink couch]|
+    +--------------------------------------+------+
+    """
+
+    name = "LLAVAForMultiModal"
+
+    inputAnnotatorTypes = [AnnotatorType.IMAGE]
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    configProtoBytes = Param(Params._dummy(),
+                             "configProtoBytes",
+                             "ConfigProto from tensorflow, serialized into byte array. Get with "
+                             "config_proto.SerializeToString()",
+                             TypeConverters.toListInt)
+
+    minOutputLength = Param(Params._dummy(), "minOutputLength", "Minimum length of the sequence to be generated",
+                            typeConverter=TypeConverters.toInt)
+
+    maxOutputLength = Param(Params._dummy(), "maxOutputLength", "Maximum length of output text",
+                            typeConverter=TypeConverters.toInt)
+
+    doSample = Param(Params._dummy(), "doSample", "Whether or not to use sampling; use greedy decoding otherwise",
+                     typeConverter=TypeConverters.toBoolean)
+
+    temperature = Param(Params._dummy(), "temperature", "The value used to module the next token probabilities",
+                        typeConverter=TypeConverters.toFloat)
+
+    topK = Param(Params._dummy(), "topK",
+                 "The number of highest probability vocabulary tokens to keep for top-k-filtering",
+                 typeConverter=TypeConverters.toInt)
+
+    topP = Param(Params._dummy(), "topP",
+                 "If set to float < 1, only the most probable tokens with probabilities that add up to ``top_p`` or higher are kept for generation",
+                 typeConverter=TypeConverters.toFloat)
+
+    repetitionPenalty = Param(Params._dummy(), "repetitionPenalty",
+                              "The parameter for repetition penalty. 1.0 means no penalty. See `this paper `__ for more details",
+                              typeConverter=TypeConverters.toFloat)
+
+    noRepeatNgramSize = Param(Params._dummy(), "noRepeatNgramSize",
+                              "If set to int > 0, all ngrams of that size can only occur once",
+                              typeConverter=TypeConverters.toInt)
+
+    ignoreTokenIds = Param(Params._dummy(), "ignoreTokenIds",
+                           "A list of token ids which are ignored in the decoder's output",
+                           typeConverter=TypeConverters.toListInt)
+    beamSize = Param(Params._dummy(), "beamSize",
+                     "The Number of beams for beam search.",
+                     typeConverter=TypeConverters.toInt)
+
+    def setMaxSentenceSize(self, value):
+        """Sets Maximum sentence length that the annotator will process, by
+        default 50.
+
+        Parameters
+        ----------
+        value : int
+            Maximum sentence length that the annotator will process
+        """
+        return self._set(maxSentenceLength=value)
+
+    def setIgnoreTokenIds(self, value):
+        """A list of token ids which are ignored in the decoder's output.
+
+        Parameters
+        ----------
+        value : List[int]
+            The words to be filtered out
+        """
+        return self._set(ignoreTokenIds=value)
+
+    def setConfigProtoBytes(self, b):
+        """Sets configProto from tensorflow, serialized into byte array.
+
+        Parameters
+        ----------
+        b : List[int]
+            ConfigProto from tensorflow, serialized into byte array
+        """
+        return self._set(configProtoBytes=b)
+
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
+
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
+
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
+
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
+
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
+
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
+
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
+
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
+
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
+
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
+
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
+
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
+
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
+
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
+
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
+
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation `__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
+
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
+
+        If set to int > 0, all ngrams of that size can only occur once.
+
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
+
+    def setBeamSize(self, value):
+        """Sets the number of beam size for beam search, by default `4`.
+
+        Parameters
+        ----------
+        value : int
+            Number of beam size for beam search
+        """
+        return self._set(beamSize=value)
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.cv.LLAVAForMultiModal",
+                 java_model=None):
+        super(LLAVAForMultiModal, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=2,
+            minOutputLength=0,
+            maxOutputLength=200,
+            doSample=False,
+            temperature=1,
+            topK=50,
+            topP=1,
+            repetitionPenalty=1.0,
+            noRepeatNgramSize=0,
+            ignoreTokenIds=[],
+            beamSize=1,
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session, use_openvino=False):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        CLIPForZeroShotClassification
+            The restored model
+        """
+        from sparknlp.internal import _LLAVAForMultiModalLoader
+        jModel = _LLAVAForMultiModalLoader(folder, spark_session._jsparkSession, use_openvino)._java_obj
+        return LLAVAForMultiModal(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="llava_1_5_7b_hf", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "llava_1_5_7b_hf"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        LLAVAForMultiModal
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(LLAVAForMultiModal, name, lang, remote_loc)
\ No newline at end of file
diff --git a/python/sparknlp/annotator/cv/mllama_for_multimodal.py b/python/sparknlp/annotator/cv/mllama_for_multimodal.py
new file mode 100644
index 00000000000000..1a4939b739d957
--- /dev/null
+++ b/python/sparknlp/annotator/cv/mllama_for_multimodal.py
@@ -0,0 +1,340 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+class MLLamaForMultimodal(AnnotatorModel,
+                 HasBatchedAnnotateImage,
+                 HasImageFeatureProperties,
+                 HasEngine,
+                 HasCandidateLabelsProperties,
+                 HasRescaleFactor):
+    """
+MLLamaForMultimodal can load LLAMA 3.2 Vision models for visual question answering.
+The model consists of a vision encoder, a text encoder, and a text decoder.
+The vision encoder encodes the input image, the text encoder processes the input question
+alongside the image encoding, and the text decoder generates the answer to the question.
+
+The Llama 3.2-Vision collection comprises pretrained and instruction-tuned multimodal large
+language models (LLMs) available in 11B and 90B sizes. These models are optimized for visual
+recognition, image reasoning, captioning, and answering general questions about images.
+The models outperform many open-source and proprietary multimodal models on standard industry
+benchmarks.
+
+Pretrained models can be loaded with :meth:`.pretrained` of the companion object:
+
+>>> visualQAClassifier = MLLamaForMultimodal.pretrained() \\
+...     .setInputCols(["image_assembler"]) \\
+...     .setOutputCol("answer")
+
+The default model is `"llama_3_2_11b_vision_instruct_int4"`, if no name is provided.
+
+For available pretrained models, refer to the `Models Hub
+`__.
+
+Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀.
+To check compatibility and learn how to import them, see `Import Transformers into Spark NLP 🚀
+`_. For extended examples, refer to
+the `MLLamaForMultimodal Test Suite
+`_.
+
+====================== ======================
+Input Annotation types Output Annotation type
+====================== ======================
+``IMAGE``              ``DOCUMENT``
+====================== ======================
+
+Parameters
+----------
+batchSize : int, optional
+    Batch size. Larger values allow faster processing but require more memory,
+    by default 2.
+configProtoBytes : bytes, optional
+    ConfigProto from TensorFlow, serialized into a byte array.
+maxSentenceLength : int, optional
+    Maximum sentence length to process, by default 50.
+
+Examples
+--------
+>>> import sparknlp
+>>> from sparknlp.base import *
+>>> from sparknlp.annotator import *
+>>> from pyspark.ml import Pipeline
+>>> from pyspark.sql.functions import lit
+>>> image_df = SparkSessionForTest.spark.read.format("image").load(path=images_path)
+>>> test_df = image_df.withColumn(
+...     "text",
+...     lit("<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n")
+... )
+>>> imageAssembler = ImageAssembler() \\
+...     .setInputCol("image") \\
+...     .setOutputCol("image_assembler")
+>>> visualQAClassifier = MLLamaForMultimodal.pretrained() \\
+...     .setInputCols("image_assembler") \\
+...     .setOutputCol("answer")
+>>> pipeline = Pipeline().setStages([
+...     imageAssembler,
+...     visualQAClassifier
+... ])
+>>> result = pipeline.fit(test_df).transform(test_df)
+>>> result.select("image_assembler.origin", "answer.result").show(truncate=False)
++--------------------------------------+----------------------------------------------------------------------+
+|origin                                |result                                                                |
++--------------------------------------+----------------------------------------------------------------------+
+|[file:///content/images/cat_image.jpg]|[The unusual aspect of this picture is the presence of two cats lying on a pink couch]|
++--------------------------------------+----------------------------------------------------------------------+
+"""
+
+
+    name = "MLLamaForMultimodal"
+
+    inputAnnotatorTypes = [AnnotatorType.IMAGE]
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    configProtoBytes = Param(Params._dummy(),
+                             "configProtoBytes",
+                             "ConfigProto from tensorflow, serialized into byte array. Get with "
+                             "config_proto.SerializeToString()",
+                             TypeConverters.toListInt)
+
+    minOutputLength = Param(Params._dummy(), "minOutputLength", "Minimum length of the sequence to be generated",
+                            typeConverter=TypeConverters.toInt)
+
+    maxOutputLength = Param(Params._dummy(), "maxOutputLength", "Maximum length of output text",
+                            typeConverter=TypeConverters.toInt)
+
+    doSample = Param(Params._dummy(), "doSample", "Whether or not to use sampling; use greedy decoding otherwise",
+                     typeConverter=TypeConverters.toBoolean)
+
+    temperature = Param(Params._dummy(), "temperature", "The value used to module the next token probabilities",
+                        typeConverter=TypeConverters.toFloat)
+
+    topK = Param(Params._dummy(), "topK",
+                 "The number of highest probability vocabulary tokens to keep for top-k-filtering",
+                 typeConverter=TypeConverters.toInt)
+
+    topP = Param(Params._dummy(), "topP",
+                 "If set to float < 1, only the most probable tokens with probabilities that add up to ``top_p`` or higher are kept for generation",
+                 typeConverter=TypeConverters.toFloat)
+
+    repetitionPenalty = Param(Params._dummy(), "repetitionPenalty",
+                              "The parameter for repetition penalty. 1.0 means no penalty. See `this paper `__ for more details",
+                              typeConverter=TypeConverters.toFloat)
+
+    noRepeatNgramSize = Param(Params._dummy(), "noRepeatNgramSize",
+                              "If set to int > 0, all ngrams of that size can only occur once",
+                              typeConverter=TypeConverters.toInt)
+
+    ignoreTokenIds = Param(Params._dummy(), "ignoreTokenIds",
+                           "A list of token ids which are ignored in the decoder's output",
+                           typeConverter=TypeConverters.toListInt)
+    beamSize = Param(Params._dummy(), "beamSize",
+                     "The Number of beams for beam search.",
+                     typeConverter=TypeConverters.toInt)
+
+    def setMaxSentenceSize(self, value):
+        """Sets Maximum sentence length that the annotator will process, by
+        default 50.
+
+        Parameters
+        ----------
+        value : int
+            Maximum sentence length that the annotator will process
+        """
+        return self._set(maxSentenceLength=value)
+
+    def setIgnoreTokenIds(self, value):
+        """A list of token ids which are ignored in the decoder's output.
+
+        Parameters
+        ----------
+        value : List[int]
+            The words to be filtered out
+        """
+        return self._set(ignoreTokenIds=value)
+
+    def setConfigProtoBytes(self, b):
+        """Sets configProto from tensorflow, serialized into byte array.
+
+        Parameters
+        ----------
+        b : List[int]
+            ConfigProto from tensorflow, serialized into byte array
+        """
+        return self._set(configProtoBytes=b)
+
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
+
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
+
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
+
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
+
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
+
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
+
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
+
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
+
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
+
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
+
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
+
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
+
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
+
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
+
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
+
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation `__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
+
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
+
+        If set to int > 0, all ngrams of that size can only occur once.
+
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
+
+    def setBeamSize(self, value):
+        """Sets the number of beam size for beam search, by default `4`.
+
+        Parameters
+        ----------
+        value : int
+            Number of beam size for beam search
+        """
+        return self._set(beamSize=value)
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.cv.MLLamaForMultimodal",
+                 java_model=None):
+        super(MLLamaForMultimodal, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=1,
+            minOutputLength=0,
+            maxOutputLength=50,
+            doSample=False,
+            temperature=1,
+            topK=50,
+            topP=1,
+            repetitionPenalty=1.0,
+            noRepeatNgramSize=0,
+            ignoreTokenIds=[],
+            beamSize=1,
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session, use_openvino=False):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        CLIPForZeroShotClassification
+            The restored model
+        """
+        from sparknlp.internal import _MLLamaForMultimodalLoader
+        jModel = _MLLamaForMultimodalLoader(folder, spark_session._jsparkSession, use_openvino)._java_obj
+        return MLLamaForMultimodal(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="llama_3_2_11b_vision_instruct_int4", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "llama_3_2_11b_vision_instruct_int4"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        MLLamaForMultimodal
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(MLLamaForMultimodal, name, lang, remote_loc)
\ No newline at end of file
diff --git a/python/sparknlp/annotator/cv/phi3_vision_for_multimodal.py b/python/sparknlp/annotator/cv/phi3_vision_for_multimodal.py
new file mode 100644
index 00000000000000..d86261cbc5f894
--- /dev/null
+++ b/python/sparknlp/annotator/cv/phi3_vision_for_multimodal.py
@@ -0,0 +1,328 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+class Phi3Vision(AnnotatorModel,
+                               HasBatchedAnnotateImage,
+                               HasImageFeatureProperties,
+                               HasEngine,
+                               HasCandidateLabelsProperties,
+                               HasRescaleFactor):
+    """Phi3Vision can load Phi3Vision models  for visual question answering.
+    The model consists of a vision encoder, a text encoder as well as a text decoder.
+    The vision encoder will encode the input image, the text encoder will encode the input question together
+    with the encoding of the image, and the text decoder will output the answer to the question.
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion
+    object:
+
+    >>> visualQAClassifier = Phi3Vision.pretrained() \\
+    ...     .setInputCols(["image_assembler"]) \\
+    ...     .setOutputCol("answer")
+
+    The default model is ``"phi_3_vision_128k_instruct"``, if no name is
+    provided.
+
+    For available pretrained models please see the `Models Hub
+    `__.
+
+    To see which models are compatible and how to import them see
+    `Import Transformers into Spark NLP 🚀
+    `_.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``IMAGE``              ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    batchSize
+        Batch size. Large values allows faster processing but requires more
+        memory, by default 2
+    configProtoBytes
+        ConfigProto from tensorflow, serialized into byte array.
+    maxSentenceLength
+        Max sentence length to process, by default 50
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> image_df = SparkSessionForTest.spark.read.format("image").load(path=images_path)
+    >>> test_df = image_df.withColumn("text", lit("<|user|> \n <|image_1|> \nWhat is unusual on this picture? <|end|>\n <|assistant|>\n"))
+    >>> imageAssembler = ImageAssembler() \\
+    ...     .setInputCol("image") \\
+    ...     .setOutputCol("image_assembler")
+    >>> visualQAClassifier = Phi3Vision.pretrained("phi_3_vision_128k_instruct","en") \\
+    ...     .setInputCols("image_assembler") \\
+    ...     .setOutputCol("answer")
+    >>> pipeline = Pipeline().setStages([
+    ...     imageAssembler,
+    ...     visualQAClassifier
+    ... ])
+    >>> result = pipeline.fit(test_df).transform(test_df)
+    >>> result.select("image_assembler.origin", "answer.result").show(false)
+    +--------------------------------------+------+
+    |origin                                |result|
+    +--------------------------------------+------+
+    |[file:///content/images/cat_image.jpg]|[The unusual aspect of this picture is the presence of two cats lying on a pink couch]|
+    +--------------------------------------+------+
+    """
+
+    name = "Phi3Vision"
+
+    inputAnnotatorTypes = [AnnotatorType.IMAGE]
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    configProtoBytes = Param(Params._dummy(),
+                             "configProtoBytes",
+                             "ConfigProto from tensorflow, serialized into byte array. Get with "
+                             "config_proto.SerializeToString()",
+                             TypeConverters.toListInt)
+
+    minOutputLength = Param(Params._dummy(), "minOutputLength", "Minimum length of the sequence to be generated",
+                            typeConverter=TypeConverters.toInt)
+
+    maxOutputLength = Param(Params._dummy(), "maxOutputLength", "Maximum length of output text",
+                            typeConverter=TypeConverters.toInt)
+
+    doSample = Param(Params._dummy(), "doSample", "Whether or not to use sampling; use greedy decoding otherwise",
+                     typeConverter=TypeConverters.toBoolean)
+
+    temperature = Param(Params._dummy(), "temperature", "The value used to module the next token probabilities",
+                        typeConverter=TypeConverters.toFloat)
+
+    topK = Param(Params._dummy(), "topK",
+                 "The number of highest probability vocabulary tokens to keep for top-k-filtering",
+                 typeConverter=TypeConverters.toInt)
+
+    topP = Param(Params._dummy(), "topP",
+                 "If set to float < 1, only the most probable tokens with probabilities that add up to ``top_p`` or higher are kept for generation",
+                 typeConverter=TypeConverters.toFloat)
+
+    repetitionPenalty = Param(Params._dummy(), "repetitionPenalty",
+                              "The parameter for repetition penalty. 1.0 means no penalty. See `this paper `__ for more details",
+                              typeConverter=TypeConverters.toFloat)
+
+    noRepeatNgramSize = Param(Params._dummy(), "noRepeatNgramSize",
+                              "If set to int > 0, all ngrams of that size can only occur once",
+                              typeConverter=TypeConverters.toInt)
+
+    ignoreTokenIds = Param(Params._dummy(), "ignoreTokenIds",
+                           "A list of token ids which are ignored in the decoder's output",
+                           typeConverter=TypeConverters.toListInt)
+    beamSize = Param(Params._dummy(), "beamSize",
+                     "The Number of beams for beam search.",
+                     typeConverter=TypeConverters.toInt)
+
+    def setMaxSentenceSize(self, value):
+        """Sets Maximum sentence length that the annotator will process, by
+        default 50.
+
+        Parameters
+        ----------
+        value : int
+            Maximum sentence length that the annotator will process
+        """
+        return self._set(maxSentenceLength=value)
+
+    def setIgnoreTokenIds(self, value):
+        """A list of token ids which are ignored in the decoder's output.
+
+        Parameters
+        ----------
+        value : List[int]
+            The words to be filtered out
+        """
+        return self._set(ignoreTokenIds=value)
+
+    def setConfigProtoBytes(self, b):
+        """Sets configProto from tensorflow, serialized into byte array.
+
+        Parameters
+        ----------
+        b : List[int]
+            ConfigProto from tensorflow, serialized into byte array
+        """
+        return self._set(configProtoBytes=b)
+
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
+
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
+
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
+
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
+
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
+
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
+
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
+
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
+
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
+
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
+
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
+
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
+
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
+
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
+
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
+
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation `__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
+
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
+
+        If set to int > 0, all ngrams of that size can only occur once.
+
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
+
+    def setBeamSize(self, value):
+        """Sets the number of beam size for beam search, by default `4`.
+
+        Parameters
+        ----------
+        value : int
+            Number of beam size for beam search
+        """
+        return self._set(beamSize=value)
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.cv.Phi3Vision",
+                 java_model=None):
+        super(Phi3Vision, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=2,
+            minOutputLength=0,
+            maxOutputLength=200,
+            doSample=False,
+            temperature=1,
+            topK=50,
+            topP=1,
+            repetitionPenalty=1.0,
+            noRepeatNgramSize=0,
+            ignoreTokenIds=[],
+            beamSize=1,
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session, use_openvino=False):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        CLIPForZeroShotClassification
+            The restored model
+        """
+        from sparknlp.internal import _Phi3VisionLoader
+        jModel = _Phi3VisionLoader(folder, spark_session._jsparkSession, use_openvino)._java_obj
+        return Phi3Vision(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="phi_3_vision_128k_instruct", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "phi3v"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        CLIPForZeroShotClassification
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(Phi3Vision, name, lang, remote_loc)
\ No newline at end of file
diff --git a/python/sparknlp/annotator/cv/qwen2vl_transformer.py b/python/sparknlp/annotator/cv/qwen2vl_transformer.py
new file mode 100644
index 00000000000000..a0dfc52a8f1706
--- /dev/null
+++ b/python/sparknlp/annotator/cv/qwen2vl_transformer.py
@@ -0,0 +1,332 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from sparknlp.common import *
+
+class Qwen2VLTransformer(AnnotatorModel,
+                         HasBatchedAnnotateImage,
+                         HasImageFeatureProperties,
+                         HasEngine,
+                         HasCandidateLabelsProperties,
+                         HasRescaleFactor):
+    """
+    Qwen2VLTransformer can load Qwen2 Vision-Language models for visual question answering
+    and multimodal instruction following. The model consists of a vision encoder, a text encoder,
+    and a text decoder. The vision encoder processes the input image, the text encoder integrates
+    the encoding of the image with the input text, and the text decoder outputs the response to
+    the query or instruction.
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion object:
+
+    >>> visualQAClassifier = Qwen2VLTransformer.pretrained() \\
+    ...     .setInputCols(["image_assembler"]) \\
+    ...     .setOutputCol("answer")
+
+    The default model is ``"qwen2_vl_2b_instruct_int4"``, if no name is provided.
+
+    For available pretrained models, please see the `Models Hub
+    `__.
+
+    Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. To
+    see which models are compatible and how to import them, see
+    `Import Transformers into Spark NLP 🚀
+    `__. For more extended examples, see
+    `Spark NLP Test Suite for Qwen2VLTransformer
+    `__.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``IMAGE``              ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    batchSize
+        Batch size. Large values allow faster processing but require more memory,
+        by default 2
+    configProtoBytes
+        ConfigProto from TensorFlow, serialized into byte array.
+    maxSentenceLength
+        Max sentence length to process, by default 50
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> image_df = SparkSessionForTest.spark.read.format("image").load(path=images_path)
+    >>> test_df = image_df.withColumn("text", lit("<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n"))
+    >>> imageAssembler = ImageAssembler() \\
+    ...     .setInputCol("image") \\
+    ...     .setOutputCol("image_assembler")
+    >>> visualQAClassifier = Qwen2VLTransformer.pretrained() \\
+    ...     .setInputCols("image_assembler") \\
+    ...     .setOutputCol("answer")
+    >>> pipeline = Pipeline().setStages([
+    ...     imageAssembler,
+    ...     visualQAClassifier
+    ... ])
+    >>> result = pipeline.fit(test_df).transform(test_df)
+    >>> result.select("image_assembler.origin", "answer.result").show(false)
+    +--------------------------------------+------+
+    |origin                                |result|
+    +--------------------------------------+------+
+    |[file:///content/images/cat_image.jpg]|[This image is unusual because it features two cats lying on a pink couch.]|
+    +--------------------------------------+------+
+    """
+
+
+    name = "Qwen2VLTransformer"
+
+    inputAnnotatorTypes = [AnnotatorType.IMAGE]
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    configProtoBytes = Param(Params._dummy(),
+                             "configProtoBytes",
+                             "ConfigProto from tensorflow, serialized into byte array. Get with "
+                             "config_proto.SerializeToString()",
+                             TypeConverters.toListInt)
+
+    minOutputLength = Param(Params._dummy(), "minOutputLength", "Minimum length of the sequence to be generated",
+                            typeConverter=TypeConverters.toInt)
+
+    maxOutputLength = Param(Params._dummy(), "maxOutputLength", "Maximum length of output text",
+                            typeConverter=TypeConverters.toInt)
+
+    doSample = Param(Params._dummy(), "doSample", "Whether or not to use sampling; use greedy decoding otherwise",
+                     typeConverter=TypeConverters.toBoolean)
+
+    temperature = Param(Params._dummy(), "temperature", "The value used to module the next token probabilities",
+                        typeConverter=TypeConverters.toFloat)
+
+    topK = Param(Params._dummy(), "topK",
+                 "The number of highest probability vocabulary tokens to keep for top-k-filtering",
+                 typeConverter=TypeConverters.toInt)
+
+    topP = Param(Params._dummy(), "topP",
+                 "If set to float < 1, only the most probable tokens with probabilities that add up to ``top_p`` or higher are kept for generation",
+                 typeConverter=TypeConverters.toFloat)
+
+    repetitionPenalty = Param(Params._dummy(), "repetitionPenalty",
+                              "The parameter for repetition penalty. 1.0 means no penalty. See `this paper `__ for more details",
+                              typeConverter=TypeConverters.toFloat)
+
+    noRepeatNgramSize = Param(Params._dummy(), "noRepeatNgramSize",
+                              "If set to int > 0, all ngrams of that size can only occur once",
+                              typeConverter=TypeConverters.toInt)
+
+    ignoreTokenIds = Param(Params._dummy(), "ignoreTokenIds",
+                           "A list of token ids which are ignored in the decoder's output",
+                           typeConverter=TypeConverters.toListInt)
+    beamSize = Param(Params._dummy(), "beamSize",
+                     "The Number of beams for beam search.",
+                     typeConverter=TypeConverters.toInt)
+
+    def setMaxSentenceSize(self, value):
+        """Sets Maximum sentence length that the annotator will process, by
+        default 50.
+
+        Parameters
+        ----------
+        value : int
+            Maximum sentence length that the annotator will process
+        """
+        return self._set(maxSentenceLength=value)
+
+    def setIgnoreTokenIds(self, value):
+        """A list of token ids which are ignored in the decoder's output.
+
+        Parameters
+        ----------
+        value : List[int]
+            The words to be filtered out
+        """
+        return self._set(ignoreTokenIds=value)
+
+    def setConfigProtoBytes(self, b):
+        """Sets configProto from tensorflow, serialized into byte array.
+
+        Parameters
+        ----------
+        b : List[int]
+            ConfigProto from tensorflow, serialized into byte array
+        """
+        return self._set(configProtoBytes=b)
+
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
+
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
+
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
+
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
+
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
+
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
+
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
+
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
+
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
+
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
+
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
+
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
+
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
+
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
+
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
+
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation `__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
+
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
+
+        If set to int > 0, all ngrams of that size can only occur once.
+
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
+
+    def setBeamSize(self, value):
+        """Sets the number of beam size for beam search, by default `4`.
+
+        Parameters
+        ----------
+        value : int
+            Number of beam size for beam search
+        """
+        return self._set(beamSize=value)
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.cv.Qwen2VLTransformer",
+                 java_model=None):
+        super(Qwen2VLTransformer, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            batchSize=2,
+            minOutputLength=0,
+            maxOutputLength=200,
+            doSample=False,
+            temperature=1,
+            topK=50,
+            topP=1,
+            repetitionPenalty=1.0,
+            noRepeatNgramSize=0,
+            ignoreTokenIds=[],
+            beamSize=1,
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session, use_openvino=False):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        CLIPForZeroShotClassification
+            The restored model
+        """
+        from sparknlp.internal import _Qwen2VLTransformerLoader
+        jModel = _Qwen2VLTransformerLoader(folder, spark_session._jsparkSession, use_openvino)._java_obj
+        return Qwen2VLTransformer(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="qwen2_vl_2b_instruct_int4", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default
+            "qwen2_vl_2b_instruct_int4"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        Qwen2VLTransformer
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(Qwen2VLTransformer, name, lang, remote_loc)
\ No newline at end of file
diff --git a/python/sparknlp/annotator/embeddings/auto_gguf_embeddings.py b/python/sparknlp/annotator/embeddings/auto_gguf_embeddings.py
index 30cee663c16129..20bb13906afe02 100755
--- a/python/sparknlp/annotator/embeddings/auto_gguf_embeddings.py
+++ b/python/sparknlp/annotator/embeddings/auto_gguf_embeddings.py
@@ -32,7 +32,7 @@ class AutoGGUFEmbeddings(AnnotatorModel, HasBatchedAnnotate):
     ...     .setInputCols(["document"]) \\
     ...     .setOutputCol("embeddings")
 
-    The default model is ``"nomic-embed-text-v1.5.Q8_0.gguf"``, if no name is provided.
+    The default model is ``"Nomic_Embed_Text_v1.5.Q8_0.gguf"``, if no name is provided.
 
     For extended examples of usage, see the
     `AutoGGUFEmbeddingsTest `__
@@ -471,15 +471,19 @@ def setNoKvOffload(self, noKvOffload: bool):
         """Whether to disable KV offload"""
         return self._set(noKvOffload=noKvOffload)
 
+    def setNParallel(self, nParallel: int):
+        """Sets the number of parallel processes for decoding. This is an alias for `setBatchSize`."""
+        return self.setBatchSize(nParallel)
+
     def getMetadata(self):
         """Gets the metadata of the model"""
         return self._call_java("getMetadata")
 
     @keyword_only
     def __init__(
-        self,
-        classname="com.johnsnowlabs.nlp.embeddings.AutoGGUFEmbeddings",
-        java_model=None,
+            self,
+            classname="com.johnsnowlabs.nlp.embeddings.AutoGGUFEmbeddings",
+            java_model=None,
     ):
         super(AutoGGUFEmbeddings, self).__init__(
             classname=classname, java_model=java_model
@@ -513,13 +517,13 @@ def loadSavedModel(folder, spark_session):
         return AutoGGUFEmbeddings(java_model=jModel)
 
     @staticmethod
-    def pretrained(name="nomic-embed-text-v1.5.Q8_0.gguf", lang="en", remote_loc=None):
+    def pretrained(name="Nomic_Embed_Text_v1.5.Q8_0.gguf", lang="en", remote_loc=None):
         """Downloads and loads a pretrained model.
 
         Parameters
         ----------
         name : str, optional
-            Name of the pretrained model, by default "nomic-embed-text-v1.5.Q8_0.gguf"
+            Name of the pretrained model, by default "Nomic_Embed_Text_v1.5.Q8_0.gguf"
         lang : str, optional
             Language of the pretrained model, by default "en"
         remote_loc : str, optional
diff --git a/python/sparknlp/annotator/seq2seq/__init__.py b/python/sparknlp/annotator/seq2seq/__init__.py
index e9c3984c21ecc1..e67f8fce189a4d 100644
--- a/python/sparknlp/annotator/seq2seq/__init__.py
+++ b/python/sparknlp/annotator/seq2seq/__init__.py
@@ -22,9 +22,12 @@
 from sparknlp.annotator.seq2seq.phi2_transformer import *
 from sparknlp.annotator.seq2seq.mistral_transformer import *
 from sparknlp.annotator.seq2seq.auto_gguf_model import *
+from sparknlp.annotator.seq2seq.auto_gguf_vision_model import *
 from sparknlp.annotator.seq2seq.phi3_transformer import *
 from sparknlp.annotator.seq2seq.nllb_transformer import *
 from sparknlp.annotator.seq2seq.cpm_transformer import *
 from sparknlp.annotator.seq2seq.qwen_transformer import *
 from sparknlp.annotator.seq2seq.starcoder_transformer import *
 from sparknlp.annotator.seq2seq.llama3_transformer import *
+from sparknlp.annotator.seq2seq.cohere_transformer import *
+from sparknlp.annotator.seq2seq.olmo_transformer import *
diff --git a/python/sparknlp/annotator/seq2seq/auto_gguf_model.py b/python/sparknlp/annotator/seq2seq/auto_gguf_model.py
index d28ac006c9da22..37c96319564782 100755
--- a/python/sparknlp/annotator/seq2seq/auto_gguf_model.py
+++ b/python/sparknlp/annotator/seq2seq/auto_gguf_model.py
@@ -17,7 +17,7 @@
 from sparknlp.common import *
 
 
-class AutoGGUFModel(AnnotatorModel, HasBatchedAnnotate):
+class AutoGGUFModel(AnnotatorModel, HasBatchedAnnotate, HasLlamaCppProperties):
     """
     Annotator that uses the llama.cpp library to generate text completions with large language
     models.
@@ -241,507 +241,6 @@ class AutoGGUFModel(AnnotatorModel, HasBatchedAnnotate):
     inputAnnotatorTypes = [AnnotatorType.DOCUMENT]
     outputAnnotatorType = AnnotatorType.DOCUMENT
 
-    # -------- MODEl PARAMETERS --------
-    nThreads = Param(Params._dummy(), "nThreads", "Set the number of threads to use during generation",
-                     typeConverter=TypeConverters.toInt)
-    nThreadsDraft = Param(Params._dummy(), "nThreadsDraft", "Set the number of threads to use during draft generation",
-                          typeConverter=TypeConverters.toInt)
-    nThreadsBatch = Param(Params._dummy(), "nThreadsBatch",
-                          "Set the number of threads to use during batch and prompt processing",
-                          typeConverter=TypeConverters.toInt)
-    nThreadsBatchDraft = Param(Params._dummy(), "nThreadsBatchDraft",
-                               "Set the number of threads to use during batch and prompt processing",
-                               typeConverter=TypeConverters.toInt)
-    nCtx = Param(Params._dummy(), "nCtx", "Set the size of the prompt context", typeConverter=TypeConverters.toInt)
-    nBatch = Param(Params._dummy(), "nBatch",
-                   "Set the logical batch size for prompt processing (must be >=32 to use BLAS)",
-                   typeConverter=TypeConverters.toInt)
-    nUbatch = Param(Params._dummy(), "nUbatch",
-                    "Set the physical batch size for prompt processing (must be >=32 to use BLAS)",
-                    typeConverter=TypeConverters.toInt)
-    nDraft = Param(Params._dummy(), "nDraft", "Set the number of tokens to draft for speculative decoding",
-                   typeConverter=TypeConverters.toInt)
-    nChunks = Param(Params._dummy(), "nChunks", "Set the maximal number of chunks to process",
-                    typeConverter=TypeConverters.toInt)
-    nSequences = Param(Params._dummy(), "nSequences", "Set the number of sequences to decode",
-                       typeConverter=TypeConverters.toInt)
-    pSplit = Param(Params._dummy(), "pSplit", "Set the speculative decoding split probability",
-                   typeConverter=TypeConverters.toFloat)
-    nGpuLayers = Param(Params._dummy(), "nGpuLayers", "Set the number of layers to store in VRAM (-1 - use default)",
-                       typeConverter=TypeConverters.toInt)
-    nGpuLayersDraft = Param(Params._dummy(), "nGpuLayersDraft",
-                            "Set the number of layers to store in VRAM for the draft model (-1 - use default)",
-                            typeConverter=TypeConverters.toInt)
-    # Set how to split the model across GPUs
-    #
-    #   - NONE: No GPU split
-    #   - LAYER: Split the model across GPUs by layer
-    #   - ROW: Split the model across GPUs by rows
-    gpuSplitMode = Param(Params._dummy(), "gpuSplitMode", "Set how to split the model across GPUs",
-                         typeConverter=TypeConverters.toString)
-    mainGpu = Param(Params._dummy(), "mainGpu", "Set the main GPU that is used for scratch and small tensors.",
-                    typeConverter=TypeConverters.toInt)
-    tensorSplit = Param(Params._dummy(), "tensorSplit", "Set how split tensors should be distributed across GPUs",
-                        typeConverter=TypeConverters.toListFloat)
-    grpAttnN = Param(Params._dummy(), "grpAttnN", "Set the group-attention factor", typeConverter=TypeConverters.toInt)
-    grpAttnW = Param(Params._dummy(), "grpAttnW", "Set the group-attention width", typeConverter=TypeConverters.toInt)
-    ropeFreqBase = Param(Params._dummy(), "ropeFreqBase", "Set the RoPE base frequency, used by NTK-aware scaling",
-                         typeConverter=TypeConverters.toFloat)
-    ropeFreqScale = Param(Params._dummy(), "ropeFreqScale",
-                          "Set the RoPE frequency scaling factor, expands context by a factor of 1/N",
-                          typeConverter=TypeConverters.toFloat)
-    yarnExtFactor = Param(Params._dummy(), "yarnExtFactor", "Set the YaRN extrapolation mix factor",
-                          typeConverter=TypeConverters.toFloat)
-    yarnAttnFactor = Param(Params._dummy(), "yarnAttnFactor", "Set the YaRN scale sqrt(t) or attention magnitude",
-                           typeConverter=TypeConverters.toFloat)
-    yarnBetaFast = Param(Params._dummy(), "yarnBetaFast", "Set the YaRN low correction dim or beta",
-                         typeConverter=TypeConverters.toFloat)
-    yarnBetaSlow = Param(Params._dummy(), "yarnBetaSlow", "Set the YaRN high correction dim or alpha",
-                         typeConverter=TypeConverters.toFloat)
-    yarnOrigCtx = Param(Params._dummy(), "yarnOrigCtx", "Set the YaRN original context size of model",
-                        typeConverter=TypeConverters.toInt)
-    defragmentationThreshold = Param(Params._dummy(), "defragmentationThreshold",
-                                     "Set the KV cache defragmentation threshold", typeConverter=TypeConverters.toFloat)
-    # Set optimization strategies that help on some NUMA systems (if available)
-    #
-    # Available Strategies:
-    #
-    #   - DISABLED: No NUMA optimizations
-    #   - DISTRIBUTE: Spread execution evenly over all
-    #   - ISOLATE: Only spawn threads on CPUs on the node that execution started on
-    #   - NUMA_CTL: Use the CPU map provided by numactl
-    #   - MIRROR: Mirrors the model across NUMA nodes
-    numaStrategy = Param(Params._dummy(), "numaStrategy",
-                         "Set optimization strategies that help on some NUMA systems (if available)",
-                         typeConverter=TypeConverters.toString)
-    # Set the RoPE frequency scaling method, defaults to linear unless specified by the model.
-    #
-    #   - UNSPECIFIED: Don't use any scaling
-    #   - LINEAR: Linear scaling
-    #   - YARN: YaRN RoPE scaling
-    ropeScalingType = Param(Params._dummy(), "ropeScalingType",
-                            "Set the RoPE frequency scaling method, defaults to linear unless specified by the model",
-                            typeConverter=TypeConverters.toString)
-    # Set the pooling type for embeddings, use model default if unspecified
-    #
-    #   - 0 UNSPECIFIED: Don't use any pooling
-    #   - 1 MEAN: Mean Pooling
-    #   - 2 CLS: CLS Pooling
-    poolingType = Param(Params._dummy(), "poolingType",
-                        "Set the pooling type for embeddings, use model default if unspecified",
-                        typeConverter=TypeConverters.toString)
-    modelDraft = Param(Params._dummy(), "modelDraft", "Set the draft model for speculative decoding",
-                       typeConverter=TypeConverters.toString)
-    modelAlias = Param(Params._dummy(), "modelAlias", "Set a model alias", typeConverter=TypeConverters.toString)
-    lookupCacheStaticFilePath = Param(Params._dummy(), "lookupCacheStaticFilePath",
-                                      "Set path to static lookup cache to use for lookup decoding (not updated by generation)",
-                                      typeConverter=TypeConverters.toString)
-    lookupCacheDynamicFilePath = Param(Params._dummy(), "lookupCacheDynamicFilePath",
-                                       "Set path to dynamic lookup cache to use for lookup decoding (updated by generation)",
-                                       typeConverter=TypeConverters.toString)
-    # loraAdapters = new StructFeature[Map[String, Float]](this, "loraAdapters")
-    embedding = Param(Params._dummy(), "embedding", "Whether to load model with embedding support",
-                      typeConverter=TypeConverters.toBoolean)
-    flashAttention = Param(Params._dummy(), "flashAttention", "Whether to enable Flash Attention",
-                           typeConverter=TypeConverters.toBoolean)
-    inputPrefixBos = Param(Params._dummy(), "inputPrefixBos",
-                           "Whether to add prefix BOS to user inputs, preceding the `--in-prefix` string",
-                           typeConverter=TypeConverters.toBoolean)
-    useMmap = Param(Params._dummy(), "useMmap",
-                    "Whether to use memory-map model (faster load but may increase pageouts if not using mlock)",
-                    typeConverter=TypeConverters.toBoolean)
-    useMlock = Param(Params._dummy(), "useMlock",
-                     "Whether to force the system to keep model in RAM rather than swapping or compressing",
-                     typeConverter=TypeConverters.toBoolean)
-    noKvOffload = Param(Params._dummy(), "noKvOffload", "Whether to disable KV offload",
-                        typeConverter=TypeConverters.toBoolean)
-    systemPrompt = Param(Params._dummy(), "systemPrompt", "Set a system prompt to use",
-                         typeConverter=TypeConverters.toString)
-    chatTemplate = Param(Params._dummy(), "chatTemplate", "The chat template to use",
-                         typeConverter=TypeConverters.toString)
-
-    # -------- INFERENCE PARAMETERS --------
-    inputPrefix = Param(Params._dummy(), "inputPrefix", "Set the prompt to start generation with",
-                        typeConverter=TypeConverters.toString)
-    inputSuffix = Param(Params._dummy(), "inputSuffix", "Set a suffix for infilling",
-                        typeConverter=TypeConverters.toString)
-    cachePrompt = Param(Params._dummy(), "cachePrompt", "Whether to remember the prompt to avoid reprocessing it",
-                        typeConverter=TypeConverters.toBoolean)
-    nPredict = Param(Params._dummy(), "nPredict", "Set the number of tokens to predict",
-                     typeConverter=TypeConverters.toInt)
-    topK = Param(Params._dummy(), "topK", "Set top-k sampling", typeConverter=TypeConverters.toInt)
-    topP = Param(Params._dummy(), "topP", "Set top-p sampling", typeConverter=TypeConverters.toFloat)
-    minP = Param(Params._dummy(), "minP", "Set min-p sampling", typeConverter=TypeConverters.toFloat)
-    tfsZ = Param(Params._dummy(), "tfsZ", "Set tail free sampling, parameter z", typeConverter=TypeConverters.toFloat)
-    typicalP = Param(Params._dummy(), "typicalP", "Set locally typical sampling, parameter p",
-                     typeConverter=TypeConverters.toFloat)
-    temperature = Param(Params._dummy(), "temperature", "Set the temperature", typeConverter=TypeConverters.toFloat)
-    dynamicTemperatureRange = Param(Params._dummy(), "dynatempRange", "Set the dynamic temperature range",
-                                    typeConverter=TypeConverters.toFloat)
-    dynamicTemperatureExponent = Param(Params._dummy(), "dynatempExponent", "Set the dynamic temperature exponent",
-                                       typeConverter=TypeConverters.toFloat)
-    repeatLastN = Param(Params._dummy(), "repeatLastN", "Set the last n tokens to consider for penalties",
-                        typeConverter=TypeConverters.toInt)
-    repeatPenalty = Param(Params._dummy(), "repeatPenalty", "Set the penalty of repeated sequences of tokens",
-                          typeConverter=TypeConverters.toFloat)
-    frequencyPenalty = Param(Params._dummy(), "frequencyPenalty", "Set the repetition alpha frequency penalty",
-                             typeConverter=TypeConverters.toFloat)
-    presencePenalty = Param(Params._dummy(), "presencePenalty", "Set the repetition alpha presence penalty",
-                            typeConverter=TypeConverters.toFloat)
-    miroStat = Param(Params._dummy(), "miroStat", "Set MiroStat sampling strategies.",
-                     typeConverter=TypeConverters.toString)
-    miroStatTau = Param(Params._dummy(), "mirostatTau", "Set the MiroStat target entropy, parameter tau",
-                        typeConverter=TypeConverters.toFloat)
-    miroStatEta = Param(Params._dummy(), "mirostatEta", "Set the MiroStat learning rate, parameter eta",
-                        typeConverter=TypeConverters.toFloat)
-    penalizeNl = Param(Params._dummy(), "penalizeNl", "Whether to penalize newline tokens",
-                       typeConverter=TypeConverters.toBoolean)
-    nKeep = Param(Params._dummy(), "nKeep", "Set the number of tokens to keep from the initial prompt",
-                  typeConverter=TypeConverters.toInt)
-    seed = Param(Params._dummy(), "seed", "Set the RNG seed", typeConverter=TypeConverters.toInt)
-    nProbs = Param(Params._dummy(), "nProbs", "Set the amount top tokens probabilities to output if greater than 0.",
-                   typeConverter=TypeConverters.toInt)
-    minKeep = Param(Params._dummy(), "minKeep",
-                    "Set the amount of tokens the samplers should return at least (0 = disabled)",
-                    typeConverter=TypeConverters.toInt)
-    grammar = Param(Params._dummy(), "grammar", "Set BNF-like grammar to constrain generations",
-                    typeConverter=TypeConverters.toString)
-    penaltyPrompt = Param(Params._dummy(), "penaltyPrompt",
-                          "Override which part of the prompt is penalized for repetition.",
-                          typeConverter=TypeConverters.toString)
-    ignoreEos = Param(Params._dummy(), "ignoreEos",
-                      "Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)",
-                      typeConverter=TypeConverters.toBoolean)
-    disableTokenIds = Param(Params._dummy(), "disableTokenIds", "Set the token ids to disable in the completion",
-                            typeConverter=TypeConverters.toListInt)
-    stopStrings = Param(Params._dummy(), "stopStrings", "Set strings upon seeing which token generation is stopped",
-                        typeConverter=TypeConverters.toListString)
-    samplers = Param(Params._dummy(), "samplers", "Set which samplers to use for token generation in the given order",
-                     typeConverter=TypeConverters.toListString)
-    useChatTemplate = Param(Params._dummy(), "useChatTemplate",
-                            "Set whether or not generate should apply a chat template",
-                            typeConverter=TypeConverters.toBoolean)
-
-    # -------- MODEL SETTERS --------
-    def setNThreads(self, nThreads: int):
-        """Set the number of threads to use during generation"""
-        return self._set(nThreads=nThreads)
-
-    def setNThreadsDraft(self, nThreadsDraft: int):
-        """Set the number of threads to use during draft generation"""
-        return self._set(nThreadsDraft=nThreadsDraft)
-
-    def setNThreadsBatch(self, nThreadsBatch: int):
-        """Set the number of threads to use during batch and prompt processing"""
-        return self._set(nThreadsBatch=nThreadsBatch)
-
-    def setNThreadsBatchDraft(self, nThreadsBatchDraft: int):
-        """Set the number of threads to use during batch and prompt processing"""
-        return self._set(nThreadsBatchDraft=nThreadsBatchDraft)
-
-    def setNCtx(self, nCtx: int):
-        """Set the size of the prompt context"""
-        return self._set(nCtx=nCtx)
-
-    def setNBatch(self, nBatch: int):
-        """Set the logical batch size for prompt processing (must be >=32 to use BLAS)"""
-        return self._set(nBatch=nBatch)
-
-    def setNUbatch(self, nUbatch: int):
-        """Set the physical batch size for prompt processing (must be >=32 to use BLAS)"""
-        return self._set(nUbatch=nUbatch)
-
-    def setNDraft(self, nDraft: int):
-        """Set the number of tokens to draft for speculative decoding"""
-        return self._set(nDraft=nDraft)
-
-    def setNChunks(self, nChunks: int):
-        """Set the maximal number of chunks to process"""
-        return self._set(nChunks=nChunks)
-
-    def setNSequences(self, nSequences: int):
-        """Set the number of sequences to decode"""
-        return self._set(nSequences=nSequences)
-
-    def setPSplit(self, pSplit: float):
-        """Set the speculative decoding split probability"""
-        return self._set(pSplit=pSplit)
-
-    def setNGpuLayers(self, nGpuLayers: int):
-        """Set the number of layers to store in VRAM (-1 - use default)"""
-        return self._set(nGpuLayers=nGpuLayers)
-
-    def setNGpuLayersDraft(self, nGpuLayersDraft: int):
-        """Set the number of layers to store in VRAM for the draft model (-1 - use default)"""
-        return self._set(nGpuLayersDraft=nGpuLayersDraft)
-
-    def setGpuSplitMode(self, gpuSplitMode: str):
-        """Set how to split the model across GPUs"""
-        return self._set(gpuSplitMode=gpuSplitMode)
-
-    def setMainGpu(self, mainGpu: int):
-        """Set the main GPU that is used for scratch and small tensors."""
-        return self._set(mainGpu=mainGpu)
-
-    def setTensorSplit(self, tensorSplit: List[float]):
-        """Set how split tensors should be distributed across GPUs"""
-        return self._set(tensorSplit=tensorSplit)
-
-    def setGrpAttnN(self, grpAttnN: int):
-        """Set the group-attention factor"""
-        return self._set(grpAttnN=grpAttnN)
-
-    def setGrpAttnW(self, grpAttnW: int):
-        """Set the group-attention width"""
-        return self._set(grpAttnW=grpAttnW)
-
-    def setRopeFreqBase(self, ropeFreqBase: float):
-        """Set the RoPE base frequency, used by NTK-aware scaling"""
-        return self._set(ropeFreqBase=ropeFreqBase)
-
-    def setRopeFreqScale(self, ropeFreqScale: float):
-        """Set the RoPE frequency scaling factor, expands context by a factor of 1/N"""
-        return self._set(ropeFreqScale=ropeFreqScale)
-
-    def setYarnExtFactor(self, yarnExtFactor: float):
-        """Set the YaRN extrapolation mix factor"""
-        return self._set(yarnExtFactor=yarnExtFactor)
-
-    def setYarnAttnFactor(self, yarnAttnFactor: float):
-        """Set the YaRN scale sqrt(t) or attention magnitude"""
-        return self._set(yarnAttnFactor=yarnAttnFactor)
-
-    def setYarnBetaFast(self, yarnBetaFast: float):
-        """Set the YaRN low correction dim or beta"""
-        return self._set(yarnBetaFast=yarnBetaFast)
-
-    def setYarnBetaSlow(self, yarnBetaSlow: float):
-        """Set the YaRN high correction dim or alpha"""
-        return self._set(yarnBetaSlow=yarnBetaSlow)
-
-    def setYarnOrigCtx(self, yarnOrigCtx: int):
-        """Set the YaRN original context size of model"""
-        return self._set(yarnOrigCtx=yarnOrigCtx)
-
-    def setDefragmentationThreshold(self, defragmentationThreshold: float):
-        """Set the KV cache defragmentation threshold"""
-        return self._set(defragmentationThreshold=defragmentationThreshold)
-
-    def setNumaStrategy(self, numaStrategy: str):
-        """Set optimization strategies that help on some NUMA systems (if available)"""
-        numaUpper = numaStrategy.upper()
-        numaStrategies = ["DISABLED", "DISTRIBUTE", "ISOLATE", "NUMA_CTL", "MIRROR"]
-        if numaUpper not in numaStrategies:
-            raise ValueError(
-                f"Invalid NUMA strategy: {numaUpper}. "
-                + f"Valid values are: {numaStrategies}"
-            )
-        return self._set(numaStrategy=numaStrategy)
-
-    def setRopeScalingType(self, ropeScalingType: str):
-        """Set the RoPE frequency scaling method, defaults to linear unless specified by the model"""
-        return self._set(ropeScalingType=ropeScalingType)
-
-    def setPoolingType(self, poolingType: bool):
-        """Set the pooling type for embeddings, use model default if unspecified"""
-        poolingTypeUpper = poolingType.upper()
-        poolingTypes = ["NONE", "MEAN", "CLS", "LAST"]
-        if poolingTypeUpper not in poolingTypes:
-            raise ValueError(
-                f"Invalid pooling type: {poolingType}. "
-                + f"Valid values are: {poolingTypes}"
-            )
-        return self._set(poolingType=poolingType)
-
-    def setModelDraft(self, modelDraft: str):
-        """Set the draft model for speculative decoding"""
-        return self._set(modelDraft=modelDraft)
-
-    def setModelAlias(self, modelAlias: str):
-        """Set a model alias"""
-        return self._set(modelAlias=modelAlias)
-
-    def setLookupCacheStaticFilePath(self, lookupCacheStaticFilePath: str):
-        """Set path to static lookup cache to use for lookup decoding (not updated by generation)"""
-        return self._set(lookupCacheStaticFilePath=lookupCacheStaticFilePath)
-
-    def setLookupCacheDynamicFilePath(self, lookupCacheDynamicFilePath: str):
-        """Set path to dynamic lookup cache to use for lookup decoding (updated by generation)"""
-        return self._set(lookupCacheDynamicFilePath=lookupCacheDynamicFilePath)
-
-    def setEmbedding(self, embedding: bool):
-        """Whether to load model with embedding support"""
-        return self._set(embedding=embedding)
-
-    def setFlashAttention(self, flashAttention: bool):
-        """Whether to enable Flash Attention"""
-        return self._set(flashAttention=flashAttention)
-
-    def setInputPrefixBos(self, inputPrefixBos: bool):
-        """Whether to add prefix BOS to user inputs, preceding the `--in-prefix` bool"""
-        return self._set(inputPrefixBos=inputPrefixBos)
-
-    def setUseMmap(self, useMmap: bool):
-        """Whether to use memory-map model (faster load but may increase pageouts if not using mlock)"""
-        return self._set(useMmap=useMmap)
-
-    def setUseMlock(self, useMlock: bool):
-        """Whether to force the system to keep model in RAM rather than swapping or compressing"""
-        return self._set(useMlock=useMlock)
-
-    def setNoKvOffload(self, noKvOffload: bool):
-        """Whether to disable KV offload"""
-        return self._set(noKvOffload=noKvOffload)
-
-    def setSystemPrompt(self, systemPrompt: bool):
-        """Set a system prompt to use"""
-        return self._set(systemPrompt=systemPrompt)
-
-    def setChatTemplate(self, chatTemplate: str):
-        """The chat template to use"""
-        return self._set(chatTemplate=chatTemplate)
-
-    # -------- INFERENCE SETTERS --------
-    def setInputPrefix(self, inputPrefix: str):
-        """Set the prompt to start generation with"""
-        return self._set(inputPrefix=inputPrefix)
-
-    def setInputSuffix(self, inputSuffix: str):
-        """Set a suffix for infilling"""
-        return self._set(inputSuffix=inputSuffix)
-
-    def setCachePrompt(self, cachePrompt: bool):
-        """Whether to remember the prompt to avoid reprocessing it"""
-        return self._set(cachePrompt=cachePrompt)
-
-    def setNPredict(self, nPredict: int):
-        """Set the number of tokens to predict"""
-        return self._set(nPredict=nPredict)
-
-    def setTopK(self, topK: int):
-        """Set top-k sampling"""
-        return self._set(topK=topK)
-
-    def setTopP(self, topP: float):
-        """Set top-p sampling"""
-        return self._set(topP=topP)
-
-    def setMinP(self, minP: float):
-        """Set min-p sampling"""
-        return self._set(minP=minP)
-
-    def setTfsZ(self, tfsZ: float):
-        """Set tail free sampling, parameter z"""
-        return self._set(tfsZ=tfsZ)
-
-    def setTypicalP(self, typicalP: float):
-        """Set locally typical sampling, parameter p"""
-        return self._set(typicalP=typicalP)
-
-    def setTemperature(self, temperature: float):
-        """Set the temperature"""
-        return self._set(temperature=temperature)
-
-    def setDynamicTemperatureRange(self, dynamicTemperatureRange: float):
-        """Set the dynamic temperature range"""
-        return self._set(dynamicTemperatureRange=dynamicTemperatureRange)
-
-    def setDynamicTemperatureExponent(self, dynamicTemperatureExponent: float):
-        """Set the dynamic temperature exponent"""
-        return self._set(dynamicTemperatureExponent=dynamicTemperatureExponent)
-
-    def setRepeatLastN(self, repeatLastN: int):
-        """Set the last n tokens to consider for penalties"""
-        return self._set(repeatLastN=repeatLastN)
-
-    def setRepeatPenalty(self, repeatPenalty: float):
-        """Set the penalty of repeated sequences of tokens"""
-        return self._set(repeatPenalty=repeatPenalty)
-
-    def setFrequencyPenalty(self, frequencyPenalty: float):
-        """Set the repetition alpha frequency penalty"""
-        return self._set(frequencyPenalty=frequencyPenalty)
-
-    def setPresencePenalty(self, presencePenalty: float):
-        """Set the repetition alpha presence penalty"""
-        return self._set(presencePenalty=presencePenalty)
-
-    def setMiroStat(self, miroStat: str):
-        """Set MiroStat sampling strategies."""
-        return self._set(miroStat=miroStat)
-
-    def setMiroStatTau(self, miroStatTau: float):
-        """Set the MiroStat target entropy, parameter tau"""
-        return self._set(miroStatTau=miroStatTau)
-
-    def setMiroStatEta(self, miroStatEta: float):
-        """Set the MiroStat learning rate, parameter eta"""
-        return self._set(miroStatEta=miroStatEta)
-
-    def setPenalizeNl(self, penalizeNl: bool):
-        """Whether to penalize newline tokens"""
-        return self._set(penalizeNl=penalizeNl)
-
-    def setNKeep(self, nKeep: int):
-        """Set the number of tokens to keep from the initial prompt"""
-        return self._set(nKeep=nKeep)
-
-    def setSeed(self, seed: int):
-        """Set the RNG seed"""
-        return self._set(seed=seed)
-
-    def setNProbs(self, nProbs: int):
-        """Set the amount top tokens probabilities to output if greater than 0."""
-        return self._set(nProbs=nProbs)
-
-    def setMinKeep(self, minKeep: int):
-        """Set the amount of tokens the samplers should return at least (0 = disabled)"""
-        return self._set(minKeep=minKeep)
-
-    def setGrammar(self, grammar: bool):
-        """Set BNF-like grammar to constrain generations"""
-        return self._set(grammar=grammar)
-
-    def setPenaltyPrompt(self, penaltyPrompt: str):
-        """Override which part of the prompt is penalized for repetition."""
-        return self._set(penaltyPrompt=penaltyPrompt)
-
-    def setIgnoreEos(self, ignoreEos: bool):
-        """Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)"""
-        return self._set(ignoreEos=ignoreEos)
-
-    def setDisableTokenIds(self, disableTokenIds: List[int]):
-        """Set the token ids to disable in the completion"""
-        return self._set(disableTokenIds=disableTokenIds)
-
-    def setStopStrings(self, stopStrings: List[str]):
-        """Set strings upon seeing which token generation is stopped"""
-        return self._set(stopStrings=stopStrings)
-
-    def setSamplers(self, samplers: List[str]):
-        """Set which samplers to use for token generation in the given order"""
-        return self._set(samplers=samplers)
-
-    def setUseChatTemplate(self, useChatTemplate: bool):
-        """Set whether generate should apply a chat template"""
-        return self._set(useChatTemplate=useChatTemplate)
-
-    # -------- JAVA SETTERS --------
-    def setTokenIdBias(self, tokenIdBias: Dict[int, float]):
-        """Set token id bias"""
-        return self._call_java("setTokenIdBias", tokenIdBias)
-
-    def setTokenBias(self, tokenBias: Dict[str, float]):
-        """Set token id bias"""
-        return self._call_java("setTokenBias", tokenBias)
-
-    def setLoraAdapters(self, loraAdapters: Dict[str, float]):
-        """Set token id bias"""
-        return self._call_java("setLoraAdapters", loraAdapters)
-
-    def getMetadata(self):
-        """Gets the metadata of the model"""
-        return self._call_java("getMetadata")
 
     @keyword_only
     def __init__(self, classname="com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFModel", java_model=None):
@@ -749,7 +248,13 @@ def __init__(self, classname="com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFMo
             classname=classname,
             java_model=java_model
         )
-        # self._setDefault()
+        self._setDefault(
+            useChatTemplate=True,
+            nCtx=4096,
+            nBatch=512,
+            embedding=False,
+            nPredict=100
+        )
 
     @staticmethod
     def loadSavedModel(folder, spark_session):
diff --git a/python/sparknlp/annotator/seq2seq/auto_gguf_vision_model.py b/python/sparknlp/annotator/seq2seq/auto_gguf_vision_model.py
new file mode 100755
index 00000000000000..b05150ed3b9905
--- /dev/null
+++ b/python/sparknlp/annotator/seq2seq/auto_gguf_vision_model.py
@@ -0,0 +1,333 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the AutoGGUFVisionModel."""
+from sparknlp.common import *
+
+
+class AutoGGUFVisionModel(AnnotatorModel, HasBatchedAnnotate, HasLlamaCppProperties):
+    """Multimodal annotator that uses the llama.cpp library to generate text completions with large
+    language models. It supports ingesting images for captioning.
+
+    At the moment only CLIP based models are supported.
+
+    For settable parameters, and their explanations, see HasLlamaCppInferenceProperties,
+    HasLlamaCppModelProperties and refer to the llama.cpp documentation of
+    `server.cpp `__
+    for more information.
+
+    If the parameters are not set, the annotator will default to use the parameters provided by
+    the model.
+
+    This annotator expects a column of annotator type AnnotationImage for the image and
+    Annotation for the caption. Note that the image bytes in the image annotation need to be
+    raw image bytes without preprocessing. We provide the helper function
+    ImageAssembler.loadImagesAsBytes to load the image bytes from a directory.
+
+    Pretrained models can be loaded with ``pretrained`` of the companion object:
+
+    .. code-block:: python
+
+        autoGGUFVisionModel = AutoGGUFVisionModel.pretrained() \\
+            .setInputCols(["image", "document"]) \\
+            .setOutputCol("completions")
+
+
+    The default model is ``"llava_v1.5_7b_Q4_0_gguf"``, if no name is provided.
+
+    For available pretrained models please see the `Models Hub `__.
+
+    For extended examples of usage, see the
+    `AutoGGUFVisionModelTest `__
+    and the
+    `example notebook `__.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``IMAGE, DOCUMENT``    ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    nThreads
+        Set the number of threads to use during generation
+    nThreadsDraft
+        Set the number of threads to use during draft generation
+    nThreadsBatch
+        Set the number of threads to use during batch and prompt processing
+    nThreadsBatchDraft
+        Set the number of threads to use during batch and prompt processing
+    nCtx
+        Set the size of the prompt context
+    nBatch
+        Set the logical batch size for prompt processing (must be >=32 to use BLAS)
+    nUbatch
+        Set the physical batch size for prompt processing (must be >=32 to use BLAS)
+    nDraft
+        Set the number of tokens to draft for speculative decoding
+    nChunks
+        Set the maximal number of chunks to process
+    nSequences
+        Set the number of sequences to decode
+    pSplit
+        Set the speculative decoding split probability
+    nGpuLayers
+        Set the number of layers to store in VRAM (-1 - use default)
+    nGpuLayersDraft
+        Set the number of layers to store in VRAM for the draft model (-1 - use default)
+    gpuSplitMode
+        Set how to split the model across GPUs
+    mainGpu
+        Set the main GPU that is used for scratch and small tensors.
+    tensorSplit
+        Set how split tensors should be distributed across GPUs
+    grpAttnN
+        Set the group-attention factor
+    grpAttnW
+        Set the group-attention width
+    ropeFreqBase
+        Set the RoPE base frequency, used by NTK-aware scaling
+    ropeFreqScale
+        Set the RoPE frequency scaling factor, expands context by a factor of 1/N
+    yarnExtFactor
+        Set the YaRN extrapolation mix factor
+    yarnAttnFactor
+        Set the YaRN scale sqrt(t) or attention magnitude
+    yarnBetaFast
+        Set the YaRN low correction dim or beta
+    yarnBetaSlow
+        Set the YaRN high correction dim or alpha
+    yarnOrigCtx
+        Set the YaRN original context size of model
+    defragmentationThreshold
+        Set the KV cache defragmentation threshold
+    numaStrategy
+        Set optimization strategies that help on some NUMA systems (if available)
+    ropeScalingType
+        Set the RoPE frequency scaling method, defaults to linear unless specified by the model
+    poolingType
+        Set the pooling type for embeddings, use model default if unspecified
+    modelDraft
+        Set the draft model for speculative decoding
+    modelAlias
+        Set a model alias
+    lookupCacheStaticFilePath
+        Set path to static lookup cache to use for lookup decoding (not updated by generation)
+    lookupCacheDynamicFilePath
+        Set path to dynamic lookup cache to use for lookup decoding (updated by generation)
+    embedding
+        Whether to load model with embedding support
+    flashAttention
+        Whether to enable Flash Attention
+    inputPrefixBos
+        Whether to add prefix BOS to user inputs, preceding the `--in-prefix` string
+    useMmap
+        Whether to use memory-map model (faster load but may increase pageouts if not using mlock)
+    useMlock
+        Whether to force the system to keep model in RAM rather than swapping or compressing
+    noKvOffload
+        Whether to disable KV offload
+    systemPrompt
+        Set a system prompt to use
+    chatTemplate
+        The chat template to use
+    inputPrefix
+        Set the prompt to start generation with
+    inputSuffix
+        Set a suffix for infilling
+    cachePrompt
+        Whether to remember the prompt to avoid reprocessing it
+    nPredict
+        Set the number of tokens to predict
+    topK
+        Set top-k sampling
+    topP
+        Set top-p sampling
+    minP
+        Set min-p sampling
+    tfsZ
+        Set tail free sampling, parameter z
+    typicalP
+        Set locally typical sampling, parameter p
+    temperature
+        Set the temperature
+    dynatempRange
+        Set the dynamic temperature range
+    dynatempExponent
+        Set the dynamic temperature exponent
+    repeatLastN
+        Set the last n tokens to consider for penalties
+    repeatPenalty
+        Set the penalty of repeated sequences of tokens
+    frequencyPenalty
+        Set the repetition alpha frequency penalty
+    presencePenalty
+        Set the repetition alpha presence penalty
+    miroStat
+        Set MiroStat sampling strategies.
+    mirostatTau
+        Set the MiroStat target entropy, parameter tau
+    mirostatEta
+        Set the MiroStat learning rate, parameter eta
+    penalizeNl
+        Whether to penalize newline tokens
+    nKeep
+        Set the number of tokens to keep from the initial prompt
+    seed
+        Set the RNG seed
+    nProbs
+        Set the amount top tokens probabilities to output if greater than 0.
+    minKeep
+        Set the amount of tokens the samplers should return at least (0 = disabled)
+    grammar
+        Set BNF-like grammar to constrain generations
+    penaltyPrompt
+        Override which part of the prompt is penalized for repetition.
+    ignoreEos
+        Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)
+    disableTokenIds
+        Set the token ids to disable in the completion
+    stopStrings
+        Set strings upon seeing which token generation is stopped
+    samplers
+        Set which samplers to use for token generation in the given order
+    useChatTemplate
+        Set whether or not generate should apply a chat template
+
+    Notes
+    -----
+    To use GPU inference with this annotator, make sure to use the Spark NLP GPU package and set
+    the number of GPU layers with the `setNGpuLayers` method.
+
+    When using larger models, we recommend adjusting GPU usage with `setNCtx` and `setNGpuLayers`
+    according to your hardware to avoid out-of-memory errors.
+
+    Examples
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> from pyspark.sql.functions import lit
+    >>> documentAssembler = DocumentAssembler() \\
+    ...     .setInputCol("caption") \\
+    ...     .setOutputCol("caption_document")
+    >>> imageAssembler = ImageAssembler() \\
+    ...     .setInputCol("image") \\
+    ...     .setOutputCol("image_assembler")
+    >>> imagesPath = "src/test/resources/image/"
+    >>> data = ImageAssembler \\
+    ...     .loadImagesAsBytes(spark, imagesPath) \\
+    ...     .withColumn("caption", lit("Caption this image.")) # Add a caption to each image.
+    >>> nPredict = 40
+    >>> model = AutoGGUFVisionModel.pretrained() \\
+    ...     .setInputCols(["caption_document", "image_assembler"]) \\
+    ...     .setOutputCol("completions") \\
+    ...     .setBatchSize(4) \\
+    ...     .setNGpuLayers(99) \\
+    ...     .setNCtx(4096) \\
+    ...     .setMinKeep(0) \\
+    ...     .setMinP(0.05) \\
+    ...     .setNPredict(nPredict) \\
+    ...     .setNProbs(0) \\
+    ...     .setPenalizeNl(False) \\
+    ...     .setRepeatLastN(256) \\
+    ...     .setRepeatPenalty(1.18) \\
+    ...     .setStopStrings(["", "Llama:", "User:"]) \\
+    ...     .setTemperature(0.05) \\
+    ...     .setTfsZ(1) \\
+    ...     .setTypicalP(1) \\
+    ...     .setTopK(40) \\
+    ...     .setTopP(0.95)
+    >>> pipeline = Pipeline().setStages([documentAssembler, imageAssembler, model])
+    >>> pipeline.fit(data).transform(data) \\
+    ...     .selectExpr("reverse(split(image.origin, '/'))[0] as image_name", "completions.result") \\
+    ...     .show(truncate = False)
+    +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |image_name       |result                                                                                                                                                                                        |
+    +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |palace.JPEG      |[ The image depicts a large, ornate room with high ceilings and beautifully decorated walls. There are several chairs placed throughout the space, some of which have cushions]               |
+    |egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the scene and appears to be sleeping while holding]             |
+    |hippopotamus.JPEG|[ A large brown hippo is swimming in a body of water, possibly an aquarium. The hippo appears to be enjoying its time in the water and seems relaxed as it floats]                            |
+    |hen.JPEG         |[ The image features a large chicken standing next to several baby chickens. In total, there are five birds in the scene: one adult and four young ones. They appear to be gathered together] |
+    |ostrich.JPEG     |[ The image features a large, long-necked bird standing in the grass. It appears to be an ostrich or similar species with its head held high and looking around. In addition to]              |
+    |junco.JPEG       |[ A small bird with a black head and white chest is standing on the snow. It appears to be looking at something, possibly food or another animal in its vicinity. The scene takes place out]  |
+    |bluetick.jpg     |[ A dog with a red collar is sitting on the floor, looking at something. The dog appears to be staring into the distance or focusing its attention on an object in front of it.]              |
+    |chihuahua.jpg    |[ A small brown dog wearing a sweater is sitting on the floor. The dog appears to be looking at something, possibly its owner or another animal in the room. It seems comfortable and relaxed]|
+    |tractor.JPEG     |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels and tires. The tractor appears to be parked on top of an empty field with]                                |
+    |ox.JPEG          |[ A large bull with horns is standing in a grassy field.]                                                                                                                                     |
+    +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------
+    """
+
+    name = "AutoGGUFVisionModel"
+    inputAnnotatorTypes = [AnnotatorType.IMAGE, AnnotatorType.DOCUMENT]
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFVisionModel", java_model=None):
+        super(AutoGGUFVisionModel, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+
+        self._setDefault(
+            useChatTemplate=True,
+            nCtx=4096,
+            nBatch=512,
+            embedding=False,
+            nPredict=100
+        )
+
+    @staticmethod
+    def loadSavedModel(modelPath, mmprojPath, spark_session):
+        """Loads a locally saved modelPath.
+
+        Parameters
+        ----------
+        modelPath : str
+            Path to the modelPath file
+        mmprojPath : str
+            Path to the mmprojPath file
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        AutoGGUFVisionModel
+            The restored modelPath
+        """
+        from sparknlp.internal import _AutoGGUFVisionLoader
+        jModel = _AutoGGUFVisionLoader(modelPath, mmprojPath, spark_session._jsparkSession)._java_obj
+        return AutoGGUFVisionModel(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="llava_v1.5_7b_Q4_0_gguf", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default "llava_v1.5_7b_Q4_0_gguf"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        AutoGGUFVisionModel
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(AutoGGUFVisionModel, name, lang, remote_loc)
diff --git a/python/sparknlp/annotator/seq2seq/cohere_transformer.py b/python/sparknlp/annotator/seq2seq/cohere_transformer.py
new file mode 100644
index 00000000000000..f72994860171a4
--- /dev/null
+++ b/python/sparknlp/annotator/seq2seq/cohere_transformer.py
@@ -0,0 +1,357 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the CoHereTransformer."""
+
+from sparknlp.common import *
+
+
+class CoHereTransformer(AnnotatorModel, HasBatchedAnnotate, HasEngine):
+    """Cohere: Command-R Transformer
+    
+        C4AI Command-R is a research release of a 35 billion parameter highly performant generative model.
+        Command-R is a large language model with open weights optimized for a variety of use cases including reasoning,
+        summarization, and question answering. Command-R has the capability for multilingual generation evaluated
+        in 10 languages and highly performant RAG capabilities.
+
+        Pretrained models can be loaded with :meth:`.pretrained` of the companion
+        object:
+    
+        >>> CoHere = CoHereTransformer.pretrained() \\
+        ...     .setInputCols(["document"]) \\
+        ...     .setOutputCol("generation")
+    
+    
+        The default model is ``"c4ai_command_r_v01_int4"``, if no name is provided. For available
+        pretrained models please see the `Models Hub
+        `__.
+    
+        ====================== ======================
+        Input Annotation types Output Annotation type
+        ====================== ======================
+        ``DOCUMENT``           ``DOCUMENT``
+        ====================== ======================
+    
+        Parameters
+        ----------
+        configProtoBytes
+            ConfigProto from tensorflow, serialized into byte array.
+        minOutputLength
+            Minimum length of the sequence to be generated, by default 0
+        maxOutputLength
+            Maximum length of output text, by default 60
+        doSample
+            Whether or not to use sampling; use greedy decoding otherwise, by default False
+        temperature
+            The value used to modulate the next token probabilities, by default 1.0
+        topK
+            The number of highest probability vocabulary tokens to keep for
+            top-k-filtering, by default 40
+        topP
+            Top cumulative probability for vocabulary tokens, by default 1.0
+    
+            If set to float < 1, only the most probable tokens with probabilities
+            that add up to ``topP`` or higher are kept for generation.
+        repetitionPenalty
+            The parameter for repetition penalty, 1.0 means no penalty. , by default
+            1.0
+        noRepeatNgramSize
+            If set to int > 0, all ngrams of that size can only occur once, by
+            default 0
+        ignoreTokenIds
+            A list of token ids which are ignored in the decoder's output, by
+            default []
+    
+        Notes
+        -----
+        This is a very computationally expensive module, especially on larger
+        sequences. The use of an accelerator such as GPU is recommended.
+    
+        References
+        ----------
+        - `Cohere `__
+
+    
+        Examples
+        --------
+        >>> import sparknlp
+        >>> from sparknlp.base import *
+        >>> from sparknlp.annotator import *
+        >>> from pyspark.ml import Pipeline
+        >>> documentAssembler = DocumentAssembler() \\
+        ...     .setInputCol("text") \\
+        ...     .setOutputCol("documents")
+        >>> CoHere = CoHereTransformer.pretrained("c4ai_command_r_v01_int4","en") \\
+        ...     .setInputCols(["documents"]) \\
+        ...     .setMaxOutputLength(60) \\
+        ...     .setOutputCol("generation")
+        >>> pipeline = Pipeline().setStages([documentAssembler, CoHere])
+        >>> data = spark.createDataFrame([
+        ...     (
+        ...         1,
+        ...         "<|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>"
+        ...         )
+        ... ]).toDF("id", "text")
+        >>> result = pipeline.fit(data).transform(data)
+        >>> result.select("generation.result").show(truncate=False)
+        +------------------------------------------------+
+        |result                                          |
+        +------------------------------------------------+
+        |[Hello! I'm doing well, thank you for asking! I'm excited to help you with whatever questions you have today. How can I assist you?]|
+        +------------------------------------------------+
+    """
+
+    name = "CoHereTransformer"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT]
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    configProtoBytes = Param(Params._dummy(),
+                             "configProtoBytes",
+                             "ConfigProto from tensorflow, serialized into byte array. Get with config_proto.SerializeToString()",
+                             TypeConverters.toListInt)
+
+    minOutputLength = Param(Params._dummy(), "minOutputLength", "Minimum length of the sequence to be generated",
+                            typeConverter=TypeConverters.toInt)
+
+    maxOutputLength = Param(Params._dummy(), "maxOutputLength", "Maximum length of output text",
+                            typeConverter=TypeConverters.toInt)
+
+    doSample = Param(Params._dummy(), "doSample", "Whether or not to use sampling; use greedy decoding otherwise",
+                     typeConverter=TypeConverters.toBoolean)
+
+    temperature = Param(Params._dummy(), "temperature", "The value used to module the next token probabilities",
+                        typeConverter=TypeConverters.toFloat)
+
+    topK = Param(Params._dummy(), "topK",
+                 "The number of highest probability vocabulary tokens to keep for top-k-filtering",
+                 typeConverter=TypeConverters.toInt)
+
+    topP = Param(Params._dummy(), "topP",
+                 "If set to float < 1, only the most probable tokens with probabilities that add up to ``top_p`` or higher are kept for generation",
+                 typeConverter=TypeConverters.toFloat)
+
+    repetitionPenalty = Param(Params._dummy(), "repetitionPenalty",
+                              "The parameter for repetition penalty. 1.0 means no penalty. See `this paper `__ for more details",
+                              typeConverter=TypeConverters.toFloat)
+
+    noRepeatNgramSize = Param(Params._dummy(), "noRepeatNgramSize",
+                              "If set to int > 0, all ngrams of that size can only occur once",
+                              typeConverter=TypeConverters.toInt)
+
+    ignoreTokenIds = Param(Params._dummy(), "ignoreTokenIds",
+                           "A list of token ids which are ignored in the decoder's output",
+                           typeConverter=TypeConverters.toListInt)
+
+    beamSize = Param(Params._dummy(), "beamSize",
+                     "The number of beams to use for beam search",
+                     typeConverter=TypeConverters.toInt)
+
+    stopTokenIds = Param(Params._dummy(), "stopTokenIds",
+                         "A list of token ids which are considered as stop tokens in the decoder's output",
+                         typeConverter=TypeConverters.toListInt)
+
+    def setIgnoreTokenIds(self, value):
+        """A list of token ids which are ignored in the decoder's output.
+
+        Parameters
+        ----------
+        value : List[int]
+            The words to be filtered out
+        """
+        return self._set(ignoreTokenIds=value)
+
+    def setConfigProtoBytes(self, b):
+        """Sets configProto from tensorflow, serialized into byte array.
+
+        Parameters
+        ----------
+        b : List[int]
+            ConfigProto from tensorflow, serialized into byte array
+        """
+        return self._set(configProtoBytes=b)
+
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
+
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
+
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
+
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
+
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
+
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
+
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
+
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
+
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
+
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
+
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
+
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
+
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
+
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
+
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
+
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation `__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
+
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
+
+        If set to int > 0, all ngrams of that size can only occur once.
+
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
+
+    def setBeamSize(self, value):
+        """Sets the number of beams to use for beam search.
+
+        Parameters
+        ----------
+        value : int
+            The number of beams to use for beam search
+        """
+        return self._set(beamSize=value)
+
+    def setStopTokenIds(self, value):
+        """Sets a list of token ids which are considered as stop tokens in the decoder's output.
+
+        Parameters
+        ----------
+        value : List[int]
+            The words to be considered as stop tokens
+        """
+        return self._set(stopTokenIds=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.seq2seq.CoHereTransformer", java_model=None):
+        super(CoHereTransformer, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            minOutputLength=0,
+            maxOutputLength=20,
+            doSample=False,
+            temperature=0.6,
+            topK=-1,
+            topP=0.9,
+            repetitionPenalty=1.0,
+            noRepeatNgramSize=3,
+            ignoreTokenIds=[],
+            batchSize=1,
+            beamSize=1,
+            stopTokenIds=[128001, ]
+        )
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session, use_openvino=False):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        CoHereTransformer
+            The restored model
+        """
+        from sparknlp.internal import _CoHereLoader
+        jModel = _CoHereLoader(folder, spark_session._jsparkSession, use_openvino)._java_obj
+        return CoHereTransformer(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="c4ai_command_r_v01_int4", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default "c4ai_command_r_v01_int4"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        CoHereTransformer
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(CoHereTransformer, name, lang, remote_loc)
diff --git a/python/sparknlp/annotator/seq2seq/llama3_transformer.py b/python/sparknlp/annotator/seq2seq/llama3_transformer.py
index 43b32f1a70454a..f242d68264355f 100644
--- a/python/sparknlp/annotator/seq2seq/llama3_transformer.py
+++ b/python/sparknlp/annotator/seq2seq/llama3_transformer.py
@@ -38,7 +38,7 @@ class LLAMA3Transformer(AnnotatorModel, HasBatchedAnnotate, HasEngine):
         ...     .setOutputCol("generation")
     
     
-        The default model is ``"llama3-7b"``, if no name is provided. For available
+        The default model is ``"llama_3_7b_chat_hf_int4"``, if no name is provided. For available
         pretrained models please see the `Models Hub
         `__.
     
@@ -108,7 +108,7 @@ class LLAMA3Transformer(AnnotatorModel, HasBatchedAnnotate, HasEngine):
         >>> documentAssembler = DocumentAssembler() \\
         ...     .setInputCol("text") \\
         ...     .setOutputCol("documents")
-        >>> llama3 = LLAMA3Transformer.pretrained("llama_3_7b_chat_hf_int8") \\
+        >>> llama3 = LLAMA3Transformer.pretrained("llama_3_7b_chat_hf_int4") \\
         ...     .setInputCols(["documents"]) \\
         ...     .setMaxOutputLength(60) \\
         ...     .setOutputCol("generation")
@@ -365,7 +365,7 @@ def pretrained(name="llama_3_7b_chat_hf_int4", lang="en", remote_loc=None):
         Parameters
         ----------
         name : str, optional
-            Name of the pretrained model, by default "llama_2_7b_chat_hf_int4"
+            Name of the pretrained model, by default "llama_3_7b_chat_hf_int4"
         lang : str, optional
             Language of the pretrained model, by default "en"
         remote_loc : str, optional
diff --git a/python/sparknlp/annotator/seq2seq/olmo_transformer.py b/python/sparknlp/annotator/seq2seq/olmo_transformer.py
new file mode 100644
index 00000000000000..eb1b63d71cdcf1
--- /dev/null
+++ b/python/sparknlp/annotator/seq2seq/olmo_transformer.py
@@ -0,0 +1,326 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the OLMoTransformer."""
+
+from sparknlp.common import *
+
+
+class OLMoTransformer(AnnotatorModel, HasBatchedAnnotate, HasEngine):
+    """OLMo: Open Language Models
+
+    OLMo is a series of Open Language Models designed to enable the science of language models.
+    The OLMo models are trained on the Dolma dataset. We release all code, checkpoints, logs
+    (coming soon), and details involved in training these models.
+
+    Pretrained models can be loaded with :meth:`.pretrained` of the companion
+    object:
+
+    >>> olmo = OLMoTransformer.pretrained() \\
+    ...     .setInputCols(["document"]) \\
+    ...     .setOutputCol("generation")
+
+
+    The default model is ``"olmo_1b_int4"``, if no name is provided. For available
+    pretrained models please see the `Models Hub
+    `__.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``DOCUMENT``           ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    configProtoBytes
+        ConfigProto from tensorflow, serialized into byte array.
+    minOutputLength
+        Minimum length of the sequence to be generated, by default 0
+    maxOutputLength
+        Maximum length of output text, by default 20
+    doSample
+        Whether or not to use sampling; use greedy decoding otherwise, by default False
+    temperature
+        The value used to module the next token probabilities, by default 1.0
+    topK
+        The number of highest probability vocabulary tokens to keep for
+        top-k-filtering, by default 50
+    topP
+        Top cumulative probability for vocabulary tokens, by default 1.0
+
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
+    repetitionPenalty
+        The parameter for repetition penalty, 1.0 means no penalty. , by default
+        1.0
+    noRepeatNgramSize
+        If set to int > 0, all ngrams of that size can only occur once, by
+        default 0
+    ignoreTokenIds
+        A list of token ids which are ignored in the decoder's output, by
+        default []
+
+    Notes
+    -----
+    This is a very computationally expensive module especially on larger
+    sequence. The use of an accelerator such as GPU is recommended.
+
+    References
+    ----------
+    - `OLMo Project Page.
+      `__
+    - `OLMO GitHub Repository.
+      `__
+    - `OLMo: Accelerating the Science of Language Models
+      `__
+
+    **Paper Abstract:**
+
+    *Language models (LMs) have become ubiquitous in both NLP research and in commercial product offerings.
+    As their commercial importance has surged, the most powerful models have become closed off, gated behind
+    proprietary interfaces, with important details of their training data, architectures, and development
+    undisclosed. Given the importance of these details in scientifically studying these models, including
+    their biases and potential risks, we believe it is essential for the research community to have access
+    to powerful, truly open LMs. To this end, this technical report details the first release of OLMo,
+    a state-of-the-art, truly Open Language Model and its framework to build and study the science of
+    language modeling. Unlike most prior efforts that have only released model weights and inference code,
+    we release OLMo and the whole framework, including training data and training and evaluation code.
+    We hope this release will empower and strengthen the open research community and inspire a new wave
+    of innovation.*
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> documentAssembler = DocumentAssembler() \\
+    ...     .setInputCol("text") \\
+    ...     .setOutputCol("documents")
+    >>> olmo = OLMoTransformer.pretrained("olmo-7b") \\
+    ...     .setInputCols(["documents"]) \\
+    ...     .setMaxOutputLength(50) \\
+    ...     .setOutputCol("generation")
+    >>> pipeline = Pipeline().setStages([documentAssembler, olmo])
+    >>> data = spark.createDataFrame([["My name is Leonardo."]]).toDF("text")
+    >>> result = pipeline.fit(data).transform(data)
+    >>> result.select("summaries.generation").show(truncate=False)
+    +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |result                                                                                                                                                                                              |
+    +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |[My name is Leonardo . I am a student of the University of California, Berkeley. I am interested in the field of Artificial Intelligence and its applications in the real world. I have a strong    |
+    | passion for learning and am always looking for ways to improve my knowledge and skills]                                                                                                            |
+    -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    """
+
+    name = "OLMoTransformer"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT]
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    configProtoBytes = Param(Params._dummy(), "configProtoBytes",
+                             "ConfigProto from tensorflow, serialized into byte array. Get with config_proto.SerializeToString()",
+                             TypeConverters.toListInt)
+
+    minOutputLength = Param(Params._dummy(), "minOutputLength", "Minimum length of the sequence to be generated",
+                            typeConverter=TypeConverters.toInt)
+
+    maxOutputLength = Param(Params._dummy(), "maxOutputLength", "Maximum length of output text",
+                            typeConverter=TypeConverters.toInt)
+
+    doSample = Param(Params._dummy(), "doSample", "Whether or not to use sampling; use greedy decoding otherwise",
+                     typeConverter=TypeConverters.toBoolean)
+
+    temperature = Param(Params._dummy(), "temperature", "The value used to module the next token probabilities",
+                        typeConverter=TypeConverters.toFloat)
+
+    topK = Param(Params._dummy(), "topK",
+                 "The number of highest probability vocabulary tokens to keep for top-k-filtering",
+                 typeConverter=TypeConverters.toInt)
+
+    topP = Param(Params._dummy(), "topP",
+                 "If set to float < 1, only the most probable tokens with probabilities that add up to ``top_p`` or higher are kept for generation",
+                 typeConverter=TypeConverters.toFloat)
+
+    repetitionPenalty = Param(Params._dummy(), "repetitionPenalty",
+                              "The parameter for repetition penalty. 1.0 means no penalty. See `this paper `__ for more details",
+                              typeConverter=TypeConverters.toFloat)
+
+    noRepeatNgramSize = Param(Params._dummy(), "noRepeatNgramSize",
+                              "If set to int > 0, all ngrams of that size can only occur once",
+                              typeConverter=TypeConverters.toInt)
+
+    ignoreTokenIds = Param(Params._dummy(), "ignoreTokenIds",
+                           "A list of token ids which are ignored in the decoder's output",
+                           typeConverter=TypeConverters.toListInt)
+
+    def setIgnoreTokenIds(self, value):
+        """A list of token ids which are ignored in the decoder's output.
+
+        Parameters
+        ----------
+        value : List[int]
+            The words to be filtered out
+        """
+        return self._set(ignoreTokenIds=value)
+
+    def setConfigProtoBytes(self, b):
+        """Sets configProto from tensorflow, serialized into byte array.
+
+        Parameters
+        ----------
+        b : List[int]
+            ConfigProto from tensorflow, serialized into byte array
+        """
+        return self._set(configProtoBytes=b)
+
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
+
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
+
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
+
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
+
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
+
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
+
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
+
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
+
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
+
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
+
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
+
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
+
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
+
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
+
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
+
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation `__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
+
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
+
+        If set to int > 0, all ngrams of that size can only occur once.
+
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.seq2seq.OLMoTransformer", java_model=None):
+        super(OLMoTransformer, self).__init__(classname=classname, java_model=java_model)
+        self._setDefault(minOutputLength=0, maxOutputLength=20, doSample=False, temperature=0.6, topK=50, topP=0.9,
+                         repetitionPenalty=1.0, noRepeatNgramSize=0, ignoreTokenIds=[], batchSize=1)
+
+    @staticmethod
+    def loadSavedModel(folder, spark_session):
+        """Loads a locally saved model.
+
+        Parameters
+        ----------
+        folder : str
+            Folder of the saved model
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        OLMoTransformer
+            The restored model
+        """
+        from sparknlp.internal import _OLMoLoader
+        jModel = _OLMoLoader(folder, spark_session._jsparkSession)._java_obj
+        return OLMoTransformer(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="olmo_1b_int4", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default "olmo-7b"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        OLMoTransformer
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(OLMoTransformer, name, lang, remote_loc)
diff --git a/python/sparknlp/base/image_assembler.py b/python/sparknlp/base/image_assembler.py
index cc8a9eb8c91253..61d4a283cdbb60 100644
--- a/python/sparknlp/base/image_assembler.py
+++ b/python/sparknlp/base/image_assembler.py
@@ -15,6 +15,8 @@
 
 from pyspark import keyword_only
 from pyspark.ml.param import TypeConverters, Params, Param
+from pyspark.sql import SparkSession, DataFrame
+from pyspark.sql.functions import regexp_replace, col
 
 from sparknlp.common import AnnotatorType
 from sparknlp.internal import AnnotatorTransformer
@@ -112,3 +114,59 @@ def setTextCol(self, value):
             Name of an optional input text column
         """
         return self._set(inputCol=value)
+
+    @classmethod
+    def loadImagesAsBytes(cls, spark: SparkSession, path: str):
+        """
+        Loads images from a given path and returns them as raw bytes, instead of the default
+        OpenCV-compatible format. Supported image types include JPEG, PNG, GIF, and BMP.
+
+        Multimodal inference with llama.cpp requires raw bytes as input.
+
+        Parameters
+        ----------
+        spark : SparkSession
+            The active SparkSession.
+        path : str
+            The path to the images. Supported image types are JPEG, PNG, GIF, and BMP.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the images as raw bytes along with their metadata.
+        """
+
+        # Replace the path separator in the `origin` field and `path` column, so that they match
+        def replace_path(column_name: str):
+            return regexp_replace(col(column_name), ":///", ":/")
+
+        # Load the images as metadata with the default Spark image format
+        data = (
+            spark.read.format("image")
+            .option("dropInvalid", True)
+            .load(path)
+            .withColumn(
+                "image", col("image").withField("origin", replace_path("image.origin"))
+            )
+        )
+
+        # Load the images as raw binary files
+        image_bytes = (
+            spark.read.format("binaryFile")
+            .option("pathGlobFilter", "*.{jpeg,jpg,png,gif,bmp,JPEG,JPG,PNG,GIF,BMP}")
+            .option("dropInvalid", True)
+            .load(path)
+            .withColumn("path", replace_path("path"))
+        )
+
+        # Join the two datasets on the file path
+        df_joined = data.join(
+            image_bytes, data["image.origin"] == image_bytes["path"], "inner"
+        )
+
+        # Replace the `data` field of the `image` column with raw bytes
+        df_image_replaced = df_joined.withColumn(
+            "image", df_joined["image"].withField("data", df_joined["content"])
+        )
+
+        return df_image_replaced
diff --git a/python/sparknlp/common/properties.py b/python/sparknlp/common/properties.py
index ba6cb094a91d31..f6d9a1ec94d313 100644
--- a/python/sparknlp/common/properties.py
+++ b/python/sparknlp/common/properties.py
@@ -12,6 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 """Contains classes for Annotator properties."""
+from typing import List, Dict
 
 from pyspark.ml.param import Param, Params, TypeConverters
 
@@ -628,133 +629,641 @@ class HasGeneratorProperties:
                              typeConverter=TypeConverters.toInt)
 
 
-def setTask(self, value):
-    """Sets the transformer's task, e.g. ``summarize:``.
+    def setTask(self, value):
+        """Sets the transformer's task, e.g. ``summarize:``.
 
-    Parameters
-    ----------
-    value : str
-        The transformer's task
-    """
-    return self._set(task=value)
+        Parameters
+        ----------
+        value : str
+            The transformer's task
+        """
+        return self._set(task=value)
 
 
-def setMinOutputLength(self, value):
-    """Sets minimum length of the sequence to be generated.
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
 
-    Parameters
-    ----------
-    value : int
-        Minimum length of the sequence to be generated
-    """
-    return self._set(minOutputLength=value)
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
 
 
-def setMaxOutputLength(self, value):
-    """Sets maximum length of output text.
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
 
-    Parameters
-    ----------
-    value : int
-        Maximum length of output text
-    """
-    return self._set(maxOutputLength=value)
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
 
 
-def setDoSample(self, value):
-    """Sets whether or not to use sampling, use greedy decoding otherwise.
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
 
-    Parameters
-    ----------
-    value : bool
-        Whether or not to use sampling; use greedy decoding otherwise
-    """
-    return self._set(doSample=value)
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
 
 
-def setTemperature(self, value):
-    """Sets the value used to module the next token probabilities.
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
 
-    Parameters
-    ----------
-    value : float
-        The value used to module the next token probabilities
-    """
-    return self._set(temperature=value)
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
 
 
-def setTopK(self, value):
-    """Sets the number of highest probability vocabulary tokens to keep for
-    top-k-filtering.
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
 
-    Parameters
-    ----------
-    value : int
-        Number of highest probability vocabulary tokens to keep
-    """
-    return self._set(topK=value)
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
 
 
-def setTopP(self, value):
-    """Sets the top cumulative probability for vocabulary tokens.
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
 
-    If set to float < 1, only the most probable tokens with probabilities
-    that add up to ``topP`` or higher are kept for generation.
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
 
-    Parameters
-    ----------
-    value : float
-        Cumulative probability for vocabulary tokens
-    """
-    return self._set(topP=value)
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
 
 
-def setRepetitionPenalty(self, value):
-    """Sets the parameter for repetition penalty. 1.0 means no penalty.
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
 
-    Parameters
-    ----------
-    value : float
-        The repetition penalty
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
 
-    References
-    ----------
-    See `Ctrl: A Conditional Transformer Language Model For Controllable
-    Generation `__ for more details.
-    """
-    return self._set(repetitionPenalty=value)
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation `__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
 
 
-def setNoRepeatNgramSize(self, value):
-    """Sets size of n-grams that can only occur once.
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
 
-    If set to int > 0, all ngrams of that size can only occur once.
+        If set to int > 0, all ngrams of that size can only occur once.
 
-    Parameters
-    ----------
-    value : int
-        N-gram size can only occur once
-    """
-    return self._set(noRepeatNgramSize=value)
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
+
+
+    def setBeamSize(self, value):
+        """Sets the number of beam size for beam search.
+
+        Parameters
+        ----------
+        value : int
+            Number of beam size for beam search
+        """
+        return self._set(beamSize=value)
+
+
+    def setNReturnSequences(self, value):
+        """Sets the number of sequences to return from the beam search.
+
+        Parameters
+        ----------
+        value : int
+            Number of sequences to return
+        """
+        return self._set(nReturnSequences=value)
+
+
+class HasLlamaCppProperties:
+    # -------- MODEl PARAMETERS --------
+    nThreads = Param(Params._dummy(), "nThreads", "Set the number of threads to use during generation",
+                     typeConverter=TypeConverters.toInt)
+    nThreadsDraft = Param(Params._dummy(), "nThreadsDraft", "Set the number of threads to use during draft generation",
+                          typeConverter=TypeConverters.toInt)
+    nThreadsBatch = Param(Params._dummy(), "nThreadsBatch",
+                          "Set the number of threads to use during batch and prompt processing",
+                          typeConverter=TypeConverters.toInt)
+    nThreadsBatchDraft = Param(Params._dummy(), "nThreadsBatchDraft",
+                               "Set the number of threads to use during batch and prompt processing",
+                               typeConverter=TypeConverters.toInt)
+    nCtx = Param(Params._dummy(), "nCtx", "Set the size of the prompt context", typeConverter=TypeConverters.toInt)
+    nBatch = Param(Params._dummy(), "nBatch",
+                   "Set the logical batch size for prompt processing (must be >=32 to use BLAS)",
+                   typeConverter=TypeConverters.toInt)
+    nUbatch = Param(Params._dummy(), "nUbatch",
+                    "Set the physical batch size for prompt processing (must be >=32 to use BLAS)",
+                    typeConverter=TypeConverters.toInt)
+    nDraft = Param(Params._dummy(), "nDraft", "Set the number of tokens to draft for speculative decoding",
+                   typeConverter=TypeConverters.toInt)
+    nChunks = Param(Params._dummy(), "nChunks", "Set the maximal number of chunks to process",
+                    typeConverter=TypeConverters.toInt)
+    nSequences = Param(Params._dummy(), "nSequences", "Set the number of sequences to decode",
+                       typeConverter=TypeConverters.toInt)
+    pSplit = Param(Params._dummy(), "pSplit", "Set the speculative decoding split probability",
+                   typeConverter=TypeConverters.toFloat)
+    nGpuLayers = Param(Params._dummy(), "nGpuLayers", "Set the number of layers to store in VRAM (-1 - use default)",
+                       typeConverter=TypeConverters.toInt)
+    nGpuLayersDraft = Param(Params._dummy(), "nGpuLayersDraft",
+                            "Set the number of layers to store in VRAM for the draft model (-1 - use default)",
+                            typeConverter=TypeConverters.toInt)
+    # Set how to split the model across GPUs
+    #
+    #   - NONE: No GPU split
+    #   - LAYER: Split the model across GPUs by layer
+    #   - ROW: Split the model across GPUs by rows
+    gpuSplitMode = Param(Params._dummy(), "gpuSplitMode", "Set how to split the model across GPUs",
+                         typeConverter=TypeConverters.toString)
+    mainGpu = Param(Params._dummy(), "mainGpu", "Set the main GPU that is used for scratch and small tensors.",
+                    typeConverter=TypeConverters.toInt)
+    tensorSplit = Param(Params._dummy(), "tensorSplit", "Set how split tensors should be distributed across GPUs",
+                        typeConverter=TypeConverters.toListFloat)
+    grpAttnN = Param(Params._dummy(), "grpAttnN", "Set the group-attention factor", typeConverter=TypeConverters.toInt)
+    grpAttnW = Param(Params._dummy(), "grpAttnW", "Set the group-attention width", typeConverter=TypeConverters.toInt)
+    ropeFreqBase = Param(Params._dummy(), "ropeFreqBase", "Set the RoPE base frequency, used by NTK-aware scaling",
+                         typeConverter=TypeConverters.toFloat)
+    ropeFreqScale = Param(Params._dummy(), "ropeFreqScale",
+                          "Set the RoPE frequency scaling factor, expands context by a factor of 1/N",
+                          typeConverter=TypeConverters.toFloat)
+    yarnExtFactor = Param(Params._dummy(), "yarnExtFactor", "Set the YaRN extrapolation mix factor",
+                          typeConverter=TypeConverters.toFloat)
+    yarnAttnFactor = Param(Params._dummy(), "yarnAttnFactor", "Set the YaRN scale sqrt(t) or attention magnitude",
+                           typeConverter=TypeConverters.toFloat)
+    yarnBetaFast = Param(Params._dummy(), "yarnBetaFast", "Set the YaRN low correction dim or beta",
+                         typeConverter=TypeConverters.toFloat)
+    yarnBetaSlow = Param(Params._dummy(), "yarnBetaSlow", "Set the YaRN high correction dim or alpha",
+                         typeConverter=TypeConverters.toFloat)
+    yarnOrigCtx = Param(Params._dummy(), "yarnOrigCtx", "Set the YaRN original context size of model",
+                        typeConverter=TypeConverters.toInt)
+    defragmentationThreshold = Param(Params._dummy(), "defragmentationThreshold",
+                                     "Set the KV cache defragmentation threshold", typeConverter=TypeConverters.toFloat)
+    # Set optimization strategies that help on some NUMA systems (if available)
+    #
+    # Available Strategies:
+    #
+    #   - DISABLED: No NUMA optimizations
+    #   - DISTRIBUTE: Spread execution evenly over all
+    #   - ISOLATE: Only spawn threads on CPUs on the node that execution started on
+    #   - NUMA_CTL: Use the CPU map provided by numactl
+    #   - MIRROR: Mirrors the model across NUMA nodes
+    numaStrategy = Param(Params._dummy(), "numaStrategy",
+                         "Set optimization strategies that help on some NUMA systems (if available)",
+                         typeConverter=TypeConverters.toString)
+    # Set the RoPE frequency scaling method, defaults to linear unless specified by the model.
+    #
+    #   - UNSPECIFIED: Don't use any scaling
+    #   - LINEAR: Linear scaling
+    #   - YARN: YaRN RoPE scaling
+    ropeScalingType = Param(Params._dummy(), "ropeScalingType",
+                            "Set the RoPE frequency scaling method, defaults to linear unless specified by the model",
+                            typeConverter=TypeConverters.toString)
+    # Set the pooling type for embeddings, use model default if unspecified
+    #
+    #   - 0 NONE: Don't use any pooling
+    #   - 1 MEAN: Mean Pooling
+    #   - 2 CLS: CLS Pooling
+    poolingType = Param(Params._dummy(), "poolingType",
+                        "Set the pooling type for embeddings, use model default if unspecified",
+                        typeConverter=TypeConverters.toString)
+    modelDraft = Param(Params._dummy(), "modelDraft", "Set the draft model for speculative decoding",
+                       typeConverter=TypeConverters.toString)
+    modelAlias = Param(Params._dummy(), "modelAlias", "Set a model alias", typeConverter=TypeConverters.toString)
+    lookupCacheStaticFilePath = Param(Params._dummy(), "lookupCacheStaticFilePath",
+                                      "Set path to static lookup cache to use for lookup decoding (not updated by generation)",
+                                      typeConverter=TypeConverters.toString)
+    lookupCacheDynamicFilePath = Param(Params._dummy(), "lookupCacheDynamicFilePath",
+                                       "Set path to dynamic lookup cache to use for lookup decoding (updated by generation)",
+                                       typeConverter=TypeConverters.toString)
+    # loraAdapters = new StructFeature[Map[String, Float]](this, "loraAdapters")
+    embedding = Param(Params._dummy(), "embedding", "Whether to load model with embedding support",
+                      typeConverter=TypeConverters.toBoolean)
+    flashAttention = Param(Params._dummy(), "flashAttention", "Whether to enable Flash Attention",
+                           typeConverter=TypeConverters.toBoolean)
+    inputPrefixBos = Param(Params._dummy(), "inputPrefixBos",
+                           "Whether to add prefix BOS to user inputs, preceding the `--in-prefix` string",
+                           typeConverter=TypeConverters.toBoolean)
+    useMmap = Param(Params._dummy(), "useMmap",
+                    "Whether to use memory-map model (faster load but may increase pageouts if not using mlock)",
+                    typeConverter=TypeConverters.toBoolean)
+    useMlock = Param(Params._dummy(), "useMlock",
+                     "Whether to force the system to keep model in RAM rather than swapping or compressing",
+                     typeConverter=TypeConverters.toBoolean)
+    noKvOffload = Param(Params._dummy(), "noKvOffload", "Whether to disable KV offload",
+                        typeConverter=TypeConverters.toBoolean)
+    systemPrompt = Param(Params._dummy(), "systemPrompt", "Set a system prompt to use",
+                         typeConverter=TypeConverters.toString)
+    chatTemplate = Param(Params._dummy(), "chatTemplate", "The chat template to use",
+                         typeConverter=TypeConverters.toString)
+
+    # -------- INFERENCE PARAMETERS --------
+    inputPrefix = Param(Params._dummy(), "inputPrefix", "Set the prompt to start generation with",
+                        typeConverter=TypeConverters.toString)
+    inputSuffix = Param(Params._dummy(), "inputSuffix", "Set a suffix for infilling",
+                        typeConverter=TypeConverters.toString)
+    cachePrompt = Param(Params._dummy(), "cachePrompt", "Whether to remember the prompt to avoid reprocessing it",
+                        typeConverter=TypeConverters.toBoolean)
+    nPredict = Param(Params._dummy(), "nPredict", "Set the number of tokens to predict",
+                     typeConverter=TypeConverters.toInt)
+    topK = Param(Params._dummy(), "topK", "Set top-k sampling", typeConverter=TypeConverters.toInt)
+    topP = Param(Params._dummy(), "topP", "Set top-p sampling", typeConverter=TypeConverters.toFloat)
+    minP = Param(Params._dummy(), "minP", "Set min-p sampling", typeConverter=TypeConverters.toFloat)
+    tfsZ = Param(Params._dummy(), "tfsZ", "Set tail free sampling, parameter z", typeConverter=TypeConverters.toFloat)
+    typicalP = Param(Params._dummy(), "typicalP", "Set locally typical sampling, parameter p",
+                     typeConverter=TypeConverters.toFloat)
+    temperature = Param(Params._dummy(), "temperature", "Set the temperature", typeConverter=TypeConverters.toFloat)
+    dynamicTemperatureRange = Param(Params._dummy(), "dynatempRange", "Set the dynamic temperature range",
+                                    typeConverter=TypeConverters.toFloat)
+    dynamicTemperatureExponent = Param(Params._dummy(), "dynatempExponent", "Set the dynamic temperature exponent",
+                                       typeConverter=TypeConverters.toFloat)
+    repeatLastN = Param(Params._dummy(), "repeatLastN", "Set the last n tokens to consider for penalties",
+                        typeConverter=TypeConverters.toInt)
+    repeatPenalty = Param(Params._dummy(), "repeatPenalty", "Set the penalty of repeated sequences of tokens",
+                          typeConverter=TypeConverters.toFloat)
+    frequencyPenalty = Param(Params._dummy(), "frequencyPenalty", "Set the repetition alpha frequency penalty",
+                             typeConverter=TypeConverters.toFloat)
+    presencePenalty = Param(Params._dummy(), "presencePenalty", "Set the repetition alpha presence penalty",
+                            typeConverter=TypeConverters.toFloat)
+    miroStat = Param(Params._dummy(), "miroStat", "Set MiroStat sampling strategies.",
+                     typeConverter=TypeConverters.toString)
+    miroStatTau = Param(Params._dummy(), "mirostatTau", "Set the MiroStat target entropy, parameter tau",
+                        typeConverter=TypeConverters.toFloat)
+    miroStatEta = Param(Params._dummy(), "mirostatEta", "Set the MiroStat learning rate, parameter eta",
+                        typeConverter=TypeConverters.toFloat)
+    penalizeNl = Param(Params._dummy(), "penalizeNl", "Whether to penalize newline tokens",
+                       typeConverter=TypeConverters.toBoolean)
+    nKeep = Param(Params._dummy(), "nKeep", "Set the number of tokens to keep from the initial prompt",
+                  typeConverter=TypeConverters.toInt)
+    seed = Param(Params._dummy(), "seed", "Set the RNG seed", typeConverter=TypeConverters.toInt)
+    nProbs = Param(Params._dummy(), "nProbs", "Set the amount top tokens probabilities to output if greater than 0.",
+                   typeConverter=TypeConverters.toInt)
+    minKeep = Param(Params._dummy(), "minKeep",
+                    "Set the amount of tokens the samplers should return at least (0 = disabled)",
+                    typeConverter=TypeConverters.toInt)
+    grammar = Param(Params._dummy(), "grammar", "Set BNF-like grammar to constrain generations",
+                    typeConverter=TypeConverters.toString)
+    penaltyPrompt = Param(Params._dummy(), "penaltyPrompt",
+                          "Override which part of the prompt is penalized for repetition.",
+                          typeConverter=TypeConverters.toString)
+    ignoreEos = Param(Params._dummy(), "ignoreEos",
+                      "Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)",
+                      typeConverter=TypeConverters.toBoolean)
+    disableTokenIds = Param(Params._dummy(), "disableTokenIds", "Set the token ids to disable in the completion",
+                            typeConverter=TypeConverters.toListInt)
+    stopStrings = Param(Params._dummy(), "stopStrings", "Set strings upon seeing which token generation is stopped",
+                        typeConverter=TypeConverters.toListString)
+    samplers = Param(Params._dummy(), "samplers", "Set which samplers to use for token generation in the given order",
+                     typeConverter=TypeConverters.toListString)
+    useChatTemplate = Param(Params._dummy(), "useChatTemplate",
+                            "Set whether or not generate should apply a chat template",
+                            typeConverter=TypeConverters.toBoolean)
+
+    # -------- MODEL SETTERS --------
+    def setNThreads(self, nThreads: int):
+        """Set the number of threads to use during generation"""
+        return self._set(nThreads=nThreads)
+
+    def setNThreadsDraft(self, nThreadsDraft: int):
+        """Set the number of threads to use during draft generation"""
+        return self._set(nThreadsDraft=nThreadsDraft)
+
+    def setNThreadsBatch(self, nThreadsBatch: int):
+        """Set the number of threads to use during batch and prompt processing"""
+        return self._set(nThreadsBatch=nThreadsBatch)
+
+    def setNThreadsBatchDraft(self, nThreadsBatchDraft: int):
+        """Set the number of threads to use during batch and prompt processing"""
+        return self._set(nThreadsBatchDraft=nThreadsBatchDraft)
+
+    def setNCtx(self, nCtx: int):
+        """Set the size of the prompt context"""
+        return self._set(nCtx=nCtx)
+
+    def setNBatch(self, nBatch: int):
+        """Set the logical batch size for prompt processing (must be >=32 to use BLAS)"""
+        return self._set(nBatch=nBatch)
+
+    def setNUbatch(self, nUbatch: int):
+        """Set the physical batch size for prompt processing (must be >=32 to use BLAS)"""
+        return self._set(nUbatch=nUbatch)
+
+    def setNDraft(self, nDraft: int):
+        """Set the number of tokens to draft for speculative decoding"""
+        return self._set(nDraft=nDraft)
+
+    def setNChunks(self, nChunks: int):
+        """Set the maximal number of chunks to process"""
+        return self._set(nChunks=nChunks)
+
+    def setNSequences(self, nSequences: int):
+        """Set the number of sequences to decode"""
+        return self._set(nSequences=nSequences)
+
+    def setPSplit(self, pSplit: float):
+        """Set the speculative decoding split probability"""
+        return self._set(pSplit=pSplit)
+
+    def setNGpuLayers(self, nGpuLayers: int):
+        """Set the number of layers to store in VRAM (-1 - use default)"""
+        return self._set(nGpuLayers=nGpuLayers)
+
+    def setNGpuLayersDraft(self, nGpuLayersDraft: int):
+        """Set the number of layers to store in VRAM for the draft model (-1 - use default)"""
+        return self._set(nGpuLayersDraft=nGpuLayersDraft)
+
+    def setGpuSplitMode(self, gpuSplitMode: str):
+        """Set how to split the model across GPUs"""
+        return self._set(gpuSplitMode=gpuSplitMode)
+
+    def setMainGpu(self, mainGpu: int):
+        """Set the main GPU that is used for scratch and small tensors."""
+        return self._set(mainGpu=mainGpu)
+
+    def setTensorSplit(self, tensorSplit: List[float]):
+        """Set how split tensors should be distributed across GPUs"""
+        return self._set(tensorSplit=tensorSplit)
+
+    def setGrpAttnN(self, grpAttnN: int):
+        """Set the group-attention factor"""
+        return self._set(grpAttnN=grpAttnN)
+
+    def setGrpAttnW(self, grpAttnW: int):
+        """Set the group-attention width"""
+        return self._set(grpAttnW=grpAttnW)
+
+    def setRopeFreqBase(self, ropeFreqBase: float):
+        """Set the RoPE base frequency, used by NTK-aware scaling"""
+        return self._set(ropeFreqBase=ropeFreqBase)
+
+    def setRopeFreqScale(self, ropeFreqScale: float):
+        """Set the RoPE frequency scaling factor, expands context by a factor of 1/N"""
+        return self._set(ropeFreqScale=ropeFreqScale)
+
+    def setYarnExtFactor(self, yarnExtFactor: float):
+        """Set the YaRN extrapolation mix factor"""
+        return self._set(yarnExtFactor=yarnExtFactor)
+
+    def setYarnAttnFactor(self, yarnAttnFactor: float):
+        """Set the YaRN scale sqrt(t) or attention magnitude"""
+        return self._set(yarnAttnFactor=yarnAttnFactor)
+
+    def setYarnBetaFast(self, yarnBetaFast: float):
+        """Set the YaRN low correction dim or beta"""
+        return self._set(yarnBetaFast=yarnBetaFast)
+
+    def setYarnBetaSlow(self, yarnBetaSlow: float):
+        """Set the YaRN high correction dim or alpha"""
+        return self._set(yarnBetaSlow=yarnBetaSlow)
+
+    def setYarnOrigCtx(self, yarnOrigCtx: int):
+        """Set the YaRN original context size of model"""
+        return self._set(yarnOrigCtx=yarnOrigCtx)
+
+    def setDefragmentationThreshold(self, defragmentationThreshold: float):
+        """Set the KV cache defragmentation threshold"""
+        return self._set(defragmentationThreshold=defragmentationThreshold)
 
+    def setNumaStrategy(self, numaStrategy: str):
+        """Set optimization strategies that help on some NUMA systems (if available)"""
+        numaUpper = numaStrategy.upper()
+        numaStrategies = ["DISABLED", "DISTRIBUTE", "ISOLATE", "NUMA_CTL", "MIRROR"]
+        if numaUpper not in numaStrategies:
+            raise ValueError(
+                f"Invalid NUMA strategy: {numaUpper}. "
+                + f"Valid values are: {numaStrategies}"
+            )
+        return self._set(numaStrategy=numaStrategy)
+
+    def setRopeScalingType(self, ropeScalingType: str):
+        """Set the RoPE frequency scaling method, defaults to linear unless specified by the model"""
+        return self._set(ropeScalingType=ropeScalingType)
+
+    def setPoolingType(self, poolingType: str):
+        """Set the pooling type for embeddings, use model default if unspecified"""
+        poolingTypeUpper = poolingType.upper()
+        poolingTypes = ["NONE", "MEAN", "CLS", "LAST"]
+        if poolingTypeUpper not in poolingTypes:
+            raise ValueError(
+                f"Invalid pooling type: {poolingType}. "
+                + f"Valid values are: {poolingTypes}"
+            )
+        return self._set(poolingType=poolingType)
+
+    def setModelDraft(self, modelDraft: str):
+        """Set the draft model for speculative decoding"""
+        return self._set(modelDraft=modelDraft)
+
+    def setModelAlias(self, modelAlias: str):
+        """Set a model alias"""
+        return self._set(modelAlias=modelAlias)
+
+    def setLookupCacheStaticFilePath(self, lookupCacheStaticFilePath: str):
+        """Set path to static lookup cache to use for lookup decoding (not updated by generation)"""
+        return self._set(lookupCacheStaticFilePath=lookupCacheStaticFilePath)
+
+    def setLookupCacheDynamicFilePath(self, lookupCacheDynamicFilePath: str):
+        """Set path to dynamic lookup cache to use for lookup decoding (updated by generation)"""
+        return self._set(lookupCacheDynamicFilePath=lookupCacheDynamicFilePath)
+
+    def setEmbedding(self, embedding: bool):
+        """Whether to load model with embedding support"""
+        return self._set(embedding=embedding)
+
+    def setFlashAttention(self, flashAttention: bool):
+        """Whether to enable Flash Attention"""
+        return self._set(flashAttention=flashAttention)
+
+    def setInputPrefixBos(self, inputPrefixBos: bool):
+        """Whether to add prefix BOS to user inputs, preceding the `--in-prefix` bool"""
+        return self._set(inputPrefixBos=inputPrefixBos)
+
+    def setUseMmap(self, useMmap: bool):
+        """Whether to use memory-map model (faster load but may increase pageouts if not using mlock)"""
+        return self._set(useMmap=useMmap)
+
+    def setUseMlock(self, useMlock: bool):
+        """Whether to force the system to keep model in RAM rather than swapping or compressing"""
+        return self._set(useMlock=useMlock)
+
+    def setNoKvOffload(self, noKvOffload: bool):
+        """Whether to disable KV offload"""
+        return self._set(noKvOffload=noKvOffload)
+
+    def setSystemPrompt(self, systemPrompt: bool):
+        """Set a system prompt to use"""
+        return self._set(systemPrompt=systemPrompt)
+
+    def setChatTemplate(self, chatTemplate: str):
+        """The chat template to use"""
+        return self._set(chatTemplate=chatTemplate)
+
+    # -------- INFERENCE SETTERS --------
+    def setInputPrefix(self, inputPrefix: str):
+        """Set the prompt to start generation with"""
+        return self._set(inputPrefix=inputPrefix)
 
-def setBeamSize(self, value):
-    """Sets the number of beam size for beam search.
+    def setInputSuffix(self, inputSuffix: str):
+        """Set a suffix for infilling"""
+        return self._set(inputSuffix=inputSuffix)
 
-    Parameters
-    ----------
-    value : int
-        Number of beam size for beam search
-    """
-    return self._set(beamSize=value)
+    def setCachePrompt(self, cachePrompt: bool):
+        """Whether to remember the prompt to avoid reprocessing it"""
+        return self._set(cachePrompt=cachePrompt)
 
+    def setNPredict(self, nPredict: int):
+        """Set the number of tokens to predict"""
+        return self._set(nPredict=nPredict)
 
-def setNReturnSequences(self, value):
-    """Sets the number of sequences to return from the beam search.
+    def setTopK(self, topK: int):
+        """Set top-k sampling"""
+        return self._set(topK=topK)
 
-    Parameters
-    ----------
-    value : int
-        Number of sequences to return
-    """
-    return self._set(nReturnSequences=value)
+    def setTopP(self, topP: float):
+        """Set top-p sampling"""
+        return self._set(topP=topP)
+
+    def setMinP(self, minP: float):
+        """Set min-p sampling"""
+        return self._set(minP=minP)
+
+    def setTfsZ(self, tfsZ: float):
+        """Set tail free sampling, parameter z"""
+        return self._set(tfsZ=tfsZ)
+
+    def setTypicalP(self, typicalP: float):
+        """Set locally typical sampling, parameter p"""
+        return self._set(typicalP=typicalP)
+
+    def setTemperature(self, temperature: float):
+        """Set the temperature"""
+        return self._set(temperature=temperature)
+
+    def setDynamicTemperatureRange(self, dynamicTemperatureRange: float):
+        """Set the dynamic temperature range"""
+        return self._set(dynamicTemperatureRange=dynamicTemperatureRange)
+
+    def setDynamicTemperatureExponent(self, dynamicTemperatureExponent: float):
+        """Set the dynamic temperature exponent"""
+        return self._set(dynamicTemperatureExponent=dynamicTemperatureExponent)
+
+    def setRepeatLastN(self, repeatLastN: int):
+        """Set the last n tokens to consider for penalties"""
+        return self._set(repeatLastN=repeatLastN)
+
+    def setRepeatPenalty(self, repeatPenalty: float):
+        """Set the penalty of repeated sequences of tokens"""
+        return self._set(repeatPenalty=repeatPenalty)
+
+    def setFrequencyPenalty(self, frequencyPenalty: float):
+        """Set the repetition alpha frequency penalty"""
+        return self._set(frequencyPenalty=frequencyPenalty)
+
+    def setPresencePenalty(self, presencePenalty: float):
+        """Set the repetition alpha presence penalty"""
+        return self._set(presencePenalty=presencePenalty)
+
+    def setMiroStat(self, miroStat: str):
+        """Set MiroStat sampling strategies."""
+        return self._set(miroStat=miroStat)
+
+    def setMiroStatTau(self, miroStatTau: float):
+        """Set the MiroStat target entropy, parameter tau"""
+        return self._set(miroStatTau=miroStatTau)
+
+    def setMiroStatEta(self, miroStatEta: float):
+        """Set the MiroStat learning rate, parameter eta"""
+        return self._set(miroStatEta=miroStatEta)
+
+    def setPenalizeNl(self, penalizeNl: bool):
+        """Whether to penalize newline tokens"""
+        return self._set(penalizeNl=penalizeNl)
+
+    def setNKeep(self, nKeep: int):
+        """Set the number of tokens to keep from the initial prompt"""
+        return self._set(nKeep=nKeep)
+
+    def setSeed(self, seed: int):
+        """Set the RNG seed"""
+        return self._set(seed=seed)
+
+    def setNProbs(self, nProbs: int):
+        """Set the amount top tokens probabilities to output if greater than 0."""
+        return self._set(nProbs=nProbs)
+
+    def setMinKeep(self, minKeep: int):
+        """Set the amount of tokens the samplers should return at least (0 = disabled)"""
+        return self._set(minKeep=minKeep)
+
+    def setGrammar(self, grammar: bool):
+        """Set BNF-like grammar to constrain generations"""
+        return self._set(grammar=grammar)
+
+    def setPenaltyPrompt(self, penaltyPrompt: str):
+        """Override which part of the prompt is penalized for repetition."""
+        return self._set(penaltyPrompt=penaltyPrompt)
+
+    def setIgnoreEos(self, ignoreEos: bool):
+        """Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)"""
+        return self._set(ignoreEos=ignoreEos)
+
+    def setDisableTokenIds(self, disableTokenIds: List[int]):
+        """Set the token ids to disable in the completion"""
+        return self._set(disableTokenIds=disableTokenIds)
+
+    def setStopStrings(self, stopStrings: List[str]):
+        """Set strings upon seeing which token generation is stopped"""
+        return self._set(stopStrings=stopStrings)
+
+    def setSamplers(self, samplers: List[str]):
+        """Set which samplers to use for token generation in the given order"""
+        return self._set(samplers=samplers)
+
+    def setUseChatTemplate(self, useChatTemplate: bool):
+        """Set whether generate should apply a chat template"""
+        return self._set(useChatTemplate=useChatTemplate)
+    
+    def setNParallel(self, nParallel: int):
+        """Sets the number of parallel processes for decoding. This is an alias for `setBatchSize`."""
+        return self.setBatchSize(nParallel)
+
+    # -------- JAVA SETTERS --------
+    def setTokenIdBias(self, tokenIdBias: Dict[int, float]):
+        """Set token id bias"""
+        return self._call_java("setTokenIdBias", tokenIdBias)
+
+    def setTokenBias(self, tokenBias: Dict[str, float]):
+        """Set token id bias"""
+        return self._call_java("setTokenBias", tokenBias)
+
+    def setLoraAdapters(self, loraAdapters: Dict[str, float]):
+        """Set token id bias"""
+        return self._call_java("setLoraAdapters", loraAdapters)
+
+    def getMetadata(self):
+        """Gets the metadata of the model"""
+        return self._call_java("getMetadata")
diff --git a/python/sparknlp/internal/__init__.py b/python/sparknlp/internal/__init__.py
index 4cb5321e8a8691..7f898050bf27db 100644
--- a/python/sparknlp/internal/__init__.py
+++ b/python/sparknlp/internal/__init__.py
@@ -67,6 +67,15 @@ def __init__(self, path, jspark):
         )
 
 
+class _AlbertMultipleChoiceLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark):
+        super(_AlbertMultipleChoiceLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.classifier.dl.AlbertForMultipleChoice.loadSavedModel",
+            path,
+            jspark,
+        )
+
+
 class _BertLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark, use_openvino=False):
         super(_BertLoader, self).__init__(
@@ -121,6 +130,15 @@ def __init__(self, path, jspark):
             jspark,
         )
 
+class _CoHereLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark, use_openvino=False):
+        super(_CoHereLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.seq2seq.CoHereTransformer.loadSavedModel",
+            path,
+            jspark,
+            use_openvino,
+        )
+
 class _DeBERTaLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark):
         super(_DeBERTaLoader, self).__init__(
@@ -211,6 +229,15 @@ def __init__(self, path, jspark):
         )
 
 
+class _DistilBertMultipleChoiceLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark):
+        super(_DistilBertMultipleChoiceLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.classifier.dl.DistilBertForMultipleChoice.loadSavedModel",
+            path,
+            jspark,
+        )
+
+
 class _ElmoLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark):
         super(_ElmoLoader, self).__init__(
@@ -245,6 +272,14 @@ def __init__(self, path, jspark):
             jspark,
         )
 
+class _JanusForMultiModalLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark, use_openvino=False):
+        super(_JanusForMultiModalLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.cv.JanusForMultiModal.loadSavedModel",
+            path,
+            jspark,
+            use_openvino
+        )
 
 class _LLAMA2Loader(ExtendedJavaWrapper):
     def __init__(self, path, jspark, use_openvino=False):
@@ -299,6 +334,14 @@ def __init__(self, path, jspark):
             jspark,
         )
 
+class _LLAVAForMultiModalLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark, use_openvino=False):
+        super(_LLAVAForMultiModalLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.cv.LLAVAForMultiModal.loadSavedModel",
+            path,
+            jspark,
+            use_openvino
+        )
 
 class _M2M100Loader(ExtendedJavaWrapper):
     def __init__(self, path, jspark, use_openvino=False):
@@ -318,6 +361,14 @@ def __init__(self, path, jspark, use_openvino=False):
             use_openvino,
         )
 
+class _MLLamaForMultimodalLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark, use_openvino=False):
+        super(_MLLamaForMultimodalLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.cv.MLLamaForMultimodal.loadSavedModel",
+            path,
+            jspark,
+            use_openvino
+        )
 
 class _NLLBLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark,  use_openvino=False):
@@ -345,6 +396,10 @@ def __init__(self, path, jspark):
         )
 
 
+class _OLMoLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark):
+        super(_OLMoLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.seq2seq.OLMoTransformer.loadSavedModel", path, jspark)
 class _Phi2Loader(ExtendedJavaWrapper):
     def __init__(self, path, jspark, use_openvino=False):
         super(_Phi2Loader, self).__init__(
@@ -363,6 +418,15 @@ def __init__(self, path, jspark, use_openvino=False):
             use_openvino,
         )
 
+class _Phi3VisionLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark, use_openvino=False):
+        super(_Phi3VisionLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.cv.Phi3Vision.loadSavedModel",
+            path,
+            jspark,
+            use_openvino
+        )
+
 class _RoBertaLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark, use_openvino=False):
         super(_RoBertaLoader, self).__init__(
@@ -409,6 +473,15 @@ def __init__(self, path, jspark):
         )
 
 
+class _RoBertaMultipleChoiceLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark):
+        super(_RoBertaMultipleChoiceLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.classifier.dl.RoBertaForMultipleChoice.loadSavedModel",
+            path,
+            jspark,
+        )
+
+
 class _StarCoderLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark, use_openvino=False):
         super(_StarCoderLoader, self).__init__(
@@ -504,6 +577,15 @@ def __init__(self, path, jspark):
         )
 
 
+class _XlmRoBertaMultipleChoiceLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark):
+        super(_XlmRoBertaMultipleChoiceLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.classifier.dl.XlmRoBertaForMultipleChoice.loadSavedModel",
+            path,
+            jspark,
+        )
+
+
 class _XlnetLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark):
         super(_XlnetLoader, self).__init__(
@@ -992,8 +1074,8 @@ class _AutoGGUFLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark):
         super(_AutoGGUFLoader, self).__init__(
             "com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFModel.loadSavedModel", path, jspark)
-        
-        
+
+
 class _MxbaiEmbeddingsLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark):
         super(_MxbaiEmbeddingsLoader, self).__init__(
@@ -1021,3 +1103,19 @@ def __init__(self, path, jspark):
             path,
             jspark,
         )
+
+
+class _AutoGGUFVisionLoader(ExtendedJavaWrapper):
+    def __init__(self, modelPath, mmprojPath, jspark):
+        super(_AutoGGUFVisionLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFVisionModel.loadSavedModel", modelPath, mmprojPath, jspark)
+        
+               
+class _Qwen2VLTransformerLoader(ExtendedJavaWrapper):
+    def __init__(self, path, jspark, use_openvino=False):
+        super(_Qwen2VLTransformerLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.cv.Qwen2VLTransformer.loadSavedModel",
+            path,
+            jspark,
+            use_openvino,
+        )
diff --git a/python/sparknlp/partition/__init__.py b/python/sparknlp/partition/__init__.py
new file mode 100644
index 00000000000000..6b80db2ce46719
--- /dev/null
+++ b/python/sparknlp/partition/__init__.py
@@ -0,0 +1,14 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from sparknlp.partition.partition import *
\ No newline at end of file
diff --git a/python/sparknlp/partition/partition.py b/python/sparknlp/partition/partition.py
new file mode 100644
index 00000000000000..8326bf5181de8e
--- /dev/null
+++ b/python/sparknlp/partition/partition.py
@@ -0,0 +1,47 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import sparknlp
+from sparknlp.internal import ExtendedJavaWrapper
+
+class Partition(ExtendedJavaWrapper):
+
+    def  __init__(self, **kwargs):
+        self.spark = sparknlp.start()
+        params = {}
+        for key, value in kwargs.items():
+            try:
+                params[key] = str(value)
+            except Exception as e:
+                raise ValueError(f"Invalid value for key '{key}': Cannot cast {type(value)} to string. Original error: {e}")
+
+        super(Partition, self).__init__("com.johnsnowlabs.partition.Partition", params)
+
+    def partition(self, path, headers=None):
+        if headers is None:
+            headers = {}
+        jdf = self._java_obj.partition(path, headers)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
+
+    def partition_urls(self, path, headers=None):
+        if headers is None:
+            headers = {}
+        jdf = self._java_obj.partitionUrlsJava(path, headers)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
+
+    def partition_text(self, text):
+        jdf = self._java_obj.partitionText(text)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
\ No newline at end of file
diff --git a/python/sparknlp/reader/pdf_to_text.py b/python/sparknlp/reader/pdf_to_text.py
new file mode 100644
index 00000000000000..70b31e757482f0
--- /dev/null
+++ b/python/sparknlp/reader/pdf_to_text.py
@@ -0,0 +1,65 @@
+from pyspark import keyword_only
+from pyspark.ml.param import Param, Params, TypeConverters
+from pyspark.ml.param.shared import HasInputCol, HasOutputCol
+from pyspark.ml.util import JavaMLReadable, JavaMLWritable
+from pyspark.ml.wrapper import JavaTransformer
+
+
+class PdfToText(JavaTransformer, HasInputCol, HasOutputCol,
+                JavaMLReadable, JavaMLWritable):
+    """
+    Extract text from Pdf document to single string or to several strings per each page.
+    Input is a column with binary representation of PDF document.
+    As output generate column with text and page number.
+    Explode each page as separate row if split to page enabled.
+    """
+    pageNumCol = Param(Params._dummy(), "pageNumCol",
+                       "Page number output column name.",
+                       typeConverter=TypeConverters.toString)
+
+    partitionNum = Param(Params._dummy(), "partitionNum",
+                         "Number of partitions.",
+                         typeConverter=TypeConverters.toInt)
+
+    storeSplittedPdf = Param(Params._dummy(), "storeSplittedPdf",
+                             "Force to store splitted pdf.",
+                             typeConverter=TypeConverters.toBoolean)
+
+    @keyword_only
+    def __init__(self):
+        """
+        __init__(self)
+        """
+        super(PdfToText, self).__init__()
+        self._java_obj = self._new_java_obj("com.johnsnowlabs.reader.PdfToText", self.uid)
+
+
+    def setInputCol(self, value):
+        """
+        Sets the value of :py:attr:`inputCol`.
+        """
+        return self._set(inputCol=value)
+
+    def setOutputCol(self, value):
+        """
+        Sets the value of :py:attr:`outputCol`.
+        """
+        return self._set(outputCol=value)
+
+    def setPageNumCol(self, value):
+        """
+        Sets the value of :py:attr:`pageNumCol`.
+        """
+        return self._set(pageNumCol=value)
+
+    def setPartitionNum(self, value):
+        """
+        Sets the value of :py:attr:`partitionNum`.
+        """
+        return self._set(partitionNum=value)
+
+    def setStoreSplittedPdf(self, value):
+        """
+        Sets the value of :py:attr:`storeSplittedPdf`.
+        """
+        return self._set(storeSplittedPdf=value)
diff --git a/python/sparknlp/reader/sparknlp_reader.py b/python/sparknlp/reader/sparknlp_reader.py
index 06b8309bd45258..ce347b994667b4 100644
--- a/python/sparknlp/reader/sparknlp_reader.py
+++ b/python/sparknlp/reader/sparknlp_reader.py
@@ -15,25 +15,115 @@
 
 
 class SparkNLPReader(ExtendedJavaWrapper):
-    """Instantiates class to read HTML, email, and document files.
-
-    Two types of input paths are supported:
-
-    - `htmlPath`: A path to a directory of HTML files or a single HTML file (e.g., `"path/html/files"`).
-    - `url`: A single URL or a set of URLs (e.g., `"https://www.wikipedia.org"`).
+    """Instantiates class to read HTML, email, MS Word and Excel files.
 
     Parameters
     ----------
-    spark : SparkSession
-        The active Spark session.
+    params : spark
+        Spark session
     params : dict, optional
-        A dictionary with custom configurations.
+        Parameter with custom configuration
+
+    Examples
+    --------
+    >>> from sparknlp.reader import SparkNLPReader
+    >>> html_df = SparkNLPReader().html(spark, "https://www.wikipedia.org")
+
+    You can use SparkNLP for one line of code
+    >>> import sparknlp
+    >>> html_df = sparknlp.read().html("https://www.wikipedia.org")
+    >>> html_df.show(truncate=False)
+
+    +--------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |url                 |html                                                                                                                                                                                                                                                                                                                            |
+    +--------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |https://example.com/|[{Title, Example Domain, {pageNumber -> 1}}, {NarrativeText, 0, This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission., {pageNumber -> 1}}, {NarrativeText, 0, More information... More information..., {pageNumber -> 1}}]   |
+    +--------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    >>> html_df.printSchema()
+
+    root
+     |-- url: string (nullable = true)
+     |-- html: array (nullable = true)
+     |    |-- element: struct (containsNull = true)
+     |    |    |-- elementType: string (nullable = true)
+     |    |    |-- content: string (nullable = true)
+     |    |    |-- metadata: map (nullable = true)
+     |    |    |    |-- key: string
+     |    |    |    |-- value: string (valueContainsNull = true)
+
+
+
+    Instantiates class to read email files.
+
+    emailPath: this is a path to a directory of HTML files or a path to an HTML file E.g.
+    "path/html/emails"
+
+    Examples
+    --------
+    >>> from sparknlp.reader import SparkNLPReader
+    >>> email_df = SparkNLPReader().email(spark, "home/user/emails-directory")
+
+    You can use SparkNLP for one line of code
+    >>> import sparknlp
+    >>> email_df = sparknlp.read().email("home/user/emails-directory")
+    >>> email_df.show(truncate=False)
+    +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |email                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+    +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |[{Title, Email Text Attachments, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano }}, {NarrativeText, Email  test with two text attachments\r\n\r\nCheers,\r\n\r\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/plain}}, {NarrativeText, \r\n\r\n\r\n\r\n\r\n\r\nEmail  test with two text attachments\r\n
\r\n
\r\n
\r\n
\r\nCheers,
\r\n
\r\n
\r\n
\r\n\r\n\r\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/html}}, {Attachment, filename.txt, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , contentType -> text/plain; name="filename.txt"}}, {NarrativeText, This is the content of the file.\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/plain}}, {Attachment, filename2.txt, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , contentType -> text/plain; name="filename2.txt"}}, {NarrativeText, This is an additional content file.\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/plain}}]|
+    +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    email_df.printSchema()
+    root
+     |-- path: string (nullable = true)
+     |-- content: array (nullable = true)
+     |-- email: array (nullable = true)
+     |    |-- element: struct (containsNull = true)
+     |    |    |-- elementType: string (nullable = true)
+     |    |    |-- content: string (nullable = true)
+     |    |    |-- metadata: map (nullable = true)
+     |    |    |    |-- key: string
+     |    |    |    |-- value: string (valueContainsNull = true)
+
+
+    Instantiates class to read PDF files.
+
+    pdfPath: this is a path to a directory of PDF files or a path to an PDF file E.g.
+    "path/pdfs/"
+
+    Examples
+    --------
+    >>> from sparknlp.reader import SparkNLPReader
+    >>> pdf_df = SparkNLPReader().pdf(spark, "home/user/pdfs-directory")
+
+    You can use SparkNLP for one line of code
+    >>> import sparknlp
+    >>> pdf_df = sparknlp.read().pdf("home/user/pdfs-directory")
+    >>> pdf_df.show(truncate=False)
+
+    +--------------------+--------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+
+    |                path|    modificationTime|length|                text|height_dimension|width_dimension|             content|exception|pagenum|
+    +--------------------+--------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+
+    |file:/content/pdf...|2025-01-15 20:48:...| 25803|This is a Title \...|             842|            596|[25 50 44 46 2D 3...|     NULL|      0|
+    |file:/content/pdf...|2025-01-15 20:48:...|  9487|This is a page.\n...|             841|            595|[25 50 44 46 2D 3...|     NULL|      0|
+    +--------------------+--------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+
+
+    pdf_df.printSchema()
+    root
+     |-- path: string (nullable = true)
+     |-- modificationTime: timestamp (nullable = true)
+     |-- length: long (nullable = true)
+     |-- text: string (nullable = true)
+     |-- height_dimension: integer (nullable = true)
+     |-- width_dimension: integer (nullable = true)
+     |-- content: binary (nullable = true)
+     |-- exception: string (nullable = true)
+     |-- pagenum: integer (nullable = true)
     """
 
-    def __init__(self, spark, params=None):
+    def __init__(self, spark, params=None, headers=None):
         if params is None:
             params = {}
-        super(SparkNLPReader, self).__init__("com.johnsnowlabs.reader.SparkNLPReader", params)
+        super(SparkNLPReader, self).__init__("com.johnsnowlabs.reader.SparkNLPReader", params, headers)
         self.spark = spark
 
     def html(self, htmlPath):
@@ -52,18 +142,36 @@ def html(self, htmlPath):
         Examples
         --------
         >>> from sparknlp.reader import SparkNLPReader
-        >>> html_df = SparkNLPReader(spark).html("https://www.wikipedia.org")
+        >>> html_df = SparkNLPReader().html("https://www.wikipedia.org")
 
         You can also use SparkNLP to simplify the process:
 
         >>> import sparknlp
         >>> html_df = sparknlp.read().html("https://www.wikipedia.org")
         >>> html_df.show(truncate=False)
+
+        +--------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |url                 |html                                                                                                                                                                                                                                                                                                                            |
+        +--------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |https://example.com/|[{Title, Example Domain, {pageNumber -> 1}}, {NarrativeText, 0, This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission., {pageNumber -> 1}}, {NarrativeText, 0, More information... More information..., {pageNumber -> 1}}]   |
+        +--------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        >>> html_df.printSchema()
+
+        root
+         |-- url: string (nullable = true)
+         |-- html: array (nullable = true)
+         |    |-- element: struct (containsNull = true)
+         |    |    |-- elementType: string (nullable = true)
+         |    |    |-- content: string (nullable = true)
+         |    |    |-- metadata: map (nullable = true)
+         |    |    |    |-- key: string
+         |    |    |    |-- value: string (valueContainsNull = true)
         """
         if not isinstance(htmlPath, (str, list)) or (isinstance(htmlPath, list) and not all(isinstance(item, str) for item in htmlPath)):
             raise TypeError("htmlPath must be a string or a list of strings")
         jdf = self._java_obj.html(htmlPath)
-        return self.getDataFrame(self.spark, jdf)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
 
     def email(self, filePath):
         """Reads email files and returns a Spark DataFrame.
@@ -83,31 +191,207 @@ def email(self, filePath):
         >>> from sparknlp.reader import SparkNLPReader
         >>> email_df = SparkNLPReader(spark).email("home/user/emails-directory")
 
-        Using SparkNLP:
+        You can also use SparkNLP to simplify the process:
 
         >>> import sparknlp
         >>> email_df = sparknlp.read().email("home/user/emails-directory")
         >>> email_df.show(truncate=False)
+
+        +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |email                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+        +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |[{Title, Email Text Attachments, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano }}, {NarrativeText, Email  test with two text attachments\r\n\r\nCheers,\r\n\r\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/plain}}, {NarrativeText, \r\n\r\n\r\n\r\n\r\n\r\nEmail  test with two text attachments\r\n
\r\n
\r\n
\r\n
\r\nCheers,
\r\n
\r\n
\r\n
\r\n\r\n\r\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/html}}, {Attachment, filename.txt, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , contentType -> text/plain; name="filename.txt"}}, {NarrativeText, This is the content of the file.\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/plain}}, {Attachment, filename2.txt, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , contentType -> text/plain; name="filename2.txt"}}, {NarrativeText, This is an additional content file.\n, {sent_to -> Danilo Burbano , sent_from -> Danilo Burbano , mimeType -> text/plain}}]|
+        +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        >>> email_df.printSchema()
+        root
+         |-- path: string (nullable = true)
+         |-- content: array (nullable = true)
+         |-- email: array (nullable = true)
+         |    |-- element: struct (containsNull = true)
+         |    |    |-- elementType: string (nullable = true)
+         |    |    |-- content: string (nullable = true)
+         |    |    |-- metadata: map (nullable = true)
+         |    |    |    |-- key: string
+         |    |    |    |-- value: string (valueContainsNull = true)
+
         """
         if not isinstance(filePath, str):
             raise TypeError("filePath must be a string")
         jdf = self._java_obj.email(filePath)
-        return self.getDataFrame(self.spark, jdf)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
 
     def doc(self, docPath):
-        """Reads document files and returns a Spark DataFrame.
+        """Reads word document files and returns a Spark DataFrame.
 
         Parameters
         ----------
         docPath : str
-            Path to a document file.
+            Path to a word document file.
 
         Returns
         -------
         pyspark.sql.DataFrame
             A DataFrame containing parsed document content.
+
+        Examples
+        --------
+        >>> from sparknlp.reader import SparkNLPReader
+        >>> doc_df = SparkNLPReader().doc(spark, "home/user/word-directory")
+
+        You can use SparkNLP for one line of code
+        >>> import sparknlp
+        >>> doc_df = sparknlp.read().doc("home/user/word-directory")
+        >>> doc_df.show(truncate=False)
+
+        +----------------------------------------------------------------------------------------------------------------------------------------------------+
+        |doc                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+        +----------------------------------------------------------------------------------------------------------------------------------------------------+
+        |[{Table, Header Col 1, {}}, {Table, Header Col 2, {}}, {Table, Lorem ipsum, {}}, {Table, A Link example, {}}, {NarrativeText, Dolor sit amet, {}}]  |
+        +----------------------------------------------------------------------------------------------------------------------------------------------------+
+        >>> docsDf.printSchema()
+        root
+         |-- path: string (nullable = true)
+         |-- content: array (nullable = true)
+         |-- doc: array (nullable = true)
+         |    |-- element: struct (containsNull = true)
+         |    |    |-- elementType: string (nullable = true)
+         |    |    |-- content: string (nullable = true)
+         |    |    |-- metadata: map (nullable = true)
+         |    |    |    |-- key: string
+         |    |    |    |-- value: string (valueContainsNull = true)
+
         """
         if not isinstance(docPath, str):
             raise TypeError("docPath must be a string")
         jdf = self._java_obj.doc(docPath)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
+
+    def pdf(self, pdfPath):
+        if not isinstance(pdfPath, str):
+            raise TypeError("docPath must be a string")
+        jdf = self._java_obj.pdf(pdfPath)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
+
+    def xls(self, docPath):
+        """Reads excel document files and returns a Spark DataFrame.
+
+        Parameters
+        ----------
+        docPath : str
+            Path to an excel document file.
+
+        Returns
+        -------
+        pyspark.sql.DataFrame
+            A DataFrame containing parsed document content.
+
+        Examples
+        --------
+        >>> from sparknlp.reader import SparkNLPReader
+        >>> xlsDf = SparkNLPReader().xls(spark, "home/user/excel-directory")
+
+        You can use SparkNLP for one line of code
+        >>> import sparknlp
+        >>> xlsDf = sparknlp.read().xls("home/user/excel-directory")
+        >>> xlsDf.show(truncate=False)
+
+        +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |xls                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+        +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |[{Title, Financial performance, {SheetName -> Index}}, {Title, Topic\tPeriod\t\t\tPage, {SheetName -> Index}}, {NarrativeText, Quarterly revenue\tNine quarters to 30 June 2023\t\t\t1.0, {SheetName -> Index}}, {NarrativeText, Group financial performance\tFY 22\tFY 23\t\t2.0, {SheetName -> Index}}, {NarrativeText, Segmental results\tFY 22\tFY 23\t\t3.0, {SheetName -> Index}}, {NarrativeText, Segmental analysis\tFY 22\tFY 23\t\t4.0, {SheetName -> Index}}, {NarrativeText, Cash flow\tFY 22\tFY 23\t\t5.0, {SheetName -> Index}}, {Title, Operational metrics, {SheetName -> Index}}, {Title, Topic\tPeriod\t\t\tPage, {SheetName -> Index}}, {NarrativeText, Mobile customers\tNine quarters to 30 June 2023\t\t\t6.0, {SheetName -> Index}}, {NarrativeText, Fixed broadband customers\tNine quarters to 30 June 2023\t\t\t7.0, {SheetName -> Index}}, {NarrativeText, Marketable homes passed\tNine quarters to 30 June 2023\t\t\t8.0, {SheetName -> Index}}, {NarrativeText, TV customers\tNine quarters to 30 June 2023\t\t\t9.0, {SheetName -> Index}}, {NarrativeText, Converged customers\tNine quarters to 30 June 2023\t\t\t10.0, {SheetName -> Index}}, {NarrativeText, Mobile churn\tNine quarters to 30 June 2023\t\t\t11.0, {SheetName -> Index}}, {NarrativeText, Mobile data usage\tNine quarters to 30 June 2023\t\t\t12.0, {SheetName -> Index}}, {NarrativeText, Mobile ARPU\tNine quarters to 30 June 2023\t\t\t13.0, {SheetName -> Index}}, {Title, Other, {SheetName -> Index}}, {Title, Topic\tPeriod\t\t\tPage, {SheetName -> Index}}, {NarrativeText, Average foreign exchange rates\tNine quarters to 30 June 2023\t\t\t14.0, {SheetName -> Index}}, {NarrativeText, Guidance rates\tFY 23/24\t\t\t14.0, {SheetName -> Index}}]|
+        +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+       >>> xlsDf.printSchema()
+       root
+        |-- path: string (nullable = true)
+        |-- content: binary (nullable = true)
+        |-- xls: array (nullable = true)
+        |    |-- element: struct (containsNull = true)
+        |    |    |-- elementType: string (nullable = true)
+        |    |    |-- content: string (nullable = true)
+        |    |    |-- metadata: map (nullable = true)
+        |    |    |    |-- key: string
+        |    |    |    |-- value: string (valueContainsNull = true)
+       """
+        if not isinstance(docPath, str):
+            raise TypeError("docPath must be a string")
+        jdf = self._java_obj.xls(docPath)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
+
+    def ppt(self, docPath):
+        """
+        Reads power point document files and returns a Spark DataFrame.
+
+        Parameters
+        ----------
+        docPath : str
+            Path to an excel document file.
+
+        Returns
+        -------
+        pyspark.sql.DataFrame
+            A DataFrame containing parsed document content.
+
+        Examples
+        --------
+        >>> from sparknlp.reader import SparkNLPReader
+        >>> pptDf = SparkNLPReader().ppt(spark, "home/user/powerpoint-directory")
+
+        You can use SparkNLP for one line of code
+        >>> import sparknlp
+        >>> pptDf = sparknlp.read().ppt("home/user/powerpoint-directory")
+        >>> pptDf.show(truncate=False)
+        +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |ppt                                                                                                                                                                                                                                                                                                                      |
+        +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |[{Title, Adding a Bullet Slide, {}}, {ListItem, • Find the bullet slide layout, {}}, {ListItem, – Use _TextFrame.text for first bullet, {}}, {ListItem, • Use _TextFrame.add_paragraph() for subsequent bullets, {}}, {NarrativeText, Here is a lot of text!, {}}, {NarrativeText, Here is some text in a text box!, {}}]|
+        +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        """
+        if not isinstance(docPath, str):
+            raise TypeError("docPath must be a string")
+        jdf = self._java_obj.ppt(docPath)
+        dataframe = self.getDataFrame(self.spark, jdf)
+        return dataframe
+
+    def txt(self, docPath):
+        """Reads TXT files and returns a Spark DataFrame.
+
+        Parameters
+        ----------
+        docPath : str
+            Path to a TXT file.
+
+        Returns
+        -------
+        pyspark.sql.DataFrame
+            A DataFrame containing parsed document content.
+
+        Examples
+        --------
+        >>> from sparknlp.reader import SparkNLPReader
+        >>> txtDf = SparkNLPReader().txt(spark, "home/user/txt/files")
+
+        You can use SparkNLP for one line of code
+        >>> import sparknlp
+        >>> txtDf = sparknlp.read().txt("home/user/txt/files")
+        >>> txtDf.show(truncate=False)
+        +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |txt                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+        +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        |[{Title, BIG DATA ANALYTICS, {paragraph -> 0}}, {NarrativeText, Apache Spark is a fast and general-purpose cluster computing system.\nIt provides high-level APIs in Java, Scala, Python, and R., {paragraph -> 0}}, {Title, MACHINE LEARNING, {paragraph -> 1}}, {NarrativeText, Spark's MLlib provides scalable machine learning algorithms.\nIt includes tools for classification, regression, clustering, and more., {paragraph -> 1}}]|
+        +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+        """
+        if not isinstance(docPath, str):
+            raise TypeError("docPath must be a string")
+        jdf = self._java_obj.txt(docPath)
+        return self.getDataFrame(self.spark, jdf)
+
+    def xml(self, docPath):
+        if not isinstance(docPath, str):
+            raise TypeError("docPath must be a string")
+        jdf = self._java_obj.xml(docPath)
         return self.getDataFrame(self.spark, jdf)
\ No newline at end of file
diff --git a/python/test/annotator/classifier_dl/albert_for_multiple_choice_test.py b/python/test/annotator/classifier_dl/albert_for_multiple_choice_test.py
new file mode 100644
index 00000000000000..6e42465e8a2cea
--- /dev/null
+++ b/python/test/annotator/classifier_dl/albert_for_multiple_choice_test.py
@@ -0,0 +1,79 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import unittest
+
+import pytest
+
+from sparknlp.annotator.classifier_dl.albert_for_multiple_choice import AlbertForMultipleChoice
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+class AlbertForMultipleChoiceTestSetup(unittest.TestCase):
+    def setUp(self):
+
+        sparkNLPModelPath = "/media/danilo/Data/Danilo/JSL/models/transformers/spark-nlp"
+
+        self.spark = SparkContextForTest.spark
+        self.question = "The Eiffel Tower is located in which country?"
+        self.choices = "Germany, France, Italy"
+
+        self.spark = SparkContextForTest.spark
+        empty_df = self.spark.createDataFrame([[""]]).toDF("text")
+
+        document_assembler = MultiDocumentAssembler() \
+            .setInputCols(["question", "context"]) \
+            .setOutputCols(["document_question", "document_context"])
+
+        albert_for_multiple_choice = AlbertForMultipleChoice.load(sparkNLPModelPath + "/openvino/albert_multiple_choice_openvino") \
+            .setInputCols(["document_question", "document_context"]) \
+            .setOutputCol("answer")
+
+        pipeline = Pipeline(stages=[document_assembler, albert_for_multiple_choice])
+
+        self.pipeline_model = pipeline.fit(empty_df)
+
+
+@pytest.mark.slow
+class AlbertForMultipleChoiceTest(AlbertForMultipleChoiceTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.data = self.spark.createDataFrame([[self.question, self.choices]]).toDF("question","context")
+        self.data.show(truncate=False)
+
+    def test_run(self):
+        result_df = self.pipeline_model.transform(self.data)
+        result_df.show(truncate=False)
+        for row in result_df.collect():
+            self.assertTrue(row["answer"][0].result != "")
+
+
+@pytest.mark.slow
+class LightAlbertForMultipleChoiceTest(AlbertForMultipleChoiceTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.pipeline_model)
+        annotations_result = light_pipeline.fullAnnotate(self.question,self.choices)
+        print(annotations_result)
+        for result in annotations_result:
+            self.assertTrue(result["answer"][0].result != "")
+
+        result = light_pipeline.annotate(self.question,self.choices)
+        print(result)
+        self.assertTrue(result["answer"] != "")
diff --git a/python/test/annotator/classifier_dl/distilbert_for_multiple_choice_test.py b/python/test/annotator/classifier_dl/distilbert_for_multiple_choice_test.py
new file mode 100644
index 00000000000000..15e3885767017b
--- /dev/null
+++ b/python/test/annotator/classifier_dl/distilbert_for_multiple_choice_test.py
@@ -0,0 +1,76 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import unittest
+
+import pytest
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+class DistilBertForMultipleChoiceTestSetup(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        self.question = "The Eiffel Tower is located in which country?"
+        self.choices = "Germany, France, Italy"
+
+        self.spark = SparkContextForTest.spark
+        empty_df = self.spark.createDataFrame([[""]]).toDF("text")
+
+        document_assembler = MultiDocumentAssembler() \
+            .setInputCols(["question", "context"]) \
+            .setOutputCols(["document_question", "document_context"])
+
+        DistilBert_for_multiple_choice = DistilBertForMultipleChoice.pretrained() \
+            .setInputCols(["document_question", "document_context"]) \
+            .setOutputCol("answer")
+
+        pipeline = Pipeline(stages=[document_assembler, DistilBert_for_multiple_choice])
+
+        self.pipeline_model = pipeline.fit(empty_df)
+
+
+@pytest.mark.slow
+class DistilBertForMultipleChoiceTest(DistilBertForMultipleChoiceTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.data = self.spark.createDataFrame([[self.question, self.choices]]).toDF("question","context")
+        self.data.show(truncate=False)
+
+    def test_run(self):
+        result_df = self.pipeline_model.transform(self.data)
+        result_df.show(truncate=False)
+        for row in result_df.collect():
+            self.assertTrue(row["answer"][0].result != "")
+
+
+@pytest.mark.slow
+class LightDistilBertForMultipleChoiceTest(DistilBertForMultipleChoiceTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.pipeline_model)
+        annotations_result = light_pipeline.fullAnnotate(self.question,self.choices)
+        print(annotations_result)
+        for result in annotations_result:
+            self.assertTrue(result["answer"][0].result != "")
+
+        result = light_pipeline.annotate(self.question,self.choices)
+        print(result)
+        self.assertTrue(result["answer"] != "")
diff --git a/python/test/annotator/classifier_dl/roberta_for_multiple_choice_test.py b/python/test/annotator/classifier_dl/roberta_for_multiple_choice_test.py
new file mode 100644
index 00000000000000..b93c4b723d8e55
--- /dev/null
+++ b/python/test/annotator/classifier_dl/roberta_for_multiple_choice_test.py
@@ -0,0 +1,77 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import unittest
+
+import pytest
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+class RobertaForMultipleChoiceTestSetup(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        self.question = "The Eiffel Tower is located in which country?"
+        self.choices = "Germany, France, Italy"
+
+        self.spark = SparkContextForTest.spark
+        empty_df = self.spark.createDataFrame([[""]]).toDF("text")
+
+        document_assembler = MultiDocumentAssembler() \
+            .setInputCols(["question", "context"]) \
+            .setOutputCols(["document_question", "document_context"])
+
+        model_path = "/media/danilo/Data/Danilo/JSL/models/transformers/spark-nlp/onnx/roberta_multiple_choice"
+        roberta_for_multiple_choice = RoBertaForMultipleChoice.load(model_path) \
+            .setInputCols(["document_question", "document_context"]) \
+            .setOutputCol("answer")
+
+        pipeline = Pipeline(stages=[document_assembler, roberta_for_multiple_choice])
+
+        self.pipeline_model = pipeline.fit(empty_df)
+
+
+@pytest.mark.slow
+class RobertaForMultipleChoiceTest(RobertaForMultipleChoiceTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.data = self.spark.createDataFrame([[self.question, self.choices]]).toDF("question","context")
+        self.data.show(truncate=False)
+
+    def test_run(self):
+        result_df = self.pipeline_model.transform(self.data)
+        result_df.show(truncate=False)
+        for row in result_df.collect():
+            self.assertTrue(row["answer"][0].result != "")
+
+
+@pytest.mark.slow
+class LightRobertaForMultipleChoiceTest(RobertaForMultipleChoiceTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.pipeline_model)
+        annotations_result = light_pipeline.fullAnnotate(self.question,self.choices)
+        print(annotations_result)
+        for result in annotations_result:
+            self.assertTrue(result["answer"][0].result != "")
+
+        result = light_pipeline.annotate(self.question,self.choices)
+        print(result)
+        self.assertTrue(result["answer"] != "")
diff --git a/python/test/annotator/classifier_dl/xlm_roberta_for_multiple_choice_test.py b/python/test/annotator/classifier_dl/xlm_roberta_for_multiple_choice_test.py
new file mode 100644
index 00000000000000..b26d50dfa3be1e
--- /dev/null
+++ b/python/test/annotator/classifier_dl/xlm_roberta_for_multiple_choice_test.py
@@ -0,0 +1,76 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import unittest
+
+import pytest
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+class XlmRoBertaForMultipleChoiceTestSetup(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        self.question = "The Eiffel Tower is located in which country?"
+        self.choices = "Germany, France, Italy"
+
+        self.spark = SparkContextForTest.spark
+        empty_df = self.spark.createDataFrame([[""]]).toDF("text")
+
+        document_assembler = MultiDocumentAssembler() \
+            .setInputCols(["question", "context"]) \
+            .setOutputCols(["document_question", "document_context"])
+
+        bert_for_multiple_choice = XlmRoBertaForMultipleChoice.pretrained() \
+            .setInputCols(["document_question", "document_context"]) \
+            .setOutputCol("answer")
+
+        pipeline = Pipeline(stages=[document_assembler, bert_for_multiple_choice])
+
+        self.pipeline_model = pipeline.fit(empty_df)
+
+
+@pytest.mark.slow
+class XlmRoBertaForMultipleChoiceTest(XlmRoBertaForMultipleChoiceTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.data = self.spark.createDataFrame([[self.question, self.choices]]).toDF("question","context")
+        self.data.show(truncate=False)
+
+    def test_run(self):
+        result_df = self.pipeline_model.transform(self.data)
+        result_df.show(truncate=False)
+        for row in result_df.collect():
+            self.assertTrue(row["answer"][0].result != "")
+
+
+@pytest.mark.slow
+class LightXlmRoBertaForMultipleChoiceTest(XlmRoBertaForMultipleChoiceTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.pipeline_model)
+        annotations_result = light_pipeline.fullAnnotate(self.question,self.choices)
+        print(annotations_result)
+        for result in annotations_result:
+            self.assertTrue(result["answer"][0].result != "")
+
+        result = light_pipeline.annotate(self.question,self.choices)
+        print(result)
+        self.assertTrue(result["answer"] != "")
diff --git a/python/test/annotator/cleaners/__init__.py b/python/test/annotator/cleaners/__init__.py
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/python/test/annotator/cleaners/cleaner_test.py b/python/test/annotator/cleaners/cleaner_test.py
new file mode 100644
index 00000000000000..1868dbae935737
--- /dev/null
+++ b/python/test/annotator/cleaners/cleaner_test.py
@@ -0,0 +1,73 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+
+import pytest
+
+from sparknlp.annotator.cleaners import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+@pytest.mark.fast
+class CleanerBytesTestSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        eml_data = """Hello ð\x9f\x98\x80"""
+        self.data_set = self.spark.createDataFrame([[eml_data]]).toDF("text")
+
+    def runTest(self):
+        document_assembler = DocumentAssembler().setInputCol("text").setOutputCol("document")
+
+        cleaner = Cleaner() \
+            .setInputCols(["document"]) \
+            .setOutputCol("cleaned") \
+            .setCleanerMode("bytes_string_to_string")
+
+        pipeline = Pipeline().setStages([
+            document_assembler,
+            cleaner
+        ])
+
+        model = pipeline.fit(self.data_set)
+        result = model.transform(self.data_set)
+        result.show(truncate=False)
+
+@pytest.mark.fast
+class CleanerBulletsTestSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        data = [("1.1 This is a very important point",),
+                ("a.1 This is a very important point",),
+                ("1.4.2 This is a very important point",)]
+        self.data_set = self.spark.createDataFrame(data).toDF("text")
+
+    def runTest(self):
+        document_assembler = DocumentAssembler().setInputCol("text").setOutputCol("document")
+
+        cleaner = Cleaner() \
+            .setInputCols(["document"]) \
+            .setOutputCol("cleaned") \
+            .setCleanerMode("clean_ordered_bullets")
+
+        pipeline = Pipeline().setStages([
+            document_assembler,
+            cleaner
+        ])
+
+        model = pipeline.fit(self.data_set)
+        result = model.transform(self.data_set)
+        result.show(truncate=False)
\ No newline at end of file
diff --git a/python/test/annotator/cleaners/extractor_test.py b/python/test/annotator/cleaners/extractor_test.py
new file mode 100644
index 00000000000000..b1243152f2e69d
--- /dev/null
+++ b/python/test/annotator/cleaners/extractor_test.py
@@ -0,0 +1,49 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+
+import pytest
+
+from sparknlp.annotator.cleaners import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+@pytest.mark.fast
+class ExtractorTestSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        eml_data = """from ABC.DEF.local ([ba23::58b5:2236:45g2:88h2]) by
+  \n ABC.DEF.local2 ([ba23::58b5:2236:45g2:88h2%25]) with mapi id\
+  n 32.88.5467.123; Fri, 26 Mar 2021 11:04:09 +1200"""
+        self.data_set = self.spark.createDataFrame([[eml_data]]).toDF("text")
+
+    def runTest(self):
+        document_assembler = DocumentAssembler().setInputCol("text").setOutputCol("document")
+
+        extractor = Extractor() \
+            .setInputCols(["document"]) \
+            .setOutputCol("date") \
+            .setExtractorMode("email_date")
+
+        pipeline = Pipeline().setStages([
+            document_assembler,
+            extractor
+        ])
+
+        model = pipeline.fit(self.data_set)
+        result = model.transform(self.data_set)
+        result.show(truncate=False)
+
diff --git a/python/test/annotator/cv/janus_for_multimodal_test.py b/python/test/annotator/cv/janus_for_multimodal_test.py
new file mode 100644
index 00000000000000..25ed3ac51283d1
--- /dev/null
+++ b/python/test/annotator/cv/janus_for_multimodal_test.py
@@ -0,0 +1,83 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+import pytest
+import os
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from pyspark.sql.functions import lit
+from test.util import SparkSessionForTest,SparkContextForTest
+
+
+class JanusForMultiModalTestSetup(unittest.TestCase):
+
+    def setUp(self):
+        self.images_path = os.getcwd() + "/../src/test/resources/image/"
+        self.spark = SparkContextForTest.spark
+
+        image_df = SparkSessionForTest.spark.read.format("image").load(
+            path=self.images_path
+        )
+
+        self.test_df = image_df.withColumn("text", lit("You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\n\nUser: Describe image in details\n\nAssistant:"))
+
+        image_assembler = ImageAssembler().setInputCol("image").setOutputCol("image_assembler")
+
+        imageClassifier = (JanusForMultiModal \
+            .pretrained() \
+           .setInputCols("image_assembler") \
+           .setOutputCol("answer"))
+
+        self.pipeline = Pipeline(
+            stages=[
+                image_assembler,
+                imageClassifier,
+            ]
+        )
+
+        self.model = self.pipeline.fit(self.test_df)
+
+@pytest.mark.slow
+class JanusForMultiModalTest(JanusForMultiModalTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        result = self.model.transform(self.test_df).collect()
+
+        for row in result:
+            self.assertTrue(row["answer"] != "")
+
+
+@pytest.mark.slow
+class LightJanusForMultiModalTest(JanusForMultiModalTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.model)
+        image_path = self.images_path + "bluetick.jpg"
+
+        print("image_path: " + image_path)
+        annotations_result = light_pipeline.fullAnnotateImage(
+            image_path,
+            "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\n\nUser: Describe image in details\n\nAssistant:"
+        )
+        # print(annotations_result)
+        for result in annotations_result:
+            self.assertTrue(len(result["image_assembler"]) > 0)
+            self.assertTrue(len(result["answer"]) > 0)
\ No newline at end of file
diff --git a/python/test/annotator/cv/llava_for_multimodal_test.py b/python/test/annotator/cv/llava_for_multimodal_test.py
new file mode 100644
index 00000000000000..c927ef76c21dca
--- /dev/null
+++ b/python/test/annotator/cv/llava_for_multimodal_test.py
@@ -0,0 +1,81 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+import pytest
+import os
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from pyspark.sql.functions import lit
+from test.util import SparkSessionForTest,SparkContextForTest
+
+
+class LLAVAForMultiModalTestSetup(unittest.TestCase):
+
+    def setUp(self):
+        self.images_path = os.getcwd() + "/../src/test/resources/image/"
+        self.spark = SparkContextForTest.spark
+        image_df = SparkSessionForTest.spark.read.format("image").load(
+            path=self.images_path
+        )
+
+        self.test_df = image_df.withColumn("text", lit("USER: \n <|image|> \n What's this picture about? \n ASSISTANT:\n"))
+
+        image_assembler = ImageAssembler().setInputCol("image").setOutputCol("image_assembler")
+
+        imageClassifier = LLAVAForMultiModal.pretrained()\
+            .setInputCols("image_assembler") \
+            .setOutputCol("answer")
+
+        self.pipeline = Pipeline(
+            stages=[
+                image_assembler,
+                imageClassifier,
+            ]
+        )
+
+        self.model = self.pipeline.fit(self.test_df)
+
+@pytest.mark.slow
+class LLAVAForMultiModalTest(LLAVAForMultiModalTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        result = self.model.transform(self.test_df).collect()
+
+        for row in result:
+            self.assertTrue(row["answer"] != "")
+
+
+@pytest.mark.slow
+class LightLLAVAForMultiModalTest(LLAVAForMultiModalTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.model)
+        image_path = self.images_path + "bluetick.jpg"
+
+        print("image_path: " + image_path)
+        annotations_result = light_pipeline.fullAnnotateImage(
+            image_path,
+            "USER: \n <|image|> \n What's this picture about? \n ASSISTANT:\n"
+        )
+        print(annotations_result)
+        for result in annotations_result:
+            self.assertTrue(len(result["image_assembler"]) > 0)
+            self.assertTrue(len(result["answer"]) > 0)
\ No newline at end of file
diff --git a/python/test/annotator/cv/mllama_for_multimodal_test.py b/python/test/annotator/cv/mllama_for_multimodal_test.py
new file mode 100644
index 00000000000000..d4dccd966df5cf
--- /dev/null
+++ b/python/test/annotator/cv/mllama_for_multimodal_test.py
@@ -0,0 +1,82 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+import pytest
+import os
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from pyspark.sql.functions import lit
+from test.util import SparkSessionForTest,SparkContextForTest
+
+
+class MLLamaForMultimodalTestSetup(unittest.TestCase):
+
+    def setUp(self):
+        self.images_path = os.getcwd() + "/../src/test/resources/image/"
+        self.spark = SparkContextForTest.spark
+
+        image_df = SparkSessionForTest.spark.read.format("image").load(
+            path=self.images_path
+        )
+
+        self.test_df = image_df.withColumn("text", lit("<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"))
+
+        image_assembler = ImageAssembler().setInputCol("image").setOutputCol("image_assembler")
+
+        imageClassifier = (MLLamaForMultimodal.pretrained() \
+            .setInputCols("image_assembler") \
+            .setOutputCol("answer"))
+
+        self.pipeline = Pipeline(
+            stages=[
+                image_assembler,
+                imageClassifier,
+            ]
+        )
+
+        self.model = self.pipeline.fit(self.test_df)
+
+@pytest.mark.slow
+class MLLamaForMultimodalTest(MLLamaForMultimodalTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        result = self.model.transform(self.test_df).collect()
+
+        for row in result:
+            self.assertTrue(row["answer"] != "")
+
+
+@pytest.mark.slow
+class LightMLLamaForMultimodalTest(MLLamaForMultimodalTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.model)
+        image_path = self.images_path + "bluetick.jpg"
+
+        print("image_path: " + image_path)
+        annotations_result = light_pipeline.fullAnnotateImage(
+            image_path,
+            "<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
+        )
+        # print(annotations_result)
+        for result in annotations_result:
+            self.assertTrue(len(result["image_assembler"]) > 0)
+            self.assertTrue(len(result["answer"]) > 0)
\ No newline at end of file
diff --git a/python/test/annotator/cv/phi3_vision_for_multimodal_test.py b/python/test/annotator/cv/phi3_vision_for_multimodal_test.py
new file mode 100644
index 00000000000000..3612ec332e790b
--- /dev/null
+++ b/python/test/annotator/cv/phi3_vision_for_multimodal_test.py
@@ -0,0 +1,80 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+import pytest
+import os
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from pyspark.sql.functions import lit
+from test.util import SparkSessionForTest,SparkContextForTest
+
+
+class Phi3VisionTestSetup(unittest.TestCase):
+
+    def setUp(self):
+        self.images_path = "file://" + os.getcwd() + "/../src/test/resources/image/"
+        self.spark = SparkContextForTest.spark
+        image_df = SparkSessionForTest.spark.read.format("image").load(
+            path=self.images_path
+        )
+
+        self.test_df = image_df.withColumn("text", lit("<|user|> \n <|image_1|> \n What's this picture about? <|end|>\n <|assistant|>\n"))
+
+        image_assembler = ImageAssembler().setInputCol("image").setOutputCol("image_assembler")
+
+        imageClassifier = Phi3Vision.pretrained() \
+            .setInputCols("image_assembler") \
+            .setOutputCol("answer")
+
+        self.pipeline = Pipeline(
+            stages=[
+                image_assembler,
+                imageClassifier,
+            ]
+        )
+
+        self.model = self.pipeline.fit(self.test_df)
+
+@pytest.mark.slow
+class Phi3VisionTest(Phi3VisionTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        result = self.model.transform(self.test_df).collect()
+
+        for row in result:
+            self.assertTrue(row["answer"] != "")
+
+
+@pytest.mark.slow
+class LightPhi3VisionTest(Phi3VisionTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.model)
+        image_path = self.images_path + "bluetick.jpg"
+        print("image_path: " + image_path)
+        annotations_result = light_pipeline.fullAnnotateImage(
+            image_path,
+            "<|user|> \n <|image_1|> \n What's this picture about? <|end|>\n <|assistant|>\n"
+        )
+        print(annotations_result)
+        for result in annotations_result:
+            self.assertTrue(len(result["image_assembler"]) > 0)
+            self.assertTrue(len(result["answer"]) > 0)
\ No newline at end of file
diff --git a/python/test/annotator/cv/qwen2vl_transformer_test.py b/python/test/annotator/cv/qwen2vl_transformer_test.py
new file mode 100644
index 00000000000000..e2ca01d68d9521
--- /dev/null
+++ b/python/test/annotator/cv/qwen2vl_transformer_test.py
@@ -0,0 +1,83 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+import pytest
+import os
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from pyspark.sql.functions import lit
+from test.util import SparkSessionForTest
+from test.util import SparkContextForTest
+
+
+class Qwen2VLTransformerTestSetup(unittest.TestCase):
+
+    def setUp(self):
+        self.images_path = os.getcwd() + "/../src/test/resources/image/"
+        image_df = SparkSessionForTest.spark.read.format("image").load(
+            path=self.images_path
+        )
+        self.spark = SparkContextForTest.spark
+        self.test_df = image_df.withColumn("text", lit("<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n"))
+
+        image_assembler = ImageAssembler().setInputCol("image").setOutputCol("image_assembler")
+
+        imageClassifier = Qwen2VLTransformer.pretrained() \
+            .setInputCols("image_assembler") \
+            .setOutputCol("answer")
+
+        self.pipeline = Pipeline(
+            stages=[
+                image_assembler,
+                imageClassifier,
+            ]
+        )
+
+        self.model = self.pipeline.fit(self.test_df)
+
+
+
+@pytest.mark.slow
+class Qwen2VLTransformerTest(Qwen2VLTransformerTestSetup, unittest.TestCase):
+
+   def setUp(self):
+       super().setUp()
+
+   def runTest(self):
+       result = self.model.transform(self.test_df).collect()
+
+       for row in result:
+           self.assertTrue(row["answer"] != "")
+           print(row["answer"])
+
+
+@pytest.mark.slow
+class LightQwen2VLTransformerTest(Qwen2VLTransformerTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+    def runTest(self):
+        light_pipeline = LightPipeline(self.model)
+        image_path = self.images_path + "bluetick.jpg"
+        annotations_result = light_pipeline.fullAnnotateImage(
+            image_path,
+            "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n"
+        )
+
+        for result in annotations_result:
+            self.assertTrue(len(result["image_assembler"]) > 0)
+            self.assertTrue(len(result["answer"]) > 0)
+            print(result["answer"])
\ No newline at end of file
diff --git a/python/test/annotator/embeddings/auto_gguf_embeddings_test.py b/python/test/annotator/embeddings/auto_gguf_embeddings_test.py
index 72b82c19b6e830..0f9ebe0b4ea247 100644
--- a/python/test/annotator/embeddings/auto_gguf_embeddings_test.py
+++ b/python/test/annotator/embeddings/auto_gguf_embeddings_test.py
@@ -47,6 +47,7 @@ def runTest(self):
             .setOutputCol("embeddings")
             .setBatchSize(4)
             .setNGpuLayers(99)
+            .setNCtx(4096)
         )
 
         pipeline = Pipeline().setStages([self.document_assembler, model])
@@ -57,7 +58,7 @@ def runTest(self):
             embds = row["embeddings"][0]
             assert embds is not None
             assert (
-                sum(embds) > 0
+                    sum(embds) > 0
             ), "Embeddings should not be zero. Was there an error on llama.cpp side?"
 
 
@@ -83,10 +84,7 @@ def setUp(self):
 
     def runTest(self):
         model = (
-            # AutoGGUFEmbeddings.pretrained()
-            AutoGGUFEmbeddings.loadSavedModel(
-                "models/nomic-embed-text-v1.5.Q8_0.gguf", SparkContextForTest.spark
-            )
+            AutoGGUFEmbeddings.pretrained()
             .setInputCols("document")
             .setOutputCol("embeddings")
             .setBatchSize(4)
@@ -102,5 +100,70 @@ def runTest(self):
             embds = row["embeddings"][0]
             assert embds is not None
             assert (
-                sum(embds) > 0
+                    sum(embds) > 0
+            ), "Embeddings should not be zero. Was there an error on llama.cpp side?"
+
+
+@pytest.mark.slow
+class AutoGGUFEmbeddingsErrorHandlingTestSpec(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        self.document_assembler = (
+            DocumentAssembler().setInputCol("text").setOutputCol("document")
+        )
+        self.long_data_copies = 16
+        self.long_text = "All work and no play makes Jack a dull boy" * 100
+        self.long_data = self.spark.createDataFrame(
+            [self.long_text] * self.long_data_copies, schema="string"
+        ).toDF("text").repartition(4)
+
+    def runTest(self):
+        model = (
+            AutoGGUFEmbeddings.pretrained()
+            .setInputCols("document")
+            .setOutputCol("embeddings")
+            .setBatchSize(4)
+        )
+        pipeline = Pipeline().setStages([self.document_assembler, model])
+        results = pipeline.fit(self.long_data).transform(self.long_data)
+        collected = results.select("embeddings").collect()
+
+        assert len(collected) == self.long_data_copies
+        for row in collected:
+            metadata = row[0][0]["metadata"]
+            assert "llamacpp_exception" in metadata, "llamacpp_exception should be present"
+
+
+@pytest.mark.slow
+class AutoGGUFEmbeddingsLongTextTestSpec(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        self.document_assembler = (
+            DocumentAssembler().setInputCol("text").setOutputCol("document")
+        )
+        self.long_data_copies = 16
+        self.long_text = "All work and no play makes Jack a dull boy" * 100
+        self.long_data = self.spark.createDataFrame(
+            [self.long_text] * self.long_data_copies, schema="string"
+        ).toDF("text").repartition(4)
+
+    def runTest(self):
+        model = (
+            AutoGGUFEmbeddings.pretrained()
+            .setInputCols("document")
+            .setOutputCol("embeddings")
+            .setBatchSize(4)
+            .setNUbatch(2048)
+            .setNBatch(2048)
+        )
+        pipeline = Pipeline().setStages([self.document_assembler, model])
+        results = pipeline.fit(self.long_data).transform(self.long_data)
+        collected = results.select("embeddings").collect()
+
+        assert len(collected) == self.long_data_copies, "Should return the same number of rows"
+        for row in collected:
+            embds = row[0][0]["embeddings"]
+            assert embds is not None
+            assert (
+                    sum(embds) > 0
             ), "Embeddings should not be zero. Was there an error on llama.cpp side?"
diff --git a/python/test/annotator/seq2seq/auto_gguf_model_test.py b/python/test/annotator/seq2seq/auto_gguf_model_test.py
index e6553bc509e5ff..cb014591ae33bc 100644
--- a/python/test/annotator/seq2seq/auto_gguf_model_test.py
+++ b/python/test/annotator/seq2seq/auto_gguf_model_test.py
@@ -102,7 +102,6 @@ def runTest(self):
         model.setGpuSplitMode("NONE")
         model.setMainGpu(0)
         model.setTensorSplit([])
-        model.setNBeams(0)
         model.setGrpAttnN(1)
         model.setGrpAttnW(512)
         model.setRopeFreqBase(1.0)
@@ -115,11 +114,10 @@ def runTest(self):
         model.setDefragmentationThreshold(-1.0)
         model.setNumaStrategy("DISTRIBUTE")
         model.setRopeScalingType("UNSPECIFIED")
-        model.setPoolingType("UNSPECIFIED")
+        model.setPoolingType("NONE")
         model.setModelDraft("")
         model.setLookupCacheStaticFilePath("/tmp/sparknlp-llama-cpp-cache")
         model.setLookupCacheDynamicFilePath("/tmp/sparknlp-llama-cpp-cache")
-        model.setLoraBase("")
         model.setEmbedding(False)
         model.setFlashAttention(False)
         model.setInputPrefixBos(False)
@@ -171,6 +169,7 @@ def runTest(self):
         pipeline = Pipeline().setStages([document_assembler, model])
         results = pipeline.fit(data).transform(data)
 
+        # Can fail due to bogus parameters, but at least we are testing the setters
         results.select("completions").show(truncate=False)
 
 
@@ -189,3 +188,52 @@ def runTest(self):
         metadata = model.getMetadata()
         assert len(metadata) > 0
         print(eval(metadata))
+
+
+@pytest.mark.slow
+class AutoGGUFModelErrorMessagesTestSpec(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        self.data = (
+            self.spark.createDataFrame(
+                [
+                    ["The moons of Jupiter are "],
+                    ["Earth is "],
+                    ["The moon is "],
+                    ["The sun is "],
+                ]
+            )
+            .toDF("text")
+            .repartition(1)
+        )
+
+        self.document_assembler = (
+            DocumentAssembler().setInputCol("text").setOutputCol("document")
+        )
+
+    def runTest(self):
+        model = (
+            AutoGGUFModel.pretrained()
+            .setInputCols("document")
+            .setOutputCol("completions")
+            .setGrammar("root ::= (")  # Invalid grammar
+        )
+
+        pipeline = Pipeline().setStages([self.document_assembler, model])
+        result = pipeline.fit(self.data).transform(self.data)
+
+        collected = result.select("completions").collect()
+
+        self.assertEqual(
+            len(collected), self.data.count(), "Should return the same number of rows"
+        )
+        for row in collected:
+            annotation = row[0][0]
+            self.assertEqual(
+                annotation["result"], "", "Completions should be empty"
+            )
+            self.assertIn(
+                "llamacpp_exception",
+                annotation["metadata"],
+                "llamacpp_exception should be present",
+            )
diff --git a/python/test/annotator/seq2seq/auto_gguf_vision_model_test.py b/python/test/annotator/seq2seq/auto_gguf_vision_model_test.py
new file mode 100644
index 00000000000000..c0509a59841ba7
--- /dev/null
+++ b/python/test/annotator/seq2seq/auto_gguf_vision_model_test.py
@@ -0,0 +1,86 @@
+#  Copyright 2017-2023 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+
+import pytest
+from pyspark.sql.functions import lit
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+@pytest.mark.slow
+class AutoGGUFVisionModelTestSpec(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+
+    def runTest(self):
+        documentAssembler = (
+            DocumentAssembler().setInputCol("caption").setOutputCol("caption_document")
+        )
+        imageAssembler = (
+            ImageAssembler().setInputCol("image").setOutputCol("image_assembler")
+        )
+        imagesPath = "../src/test/resources/image/"
+        data = ImageAssembler.loadImagesAsBytes(self.spark, imagesPath).withColumn(
+            "caption", lit("Caption this image.")
+        )  # Add a caption to each image.
+        nPredict = 40
+        model = (
+            AutoGGUFVisionModel.pretrained()
+            .setInputCols(["caption_document", "image_assembler"])
+            .setOutputCol("completions")
+            .setChatTemplate("vicuna")
+            .setBatchSize(4)
+            .setNGpuLayers(99)
+            .setNCtx(4096)
+            .setMinKeep(0)
+            .setMinP(0.05)
+            .setNPredict(nPredict)
+            .setNProbs(0)
+            .setPenalizeNl(False)
+            .setRepeatLastN(256)
+            .setRepeatPenalty(1.18)
+            .setStopStrings(["", "Llama:", "User:"])
+            .setTemperature(0.05)
+            .setTfsZ(1)
+            .setTypicalP(1)
+            .setTopK(40)
+            .setTopP(0.95)
+        )
+        pipeline = Pipeline().setStages([documentAssembler, imageAssembler, model])
+        # pipeline.fit(data).transform(data).selectExpr(
+        #     "reverse(split(image.origin, '/'))[0] as image_name", "completions.result"
+        # ).show(truncate=False)
+
+        results = pipeline.fit(data).transform(data).collect()
+
+        expectedWords = {
+            "bluetick.jpg": "dog",
+            "chihuahua.jpg": "dog",
+            "egyptian_cat.jpeg": "cat",
+            "hen.JPEG": "chick",
+            "hippopotamus.JPEG": "hippo",
+            "junco.JPEG": "bird",
+            "ostrich.JPEG": "ostrich",
+            "ox.JPEG": "bull",
+            "palace.JPEG": "room",
+            "tractor.JPEG": "tractor",
+        }
+
+        for result in results:
+            image_name = result["image_assembler"][0]["origin"].split("/")[-1]
+            completion = result["completions"][0]["result"]
+            assert expectedWords[image_name] in completion, f"Expected '{expectedWords[image_name]}' in '{completion}'"
diff --git a/python/test/annotator/seq2seq/cohere_transformer_test.py b/python/test/annotator/seq2seq/cohere_transformer_test.py
new file mode 100644
index 00000000000000..fb3f2f81b978de
--- /dev/null
+++ b/python/test/annotator/seq2seq/cohere_transformer_test.py
@@ -0,0 +1,55 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+
+import pytest
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+@pytest.mark.slow
+class CoHereTransformerTextGenerationTestSpec(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+
+    def runTest(self):
+        data = self.spark.createDataFrame([
+            (
+                1,
+                "<|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>"
+            )
+        ]).toDF("id", "text")
+        document_assembler = DocumentAssembler() \
+            .setInputCol("text") \
+            .setOutputCol("documents")
+
+        CoHere = CoHereTransformer \
+            .pretrained() \
+            .setMaxOutputLength(50) \
+            .setDoSample(False) \
+            .setBeamSize(1) \
+            .setTemperature(0.6) \
+            .setTopK(-1) \
+            .setTopP(0.9) \
+            .setStopTokenIds([255001]) \
+            .setInputCols(["documents"]) \
+            .setOutputCol("generation")
+
+        pipeline = Pipeline().setStages([document_assembler, CoHere])
+        results = (pipeline.fit(data).transform(data))
+
+        results.select("generation.result").show(truncate=False)
+
diff --git a/python/test/annotator/seq2seq/olmo_transformer_test.py b/python/test/annotator/seq2seq/olmo_transformer_test.py
new file mode 100644
index 00000000000000..8c09b3cfa2e4cf
--- /dev/null
+++ b/python/test/annotator/seq2seq/olmo_transformer_test.py
@@ -0,0 +1,47 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+
+import pytest
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+@pytest.mark.slow
+class OLMoTransformerTextGenerationTestSpec(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+
+    def runTest(self):
+        data = self.spark.createDataFrame([
+            [1, """Leonardo Da Vinci invented the microscope?""".strip().replace("\n", " ")]]).toDF("id", "text")
+
+        document_assembler = DocumentAssembler() \
+            .setInputCol("text") \
+            .setOutputCol("documents")
+
+        olmo = OLMoTransformer \
+            .pretrained() \
+            .setMaxOutputLength(50) \
+            .setDoSample(False) \
+            .setInputCols(["documents"]) \
+            .setOutputCol("generation")
+
+        pipeline = Pipeline().setStages([document_assembler, olmo])
+        results = pipeline.fit(data).transform(data)
+
+        results.select("generation.result").show(truncate=False)
+
diff --git a/python/test/partition/__init__.py b/python/test/partition/__init__.py
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/python/test/partition/partition_test.py b/python/test/partition/partition_test.py
new file mode 100644
index 00000000000000..b8caca4bc8c3e5
--- /dev/null
+++ b/python/test/partition/partition_test.py
@@ -0,0 +1,144 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import os
+import unittest
+import pytest
+from sparknlp.partition.partition import Partition
+
+
+@pytest.mark.fast
+class PartitionTextTesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.txt_directory = f"file:///{os.getcwd()}/../src/test/resources/reader/txt"
+
+    def runTest(self):
+        text_df = Partition(content_type = "text/plain").partition(self.txt_directory)
+        text_file_df = Partition().partition(f"{self.txt_directory}/simple-text.txt")
+
+        self.assertTrue(text_df.select("txt").count() > 0)
+        self.assertTrue(text_file_df.select("txt").count() > 0)
+
+
+@pytest.mark.fast
+class PartitionWordTesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.word_directory = f"file:///{os.getcwd()}/../src/test/resources/reader/doc"
+
+    def runTest(self):
+        doc_df = Partition(content_type = "application/msword").partition(self.word_directory)
+        doc_file_df = Partition().partition(f"{self.word_directory}/fake_table.docx")
+
+        self.assertTrue(doc_df.select("doc").count() > 0)
+        self.assertTrue(doc_file_df.select("doc").count() > 0)
+
+
+@pytest.mark.fast
+class PartitionExcelTesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.excel_directory = f"file:///{os.getcwd()}/../src/test/resources/reader/xls"
+
+    def runTest(self):
+        xls_df = Partition(content_type = "application/vnd.ms-excel").partition(self.excel_directory)
+        xls_file_df = Partition().partition(f"{self.excel_directory}/vodafone.xlsx")
+
+        self.assertTrue(xls_df.select("xls").count() > 0)
+        self.assertTrue(xls_file_df.select("xls").count() > 0)
+
+
+@pytest.mark.fast
+class PartitionPowerPointTesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.ppt_directory = f"file:///{os.getcwd()}/../src/test/resources/reader/ppt"
+
+    def runTest(self):
+        ppt_df = Partition(content_type = "application/vnd.ms-powerpoint").partition(self.ppt_directory)
+        ppt_file_df = Partition().partition(f"{self.ppt_directory}/fake-power-point.pptx")
+
+        self.assertTrue(ppt_df.select("ppt").count() > 0)
+        self.assertTrue(ppt_file_df.select("ppt").count() > 0)
+
+
+@pytest.mark.fast
+class PartitionEmailTesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.eml_directory = f"file:///{os.getcwd()}/../src/test/resources/reader/email"
+
+    def runTest(self):
+        eml_df = Partition(content_type = "message/rfc822").partition(self.eml_directory)
+        eml_file_df = Partition().partition(f"{self.eml_directory}/test-several-attachments.eml")
+
+        self.assertTrue(eml_df.select("email").count() > 0)
+        self.assertTrue(eml_file_df.select("email").count() > 0)
+
+
+@pytest.mark.fast
+class PartitionHtmlTesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.html_directory = f"file:///{os.getcwd()}/../src/test/resources/reader/html"
+
+    def runTest(self):
+        html_df = Partition(content_type = "text/html").partition(self.html_directory)
+        html_file_df = Partition().partition(f"{self.html_directory}/fake-html.html")
+
+        self.assertTrue(html_df.select("html").count() > 0)
+        self.assertTrue(html_file_df.select("html").count() > 0)
+
+
+@pytest.mark.fast
+class PartitionUrlTesSpec(unittest.TestCase):
+
+    def runTest(self):
+        url_df = Partition().partition("https://www.wikipedia.org", headers={"User-Agent": "Mozilla/5.0"})
+        urls_df = Partition().partition_urls(["https://www.wikipedia.org", "https://example.com/"])
+
+        self.assertTrue(url_df.select("html").count() > 0)
+        self.assertTrue(urls_df.select("html").count() > 0)
+
+
+@pytest.mark.fast
+class PartitionPdfTesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.html_directory = f"file:///{os.getcwd()}/../src/test/resources/reader/pdf"
+
+    def runTest(self):
+        pdf_df = Partition(content_type = "application/pdf").partition(self.html_directory)
+        pdf_file_df = Partition().partition(f"{self.html_directory}/text_3_pages.pdf")
+
+        self.assertTrue(pdf_df.select("text").count() > 0)
+        self.assertTrue(pdf_file_df.select("text").count() > 0)
+
+@pytest.mark.fast
+class PartitionTextInMemoryTesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.raw_text = (
+            "The big brown fox\n"
+            "was walking down the lane.\n"
+            "\n"
+            "At the end of the lane,\n"
+            "the fox met a bear."
+        )
+
+    def runTest(self):
+        text_df = Partition(group_broken_paragraphs=True).partition_text(text = self.raw_text )
+        text_df.show(truncate=False)
+
+        self.assertTrue(text_df.select("txt").count() > 0)
\ No newline at end of file
diff --git a/python/test/reader/pdf_to_text_test.py b/python/test/reader/pdf_to_text_test.py
new file mode 100644
index 00000000000000..771b0c8f01bd07
--- /dev/null
+++ b/python/test/reader/pdf_to_text_test.py
@@ -0,0 +1,48 @@
+
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import unittest
+
+import pytest
+import os
+
+from sparknlp.reader.pdf_to_text import PdfToText
+from test.util import SparkContextForTest
+from pyspark.ml import Pipeline
+
+
+class PdfToTextTestSetup(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+        self.spark.conf.set("spark.sql.legacy.allowUntypedScalaUDF", "true")
+
+@pytest.mark.slow
+class PdfToTextTest(PdfToTextTestSetup, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.pdf_to_text = PdfToText().setStoreSplittedPdf(True)
+        pdf_path = os.getcwd() + "/../src/test/resources/reader/pdf"
+        self.data_frame = self.spark.read.format("binaryFile").load(pdf_path)
+
+    def test_run(self):
+        pipeline = Pipeline(stages=[self.pdf_to_text])
+        pipeline_model = pipeline.fit(self.data_frame)
+        pdf_df = pipeline_model.transform(self.data_frame)
+        pdf_df.show()
+
+        self.assertTrue(pdf_df.count() > 0)
+
+
diff --git a/python/test/sparknlp_test.py b/python/test/sparknlp_test.py
index 3b2ee58e22bfce..c2baa14fec213d 100644
--- a/python/test/sparknlp_test.py
+++ b/python/test/sparknlp_test.py
@@ -86,4 +86,57 @@ def runTest(self):
         word_df = sparknlp.read().doc(self.word_file)
         word_df.show()
 
-        self.assertTrue(word_df.select("doc").count() > 0)
\ No newline at end of file
+        self.assertTrue(word_df.select("doc").count() > 0)
+
+@pytest.mark.fast
+class SparkNLPTestExcelFilesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.data = SparkContextForTest.data
+        self.excel_file = f"file:///{os.getcwd()}/../src/test/resources/reader/xls/vodafone.xlsx"
+
+    def runTest(self):
+        excel_df = sparknlp.read().xls(self.excel_file)
+        excel_df.show()
+
+        self.assertTrue(excel_df.select("xls").count() > 0)
+
+@pytest.mark.fast
+class SparkNLPTestPowerPointFilesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.data = SparkContextForTest.data
+        self.ppt_file = f"file:///{os.getcwd()}/../src/test/resources/reader/ppt"
+
+    def runTest(self):
+        ppt_df = sparknlp.read().ppt(self.ppt_file)
+        ppt_df.show()
+
+        self.assertTrue(ppt_df.select("ppt").count() > 0)
+
+@pytest.mark.fast
+class SparkNLPTestTXTFilesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.data = SparkContextForTest.data
+        self.txt_file = f"file:///{os.getcwd()}/../src/test/resources/reader/txt/simple-text.txt"
+
+    def runTest(self):
+        txt_df = sparknlp.read().txt(self.txt_file)
+        txt_df.show()
+
+        self.assertTrue(txt_df.select("txt").count() > 0)
+
+
+@pytest.mark.fast
+class SparkNLPTestXMLFilesSpec(unittest.TestCase):
+
+    def setUp(self):
+        self.data = SparkContextForTest.data
+        self.xml_files = f"file:///{os.getcwd()}/../src/test/resources/reader/xml"
+
+    def runTest(self):
+        xml_df = sparknlp.read().xml(self.xml_files)
+        xml_df.show()
+
+        self.assertTrue(xml_df.select("xml").count() > 0)
\ No newline at end of file
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/AlbertClassification.scala b/src/main/scala/com/johnsnowlabs/ml/ai/AlbertClassification.scala
index 24075e80801347..b6ff6167b87efa 100644
--- a/src/main/scala/com/johnsnowlabs/ml/ai/AlbertClassification.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/AlbertClassification.scala
@@ -359,6 +359,96 @@ private[johnsnowlabs] class AlbertClassification(
     (startScores, endScores)
   }
 
+  override def tagSpanMultipleChoice(batch: Seq[Array[Int]]): Array[Float] = {
+    val logits = detectedEngine match {
+      case ONNX.name => computeLogitsMultipleChoiceWithOnnx(batch)
+      case Openvino.name => computeLogitsMultipleChoiceWithOv(batch)
+    }
+
+    calculateSoftmax(logits)
+  }
+
+  private def computeLogitsMultipleChoiceWithOv(batch: Seq[Array[Int]]): Array[Float] = {
+    val (numChoices, sequenceLength) = (batch.length, batch.head.length)
+    // batch_size, num_choices, sequence_length
+    val shape = Some(Array(1, numChoices, sequenceLength))
+    val (tokenTensors, maskTensors, segmentTensors) =
+      PrepareEmbeddings.prepareOvLongBatchTensorsWithSegment(
+        batch,
+        sequenceLength,
+        numChoices,
+        sentencePadTokenId,
+        shape)
+
+    val compiledModel = openvinoWrapper.get.getCompiledModel()
+    val inferRequest = compiledModel.create_infer_request()
+    inferRequest.set_tensor("input_ids", tokenTensors)
+    inferRequest.set_tensor("attention_mask", maskTensors)
+    inferRequest.set_tensor("token_type_ids", segmentTensors)
+
+    inferRequest.infer()
+
+    try {
+      try {
+        val logits = inferRequest
+          .get_output_tensor()
+          .data()
+
+        logits
+      }
+    } catch {
+      case e: Exception =>
+        // Log the exception as a warning
+        logger.warn("Exception in computeLogitsMultipleChoiceWithOv", e)
+        // Rethrow the exception to propagate it further
+        throw e
+    }
+  }
+
+  private def computeLogitsMultipleChoiceWithOnnx(batch: Seq[Array[Int]]): Array[Float] = {
+    val sequenceLength = batch.head.length
+    val inputIds = Array(batch.map(x => x.map(_.toLong)).toArray)
+    val attentionMask = Array(
+      batch.map(sentence => sentence.map(x => if (x == 0L) 0L else 1L)).toArray)
+    val tokenTypeIds = Array(batch.map(_ => Array.fill(sequenceLength)(0L)).toArray)
+
+    val (ortSession, ortEnv) = onnxWrapper.get.getSession(onnxSessionOptions)
+    val tokenTensors = OnnxTensor.createTensor(ortEnv, inputIds)
+    val maskTensors = OnnxTensor.createTensor(ortEnv, attentionMask)
+    val segmentTensors = OnnxTensor.createTensor(ortEnv, tokenTypeIds)
+
+    val inputs =
+      Map(
+        "input_ids" -> tokenTensors,
+        "attention_mask" -> maskTensors,
+        "token_type_ids" -> segmentTensors).asJava
+
+    try {
+      val output = ortSession.run(inputs)
+      try {
+
+        val logits = output
+          .get("logits")
+          .get()
+          .asInstanceOf[OnnxTensor]
+          .getFloatBuffer
+          .array()
+
+        tokenTensors.close()
+        maskTensors.close()
+        segmentTensors.close()
+
+        logits
+      } finally if (output != null) output.close()
+    } catch {
+      case e: Exception =>
+        // Log the exception as a warning
+        println("Exception in computeLogitsMultipleChoiceWithOnnx: ", e)
+        // Rethrow the exception to propagate it further
+        throw e
+    }
+  }
+
   private def computeLogitsWithTF(
       batch: Seq[Array[Int]],
       maxSentenceLength: Int): (Array[Float], Array[Float]) = {
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/CoHere.scala b/src/main/scala/com/johnsnowlabs/ml/ai/CoHere.scala
new file mode 100644
index 00000000000000..314fd63548963d
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/CoHere.scala
@@ -0,0 +1,487 @@
+/*
+ * Copyright 2017 - 2023  John Snow Labs
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package com.johnsnowlabs.ml.ai
+
+import ai.onnxruntime.{OnnxTensor, OrtEnvironment, OrtSession}
+import com.johnsnowlabs.ml.ai.util.Generation.{Generate, GenerationConfig}
+import com.johnsnowlabs.ml.onnx.OnnxSession
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.onnx.TensorResources.implicits._
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper
+import com.johnsnowlabs.ml.util.{ONNX, Openvino, TensorFlow}
+import com.johnsnowlabs.nlp.Annotation
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp.annotators.common.SentenceSplit
+import com.johnsnowlabs.nlp.annotators.tokenizer.bpe.{
+  BpeTokenizer,
+  LLAMA3Tokenizer,
+  SpecialTokens
+}
+import org.intel.openvino.InferRequest
+import org.tensorflow.{Session, Tensor}
+
+import scala.collection.JavaConverters._
+
+private[johnsnowlabs] class CoHere(
+    val onnxWrappers: Option[DecoderWrappers],
+    val openvinoWrapper: Option[OpenvinoWrapper],
+    merges: Map[(String, String), Int],
+    vocabulary: Map[String, Int],
+    addedTokens: Map[String, Int],
+    generationConfig: GenerationConfig)
+    extends Serializable
+    with Generate {
+
+  private val onnxSessionOptions: Map[String, String] = new OnnxSession().getSessionOptions
+  val detectedEngine: String =
+    if (onnxWrappers.isDefined) ONNX.name
+    else if (openvinoWrapper.isDefined) Openvino.name
+    else ONNX.name
+  private var nextPositionId: Option[Array[Long]] = None
+  private val GenerationConfig(
+    bosTokenId: Int,
+    paddingTokenId: Int,
+    eosTokenId: Int,
+    vocabSize: Int,
+    beginSuppressTokens,
+    suppressTokenIds,
+    forcedDecoderIds) =
+    generationConfig
+
+  val reversedVocabulary: Map[Int, String] = vocabulary.map(_.swap)
+  val specialTokens: SpecialTokens = SpecialTokens(
+    vocabulary,
+    startTokenString = reversedVocabulary(bosTokenId),
+    endTokenString = reversedVocabulary(eosTokenId),
+    unkTokenString = reversedVocabulary(eosTokenId),
+    maskTokenString = reversedVocabulary(eosTokenId),
+    padTokenString = reversedVocabulary(eosTokenId),
+    additionalStrings = addedTokens.keys.toArray)
+
+  val bpeTokenizer: LLAMA3Tokenizer = BpeTokenizer
+    .forModel(
+      "llama3",
+      merges = merges,
+      vocab = vocabulary,
+      specialTokens = Some(specialTokens),
+      addPrefixSpaceToSentence = true)
+    .asInstanceOf[LLAMA3Tokenizer]
+
+  /** Decode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of decoded sentences
+    */
+  def decode(sentences: Array[Array[Int]]): Seq[String] = {
+    sentences.map(s => bpeTokenizer.decodeTokens(s.map(_.toInt)))
+  }
+
+  /** Encode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of encoded sentences
+    */
+  def encode(sentences: Seq[Annotation]): Seq[Array[Int]] = {
+    SentenceSplit
+      .unpack(sentences)
+      .map(s => {
+        val sentWithTask = s
+        bpeTokenizer
+          .tokenize(sentWithTask)
+          .map(bpeTokenizer.encode)
+          .flatMap(_.map(_.pieceId))
+      })
+  }
+
+  def tag(
+      batch: Seq[Array[Int]],
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long],
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int,
+      stopTokenIds: Array[Int]): Array[Array[Int]] = {
+    val ignoreTokenIdsInt = ignoreTokenIds
+    val expandedDecoderInputsVals = batch
+    val sequencesLength = expandedDecoderInputsVals.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+
+    val numReturn_sequences = 1
+    // from config
+
+    var effectiveBatch_size = 1
+    var effectiveBatch_mult = 1
+
+    if (doSample) {
+      effectiveBatch_size = expandedDecoderInputsVals.length * numReturn_sequences
+      effectiveBatch_mult = numReturn_sequences
+    } else {
+      effectiveBatch_size = expandedDecoderInputsVals.length
+      effectiveBatch_mult = 1
+    }
+
+    // Run the prompt through the decoder and get the past
+//    val decoderOutputs =
+//      generateGreedyOnnx(
+//        expandedDecoderInputsVals.toArray,
+//        (encoderSession, env),
+//        maxOutputLength)
+    val (decoderEncoderStateTensors, encoderAttentionMaskTensors, session) =
+      detectedEngine match {
+        case ONNX.name =>
+          // dummy tensors for decoder encode state and attention mask
+          val (encoderSession, env) = onnxWrappers.get.decoder.getSession(onnxSessionOptions)
+          (
+            Right(OnnxTensor.createTensor(env, Array(0))),
+            Right(OnnxTensor.createTensor(env, Array(1))),
+            Right((env, encoderSession)))
+        case Openvino.name =>
+          // not needed
+          (null, null, null)
+      }
+    val ovInferRequest: Option[InferRequest] = detectedEngine match {
+      case ONNX.name => None
+      case Openvino.name => Some(openvinoWrapper.get.getCompiledModel().create_infer_request())
+    }
+    // output with beam search
+    val modelOutputs = generate(
+      batch,
+      decoderEncoderStateTensors,
+      encoderAttentionMaskTensors,
+      expandedDecoderInputsVals.toArray,
+      maxOutputLength + maxSentenceLength,
+      minOutputLength,
+      doSample,
+      beamSize,
+      1,
+      temperature,
+      topK,
+      topP,
+      repetitionPenalty,
+      noRepeatNgramSize,
+      this.vocabSize,
+      this.eosTokenId,
+      this.paddingTokenId,
+      randomSeed,
+      ignoreTokenIdsInt,
+      session,
+      applySoftmax = false,
+      ovInferRequest = ovInferRequest,
+      stopTokenIds = stopTokenIds)
+
+//    decoderOutputs
+    modelOutputs
+  }
+
+  def predict(
+      sentences: Seq[Annotation],
+      batchSize: Int,
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long] = None,
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int,
+      stopTokenIds: Array[Int]): Seq[Annotation] = {
+
+    val batchDecoder = sentences.grouped(batchSize).toArray.flatMap { batch =>
+      val batchSP = encode(batch)
+      val spIds = tag(
+        batchSP,
+        minOutputLength,
+        maxOutputLength,
+        doSample,
+        temperature,
+        topK,
+        topP,
+        repetitionPenalty,
+        noRepeatNgramSize,
+        randomSeed,
+        ignoreTokenIds,
+        beamSize,
+        maxInputLength,
+        stopTokenIds)
+
+      decode(spIds)
+
+    }
+
+    var sentBegin, nextSentEnd = 0
+    val annotations = batchDecoder.zip(sentences).map { case (content, sent) =>
+      nextSentEnd += content.length - 1
+      val annots = new Annotation(
+        annotatorType = DOCUMENT,
+        begin = sentBegin,
+        end = nextSentEnd,
+        result = content,
+        metadata = sent.metadata)
+      sentBegin += nextSentEnd + 1
+      annots
+    }
+    annotations
+  }
+
+  private def getDecoderOutputsWithPast(
+      inputIds: Array[Array[Int]],
+      decoderPast: Map[String, OnnxTensor],
+      onnxSession: (OrtSession, OrtEnvironment))
+      : (Array[Array[Float]], Map[String, OnnxTensor]) = {
+    val (session, env) = onnxSession
+
+    val lastTokens: Array[Array[Long]] =
+      inputIds.map { tokenIds =>
+        Array(tokenIds.last.toLong)
+      }
+
+    val lastTokensTensor: OnnxTensor =
+      OnnxTensor.createTensor(env, lastTokens)
+    val decoderAttentionMask: OnnxTensor =
+      OnnxTensor.createTensor(env, lastTokens.map(_.map(_ => 1L)))
+    val decoderWithPastInputs: java.util.Map[String, OnnxTensor] = (Map(
+      OnnxSignatures.decoderInputIDs -> lastTokensTensor,
+      OnnxSignatures.decoderAttentionMask -> decoderAttentionMask) ++ decoderPast).asJava
+    val sessionOutput = session.run(decoderWithPastInputs)
+    val logits = sessionOutput.getFloatArray(OnnxSignatures.decoderOutput)
+    val decoderPresent = sessionOutput.getOnnxTensors(OnnxSignatures.decoderPresent)
+    lastTokensTensor.close()
+    val batchLogits = logits.grouped(vocabSize).toArray
+    (batchLogits, decoderPresent)
+
+  }
+
+  override def getModelOutput(
+      encoderInputIds: Seq[Array[Int]],
+      decoderInputIds: Seq[Array[Int]],
+      decoderEncoderStateTensors: Either[Tensor, OnnxTensor],
+      encoderAttentionMaskTensors: Either[Tensor, OnnxTensor],
+      maxLength: Int,
+      session: Either[Session, (OrtEnvironment, OrtSession)],
+      ovInferRequest: Option[InferRequest]): Array[Array[Float]] = {
+    detectedEngine match {
+      case TensorFlow.name =>
+        // not implemented yet
+        Array()
+      case ONNX.name =>
+        val (env, decoderSession) = session.right.get
+        val decoderOutputs =
+          getDecoderOutputs(decoderInputIds.toArray, onnxSession = (decoderSession, env))
+        decoderOutputs
+      case Openvino.name =>
+        val decoderOutputs =
+          getDecoderOutputsOv(
+            encoderInputIds.toArray,
+            decoderInputIds.toArray,
+            ovInferRequest.get)
+        decoderOutputs
+    }
+  }
+
+  private def getDecoderOutputsOv(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      inferRequest: InferRequest): (Array[Array[Float]]) = {
+
+    val (inputIdsLong, inputPositionIDsLong): (Array[Long], Array[Long]) =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+        val posIdsLong = decoderInputIds.flatMap { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }
+        }
+        (inpIdsLong, posIdsLong)
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        val posIdsLong = decoderInputIds.map { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }.last
+        }
+        (inpIdsLong, posIdsLong)
+      }
+    val attentionMask: Array[Long] =
+      decoderInputIds.flatMap { tokenIds => tokenIds.map(_ => 1L) }
+
+    val batchSize: Int = decoderInputIds.length
+    val beamIdx: Array[Int] = new Array[Int](batchSize)
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+
+    val inputIdsLongTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputIdsLong)
+    val decoderAttentionMask: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize, decoderInputIds.head.length), attentionMask)
+    val decoderPositionIDs: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputPositionIDsLong)
+    val beamIdxTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize), beamIdx)
+
+    inferRequest.set_tensor(OpenVinoSignatures.decoderInputIDs, inputIdsLongTensor)
+    inferRequest.set_tensor(OpenVinoSignatures.decoderAttentionMask, decoderAttentionMask)
+    inferRequest.set_tensor(OpenVinoSignatures.decoderPositionIDs, decoderPositionIDs)
+    inferRequest.set_tensor(OpenVinoSignatures.decoderBeamIdx, beamIdxTensor)
+
+    inferRequest.infer()
+
+    val result = inferRequest.get_tensor(OpenVinoSignatures.decoderOutput)
+    val logitsRaw = result.data()
+
+    val sequenceLength = inputIdsLong.length / batchSize
+    val decoderOutputs = (0 until batchSize).map(i => {
+      logitsRaw
+        .slice(
+          i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+          i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    })
+    decoderOutputs.toArray
+  }
+  private def getDecoderOutputs(
+      inputIds: Array[Array[Int]],
+      onnxSession: (OrtSession, OrtEnvironment)): (Array[Array[Float]]) = {
+    val (session, env) = onnxSession
+
+    val inputIdsLong: Array[Array[Long]] =
+      inputIds.map { tokenIds => tokenIds.map(_.toLong) }
+
+    val inputPositionIDsLong: Array[Array[Long]] =
+      inputIds.map { tokenIds =>
+        tokenIds.zipWithIndex.map { case (_, i) =>
+          i.toLong
+        }
+      }
+
+    val inputIdsLongTensor: OnnxTensor =
+      OnnxTensor.createTensor(env, inputIdsLong)
+    val decoderAttentionMask: OnnxTensor =
+      OnnxTensor.createTensor(env, inputIdsLong.map(_.map(_ => 1L)))
+    val decoderPositionIDs: OnnxTensor =
+      OnnxTensor.createTensor(env, inputPositionIDsLong)
+
+    val decoderInputs: java.util.Map[String, OnnxTensor] = Map(
+      OnnxSignatures.decoderInputIDs -> inputIdsLongTensor,
+      OnnxSignatures.decoderAttentionMask -> decoderAttentionMask,
+      OnnxSignatures.decoderPositionIDs -> decoderPositionIDs).asJava
+    val sessionOutput = session.run(decoderInputs)
+
+    val sequenceLength = inputIds.head.length
+    val batchSize = inputIds.length
+
+//    val logits = sessionOutput.getFloatArray(OnnxSignatures.decoderOutput)
+//    inputIdsLongTensor.close()
+//    decoderPositionIDs.close()
+//    decoderAttentionMask.close()
+//    val batchLogits = logits.grouped(vocabSize).toArray
+//    batchLogits
+
+    val logitsRaw = sessionOutput.getFloatArray(OnnxSignatures.decoderOutput)
+    val decoderOutputs = (0 until batchSize).map(i => {
+      logitsRaw
+        .slice(
+          i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+          i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    })
+    decoderOutputs.toArray
+  }
+
+  /** Gets the index with the highest score
+    *
+    * @param scores
+    *   Array of Scores to max
+    * @return
+    *   Index of the highest score
+    */
+  private def argmax(scores: Array[Float]): Int =
+    scores.zipWithIndex.maxBy { case (score, _) =>
+      score
+    }._2
+  private def greedyGenerationFinished(
+      decoderIds: Seq[Array[Int]],
+      eosTokenId: Int,
+      maxOutputLength: Int): Boolean =
+    decoderIds.map(_.last).forall(_ == eosTokenId) || decoderIds.head.length == maxOutputLength
+
+  private def generateGreedyOnnx(
+      inputIds: Array[Array[Int]],
+      onnxSession: (OrtSession, OrtEnvironment),
+      maxOutputLength: Int): (Array[Array[Int]]) = {
+
+    val sequencesLength = inputIds.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+    var generatedIds: Array[Array[Int]] = inputIds
+    while (!greedyGenerationFinished(
+        generatedIds,
+        eosTokenId,
+        maxOutputLength + maxSentenceLength)) {
+
+      val (batchLogits: Array[Array[Float]]) =
+        Array(getDecoderOutputs(generatedIds, onnxSession).last)
+
+      val nextTokenIds: Array[Int] = batchLogits.map(argmax)
+      generatedIds =
+        generatedIds.zip(nextTokenIds).map { case (currentIds: Array[Int], nextId: Int) =>
+          currentIds ++ Array(nextId)
+        }
+    }
+    generatedIds
+  }
+
+  private object OnnxSignatures {
+    val decoderInputIDs: String = "input_ids"
+    val decoderAttentionMask: String = "attention_mask"
+    val decoderPositionIDs: String = "position_ids"
+
+    // create decoder past for 32 layers of key and value eg. past_key_values.0.key and past_key_values.0.value
+    val decoderPast: Array[String] = (0 until 32)
+      .flatMap(i => Seq(s"past_key_values.$i.key", s"past_key_values.$i.value"))
+      .toArray
+    val decoderOutput: String = "logits"
+    val decoderPresent: Array[String] =
+      (0 until 32).flatMap(i => Seq(s"present.$i.key", s"present.$i.value")).toArray
+  }
+
+  private object OpenVinoSignatures {
+    val encoderInputIDs: String = "input_ids"
+    val encoderAttentionMask: String = "attention_mask"
+
+    val encoderOutput: String = "last_hidden_state"
+
+    val decoderInputIDs: String = "input_ids"
+    val decoderEncoderAttentionMask: String = "encoder_attention_mask"
+    val decoderAttentionMask: String = "attention_mask"
+    val decoderPositionIDs: String = "position_ids"
+    val decoderBeamIdx: String = "beam_idx"
+    val decoderEncoderState: String = "encoder_hidden_states"
+
+    val decoderOutput: String = "logits"
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/DistilBertClassification.scala b/src/main/scala/com/johnsnowlabs/ml/ai/DistilBertClassification.scala
index c80cb285f07458..b6d4c2778190b5 100644
--- a/src/main/scala/com/johnsnowlabs/ml/ai/DistilBertClassification.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/DistilBertClassification.scala
@@ -474,6 +474,92 @@ private[johnsnowlabs] class DistilBertClassification(
     (startScores, endScores)
   }
 
+  override def tagSpanMultipleChoice(batch: Seq[Array[Int]]): Array[Float] = {
+    val logits = detectedEngine match {
+      case ONNX.name => computeLogitsMultipleChoiceWithOnnx(batch)
+      case Openvino.name => computeLogitsMultipleChoiceWithOv(batch)
+    }
+
+    calculateSoftmax(logits)
+  }
+
+  private def computeLogitsMultipleChoiceWithOnnx(batch: Seq[Array[Int]]): Array[Float] = {
+    val sequenceLength = batch.head.length
+    val inputIds = Array(batch.map(x => x.map(_.toLong)).toArray)
+    val attentionMask = Array(
+      batch.map(sentence => sentence.map(x => if (x == 0L) 0L else 1L)).toArray)
+    val tokenTypeIds = Array(batch.map(_ => Array.fill(sequenceLength)(0L)).toArray)
+
+    val (ortSession, ortEnv) = onnxWrapper.get.getSession(onnxSessionOptions)
+    val tokenTensors = OnnxTensor.createTensor(ortEnv, inputIds)
+    val maskTensors = OnnxTensor.createTensor(ortEnv, attentionMask)
+    val segmentTensors = OnnxTensor.createTensor(ortEnv, tokenTypeIds)
+
+    val inputs =
+      Map("input_ids" -> tokenTensors, "attention_mask" -> maskTensors).asJava
+
+    try {
+      val output = ortSession.run(inputs)
+      try {
+
+        val logits = output
+          .get("logits")
+          .get()
+          .asInstanceOf[OnnxTensor]
+          .getFloatBuffer
+          .array()
+
+        tokenTensors.close()
+        maskTensors.close()
+        segmentTensors.close()
+
+        logits
+      } finally if (output != null) output.close()
+    } catch {
+      case e: Exception =>
+        // Log the exception as a warning
+        println("Exception in computeLogitsMultipleChoiceWithOnnx: ", e)
+        // Rethrow the exception to propagate it further
+        throw e
+    }
+  }
+
+  private def computeLogitsMultipleChoiceWithOv(batch: Seq[Array[Int]]): Array[Float] = {
+    val (numChoices, sequenceLength) = (batch.length, batch.head.length)
+    // batch_size, num_choices, sequence_length
+    val shape = Some(Array(1, numChoices, sequenceLength))
+    val (tokenTensors, maskTensors, segmentTensors) =
+      PrepareEmbeddings.prepareOvLongBatchTensorsWithSegment(
+        batch,
+        sequenceLength,
+        numChoices,
+        sentencePadTokenId,
+        shape)
+
+    val compiledModel = openvinoWrapper.get.getCompiledModel()
+    val inferRequest = compiledModel.create_infer_request()
+    inferRequest.set_tensor("input_ids", tokenTensors)
+    inferRequest.set_tensor("attention_mask", maskTensors)
+
+    inferRequest.infer()
+
+    try {
+      try {
+        val logits = inferRequest
+          .get_output_tensor()
+          .data()
+
+        logits
+      }
+    } catch {
+      case e: Exception =>
+        // Log the exception as a warning
+        logger.warn("Exception in computeLogitsMultipleChoiceWithOv", e)
+        // Rethrow the exception to propagate it further
+        throw e
+    }
+  }
+
   def computeLogitsWithTF(
       batch: Seq[Array[Int]],
       maxSentenceLength: Int): (Array[Float], Array[Float]) = {
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/Janus.scala b/src/main/scala/com/johnsnowlabs/ml/ai/Janus.scala
new file mode 100644
index 00000000000000..5e374edbd71313
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/Janus.scala
@@ -0,0 +1,1031 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.ml.ai
+import java.lang.Math
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.JanusWrappers
+import com.johnsnowlabs.nlp.annotators.common.Sentence
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.nlp.annotators.common.SentenceSplit
+import com.johnsnowlabs.nlp.annotators.cv.util.transform.ImageResizeUtils
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.nlp.annotators.cv.util.io.ImageIOUtils
+import com.johnsnowlabs.nlp.annotators.tokenizer.bpe.{BpeTokenizer, JanusTokenizer, SpecialTokens}
+import org.intel.openvino.{InferRequest, Tensor}
+
+import javax.imageio.ImageIO
+import scala.util.Random
+import scala.reflect.ClassTag
+import java.awt.{Color, Graphics2D}
+import java.awt.image.BufferedImage
+import java.io.ByteArrayOutputStream
+import scala.collection.JavaConverters._
+
+private[johnsnowlabs] class Janus(
+    val onnxWrappers: Option[DecoderWrappers],
+    val openvinoWrapper: Option[JanusWrappers],
+    merges: Map[(String, String), Int],
+    vocabulary: Map[String, Int],
+    addedTokens: Map[String, Int],
+    preprocessor: Preprocessor,
+    generationConfig: GenerationConfig,
+    imageTokenLength: Int,
+    imageToken: Int)
+    extends Serializable {
+
+  val detectedEngine: String =
+    if (onnxWrappers.isDefined) ONNX.name
+    else if (openvinoWrapper.isDefined) Openvino.name
+    else Openvino.name
+
+  private val GenerationConfig(
+    bosTokenId: Int,
+    paddingTokenId: Int,
+    eosTokenId: Int,
+    vocabSize: Int,
+    beginSuppressTokens,
+    suppressTokenIds,
+    forcedDecoderIds) =
+    generationConfig
+  val reversedVocabulary: Map[Int, String] = vocabulary.map(_.swap)
+
+  val specialTokens: SpecialTokens = SpecialTokens(
+    vocabulary,
+    startTokenString = reversedVocabulary(bosTokenId),
+    endTokenString = reversedVocabulary(eosTokenId),
+    unkTokenString = reversedVocabulary(eosTokenId),
+    maskTokenString = reversedVocabulary(eosTokenId),
+    padTokenString = reversedVocabulary(paddingTokenId),
+    additionalStrings = addedTokens.keys.toArray)
+
+  val bpeTokenizer: JanusTokenizer = BpeTokenizer
+    .forModel(
+      "Janus",
+      merges = merges,
+      vocab = vocabulary,
+      specialTokens = Some(specialTokens),
+      addPrefixSpaceToSentence = true,
+      alwaysAddPrefix = false)
+    .asInstanceOf[JanusTokenizer]
+
+  var randomSeedGenerator = new Random()
+
+  /** Decode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of decoded sentences
+    */
+  def decode(sentences: Array[Array[Int]]): Seq[String] = {
+    sentences.map(s => bpeTokenizer.decodeTokens(s.map(_.toInt)))
+  }
+
+  /** Encode a sequence of sentences for generation
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of encoded sentences
+    */
+  private def encodeTextForGeneration(sentences: Seq[Annotation]): Seq[Array[Int]] = {
+    val startOfImage = ""
+    val endOfImage = ""
+    val startOfImageToken = vocabulary.getOrElse(startOfImage, 100016)
+    val endOfImageToken = vocabulary.getOrElse(endOfImage, 100593)
+
+    // encode text and add beginning of image token
+
+    val tokens = SentenceSplit
+      .unpack(sentences)
+      .map(s => {
+        val sentWithTask = s
+        bpeTokenizer
+          .tokenize(sentWithTask)
+          .map(bpeTokenizer.encode)
+          .flatMap(_.map(_.pieceId))
+      })
+      .map(s => Array(bosTokenId) ++ s ++ Array(startOfImageToken))
+
+    tokens
+
+  }
+
+  /** Encode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of encoded sentences
+    */
+  def encodeText(sentences: Seq[Annotation], imgTokenLen: List[Int]): Seq[Array[Int]] = {
+
+    val pattern = raw"".r
+
+    val startOfImage = ""
+    val endOfImage = ""
+    val startOfImageToken = vocabulary.getOrElse(startOfImage, 100016)
+    val endOfImageToken = vocabulary.getOrElse(endOfImage, 100593)
+
+    // raise an error if the pattern is not found in the text
+    if (pattern.findFirstIn(sentences.head.result).isEmpty) {
+      throw new IllegalArgumentException(
+        "The pattern  is not found in the text")
+    }
+
+    // split the sentences into chunks based on the pattern and tokenize them
+    // eg in python prompt_chunks = [self.tokenizer(chunk).input_ids for chunk in re.split(pattern, texts)]
+    val promptChunks = sentences
+      .map(s => {
+        val sentWithTask = s.result
+        var offsetLength = 0
+        pattern
+          .split(sentWithTask)
+          .zipWithIndex
+          .map(s => {
+            val sentenceWithTask = Sentence(
+              content = s._1,
+              start = offsetLength,
+              end = offsetLength + s._1.length,
+              index = s._2)
+            offsetLength += s._1.length
+            bpeTokenizer
+              .tokenize(sentenceWithTask)
+              .map(bpeTokenizer.encode)
+              .flatMap(_.map(_.pieceId))
+          })
+      })
+
+    // inject the image padding tokens of length imgTokenLen between the prompt chunks and reduce the Seq[Array[Array[Int]]] to Seq[Array[Int]]
+    val tokens = promptChunks
+      .zip(imgTokenLen)
+      .map(s => {
+        val (promptChunk, imgTokenLen) = s
+        val imgPaddingTokens =
+          Array(startOfImageToken) ++ Array.fill(imgTokenLen)(imageToken) ++ Array(
+            endOfImageToken)
+        val combinedChunks = promptChunk
+          .map(_.toArray)
+          .reduce(_ ++ imgPaddingTokens ++ _)
+        Array(bosTokenId) ++ combinedChunks
+      })
+
+    //    val tokens = SentenceSplit
+    //      .unpack(sentences)
+    //      .map(s => {
+    //        val sentWithTask = s
+    //        bpeTokenizer
+    //          .tokenize(sentWithTask)
+    //          .map(bpeTokenizer.encode)
+    //          .flatMap(_.map(_.pieceId))
+    //      })
+    tokens
+  }
+
+  def encode(
+      imageAnnotations: Seq[AnnotationImage],
+      sentences: Seq[Annotation],
+      preprocessor: Preprocessor,
+      imageTokenLength: Int = imageTokenLength)
+      : (Seq[Array[Int]], Array[Array[Array[Array[Array[Float]]]]]) = {
+    val preprocessedImages = encodeImage(imageAnnotations.toArray, preprocessor)
+    val encodedText = encodeText(sentences, List(imageTokenLength)).toArray
+
+    (encodedText, preprocessedImages)
+  }
+
+  def tag(
+      batch: Seq[Array[Int]],
+      images: Array[Array[Array[Array[Array[Float]]]]],
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long],
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int,
+      stopTokenIds: Array[Int]): Array[Array[Int]] = {
+
+    val pixelValues = images
+    val ignoreTokenIdsInt = ignoreTokenIds
+    val expandedDecoderInputsVals = batch
+    val sequencesLength = expandedDecoderInputsVals.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+    //    val pixelValues = images._1
+    //    val imageSizes = images._2
+    val numReturn_sequences = 1
+    // from config
+
+    var effectiveBatch_size = 1
+    var effectiveBatch_mult = 1
+
+    if (doSample) {
+      effectiveBatch_size = expandedDecoderInputsVals.length * numReturn_sequences
+      effectiveBatch_mult = numReturn_sequences
+    } else {
+      effectiveBatch_size = expandedDecoderInputsVals.length
+      effectiveBatch_mult = 1
+    }
+
+    val inferRequestLanguageModel =
+      openvinoWrapper.get.languageModel.getCompiledModel().create_infer_request()
+    val inferRequestVisionEmbeddingsModel =
+      openvinoWrapper.get.visionEmbeddingsModel.getCompiledModel().create_infer_request()
+    val inferRequestTextEmbeddingsModel =
+      openvinoWrapper.get.textEmbeddingsModel.getCompiledModel().create_infer_request()
+    val inferRequestLMHeadModel =
+      openvinoWrapper.get.lmHeadModel.getCompiledModel().create_infer_request()
+    val inferRequestMergeModel =
+      openvinoWrapper.get.mergeModel.getCompiledModel().create_infer_request()
+
+    val generatedIds = generateGreedy(
+      batch.toArray,
+      batch.toArray,
+      pixelValues,
+      maxOutputLength,
+      inferRequestLanguageModel,
+      inferRequestVisionEmbeddingsModel,
+      inferRequestTextEmbeddingsModel,
+      inferRequestLMHeadModel,
+      inferRequestMergeModel)
+    generatedIds
+  }
+
+  def generateGreedy(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Array[Float]]]]],
+      maxOutputLength: Int,
+      inferRequestLanguageModel: InferRequest,
+      inferRequestVisionEmbeddingsModel: InferRequest,
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestLMHeadModel: InferRequest,
+      inferRequestMergeModel: InferRequest): Array[Array[Int]] = {
+
+    var generatedIds: Array[Array[Int]] = Array()
+    var decoderInputIdsCopied = decoderInputIds
+    while (!greedyGenerationFinished(generatedIds, eosTokenId, maxOutputLength)) {
+      val decoderOutputs = getModelOutputs(
+        encoderInputIds,
+        decoderInputIdsCopied,
+        pixelValues,
+        inferRequestLanguageModel,
+        inferRequestVisionEmbeddingsModel,
+        inferRequestTextEmbeddingsModel,
+        inferRequestLMHeadModel,
+        inferRequestMergeModel)
+
+      val nextTokenIds = decoderOutputs.map { scores =>
+        argmax(scores)
+      }
+
+      if (generatedIds.isEmpty) {
+        generatedIds = nextTokenIds.map(Array(_))
+      } else {
+        generatedIds =
+          generatedIds.zip(nextTokenIds).map { case (currentIds: Array[Int], nextId: Int) =>
+            currentIds ++ Array(nextId)
+          }
+      }
+
+      // extend decoder input ids
+      decoderInputIdsCopied =
+        decoderInputIdsCopied.zip(nextTokenIds).map { case (currentIds, nextId) =>
+          currentIds ++ Array(nextId)
+        }
+    }
+    generatedIds
+  }
+
+  def predict(
+      sentences: Seq[Annotation],
+      imageAnnotations: Seq[AnnotationImage],
+      imageGenerateMode: Boolean,
+      batchSize: Int,
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long] = None,
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int,
+      numOfParallelImages: Int): Seq[Annotation] = {
+
+    if (imageGenerateMode) {
+      randomSeedGenerator = randomSeed.map(s => new Random(s)).getOrElse(new Random())
+      val encodedText: Array[Array[Int]] = encodeTextForGeneration(sentences).toArray
+      val parallelSize = numOfParallelImages
+      val tokens = Array.ofDim[Int](parallelSize * 2, encodedText.head.length)
+      for (i <- 0 until parallelSize * 2) {
+        if (i % 2 != 0) {
+          tokens(i) = Array.fill(encodedText.head.length)(paddingTokenId)
+          // update the first and last token to bos and eos respectively
+          tokens(i)(0) = encodedText.head.head
+          tokens(i)(encodedText.head.length - 1) = encodedText.head.last
+        } else {
+          tokens(i) = encodedText.head
+        }
+      }
+      val generatedImages = generateImage(
+        tokens,
+        tokens,
+        parallelSize = parallelSize,
+        patchSize = 16,
+        imageSize = preprocessor.size,
+        randomSeed = randomSeed,
+        inferRequestTextEmbeddingsModel =
+          openvinoWrapper.get.textEmbeddingsModel.getCompiledModel().create_infer_request(),
+        inferRequestGenEmbeddingsModel =
+          openvinoWrapper.get.genEmbeddingsModel.getCompiledModel().create_infer_request(),
+        inferRequestGenHeadModel =
+          openvinoWrapper.get.genHeadModel.getCompiledModel().create_infer_request(),
+        inferRequestLanguageModel =
+          openvinoWrapper.get.languageModel.getCompiledModel().create_infer_request(),
+        inferRequestGenDecoderModel =
+          openvinoWrapper.get.genDecoderModel.getCompiledModel().create_infer_request())
+
+      // group generated images into ( batch_size, parallel_size) and convert them to annotations
+      val parallelSizeBatchedImages: Array[Array[BufferedImage]] =
+        generatedImages.grouped(parallelSize).toArray
+
+      val annotations = parallelSizeBatchedImages.zip(sentences).map { case (imgs, sent) =>
+        var metadata = Map[String, String]()
+        // add each image to the metadata
+        imgs.zipWithIndex.foreach { case (img, i) =>
+          val bos = new ByteArrayOutputStream()
+          ImageIO.write(img, "png", bos)
+          val base64EncodedImage = java.util.Base64.getEncoder.encodeToString(bos.toByteArray)
+          metadata += (s"generated_image_$i" -> base64EncodedImage)
+        }
+        val annots = new Annotation(
+          annotatorType = DOCUMENT,
+          begin = 0,
+          end = 0,
+          result = sent.result,
+          metadata = metadata)
+        annots
+      }
+      annotations
+    } else {
+      val (encodedText, preprocessedImages) = encode(imageAnnotations, sentences, preprocessor)
+      val tagged = tag(
+        encodedText,
+        preprocessedImages,
+        minOutputLength,
+        maxOutputLength,
+        doSample,
+        temperature,
+        topK,
+        topP,
+        repetitionPenalty,
+        noRepeatNgramSize,
+        randomSeed,
+        ignoreTokenIds,
+        beamSize,
+        maxInputLength,
+        Array(eosTokenId))
+      val decoded = decode(tagged)
+
+      var sentBegin, nextSentEnd = 0
+      val annotations = decoded.map { content =>
+        nextSentEnd += content.length - 1
+        val annots = new Annotation(
+          annotatorType = DOCUMENT,
+          begin = sentBegin,
+          end = nextSentEnd,
+          result = content,
+          metadata = Map())
+        sentBegin += nextSentEnd + 1
+        annots
+      }
+      annotations
+    }
+  }
+
+  def getModelOutputs(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Array[Float]]]]],
+      inferRequestLanguageModel: InferRequest,
+      inferRequestVisionEmbeddingsModel: InferRequest,
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestLMHeadModel: InferRequest,
+      inferRequestMergeModel: InferRequest): Array[Array[Float]] = {
+
+    val mergeRequest = openvinoWrapper.get.mergeModel.getCompiledModel().create_infer_request()
+    val inputEmbeds = getMultimodalEmbeddings(
+      encoderInputIds,
+      decoderInputIds,
+      pixelValues,
+      inferRequestVisionEmbeddingsModel,
+      inferRequestTextEmbeddingsModel,
+      mergeRequest)
+    val (inputIdsLong, inputPositionIDsLong): (Array[Long], Array[Long]) =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+        val posIdsLong = decoderInputIds.flatMap { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }
+        }
+        (inpIdsLong, posIdsLong)
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        val posIdsLong = decoderInputIds.map { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }.last
+        }
+        (inpIdsLong, posIdsLong)
+      }
+    val attentionMask: Array[Long] =
+      decoderInputIds.flatMap { tokenIds => tokenIds.map(_ => 1L) }
+
+    val batchSize: Int = decoderInputIds.length
+    val beamIdx: Array[Int] = new Array[Int](batchSize)
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+
+    val decoderAttentionMask: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize, decoderInputIds.head.length), attentionMask)
+    val decoderPositionIDs: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputPositionIDsLong)
+    val beamIdxTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize), beamIdx)
+
+    inferRequestLanguageModel.set_tensor("inputs_embeds", inputEmbeds)
+    inferRequestLanguageModel.set_tensor("attention_mask", decoderAttentionMask)
+    inferRequestLanguageModel.set_tensor("position_ids", decoderPositionIDs)
+    inferRequestLanguageModel.set_tensor("beam_idx", beamIdxTensor)
+
+    inferRequestLanguageModel.infer()
+
+    val result = inferRequestLanguageModel.get_tensor("last_hidden_state")
+
+    inferRequestLMHeadModel.set_input_tensor(result)
+    inferRequestLMHeadModel.infer()
+
+    val logits = inferRequestLMHeadModel.get_output_tensor()
+
+    val logitsRaw = logits.data()
+
+    val sequenceLength = inputIdsLong.length / batchSize
+    val decoderOutputs = (0 until batchSize).map(i => {
+      logitsRaw
+        .slice(
+          i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+          i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    })
+    decoderOutputs.toArray
+  }
+
+  def generateImage(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      parallelSize: Int = 1,
+      patchSize: Int = 16,
+      imageSize: Int = preprocessor.size,
+      randomSeed: Option[Long] = None,
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestGenEmbeddingsModel: InferRequest,
+      inferRequestGenHeadModel: InferRequest,
+      inferRequestLanguageModel: InferRequest,
+      inferRequestGenDecoderModel: InferRequest): Array[BufferedImage] = {
+
+    val generatedTokens = getImageModelOutputs(
+      encoderInputIds,
+      decoderInputIds,
+      randomSeed,
+      inferRequestTextEmbeddingsModel,
+      inferRequestGenEmbeddingsModel,
+      inferRequestGenHeadModel,
+      inferRequestLanguageModel)
+
+    inferRequestGenDecoderModel.set_tensor(
+      "code_b",
+      new org.intel.openvino.Tensor(
+        Array(generatedTokens.length, generatedTokens.head.length),
+        generatedTokens.flatten.map(_.toLong)))
+
+    inferRequestGenDecoderModel.set_tensor(
+      "shape",
+      new org.intel.openvino.Tensor(
+        Array(4),
+        Array(parallelSize, 8, imageSize / patchSize, imageSize / patchSize).map(_.toLong)))
+
+    inferRequestGenDecoderModel.infer()
+
+    val dec = inferRequestGenDecoderModel.get_output_tensor()
+
+    val decShape = dec.get_shape()
+    val decChannelsLast = transposeArray(dec.data(), decShape, Array(0, 2, 3, 1))
+
+    val decChannelsLastReshaped =
+      reshape4D(decChannelsLast, decShape(0), decShape(2), decShape(3), decShape(1))
+
+    val decClipped: Array[Array[Array[Array[Int]]]] = decChannelsLastReshaped.map { x =>
+      x.map { y =>
+        y.map { z =>
+          z.map { w =>
+            Math.min(Math.max(((w + 1) / 2) * 255, 0), 255).toInt
+          }
+        }
+      }
+    }
+
+    // convert each image to a BufferedImage
+    val bufferedImages = decClipped.map { img =>
+      ImageIOUtils.arrayToBufferedImage(img)
+    }
+    bufferedImages
+  }
+
+  def getImageModelOutputs(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      randomSeed: Option[Long] = None,
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestGenEmbeddingsModel: InferRequest,
+      inferRequestGenHeadModel: InferRequest,
+      inferRequestLanguageModel: InferRequest): Array[Array[Int]] = {
+
+    var generatedTokens: Array[Array[Int]] = Array()
+    var nextInputEmbedsTensor: Option[org.intel.openvino.Tensor] = None
+    var decoderInputIdsCopied = decoderInputIds.clone()
+    // run the model for imageTokenLength times
+    for (i <- 0 until imageTokenLength) {
+      val nextTokenIds = getNextImageTokens(
+        encoderInputIds,
+        decoderInputIdsCopied,
+        cfgWeight = 5.0f,
+        temperature = 1.0f,
+        randomSeed = randomSeed,
+        inputEmbeds = nextInputEmbedsTensor,
+        inferRequestTextEmbeddingsModel,
+        inferRequestGenHeadModel,
+        inferRequestLanguageModel)
+      val nextTokenIdsTensor = new org.intel.openvino.Tensor(
+        Array(nextTokenIds.length * 2),
+        nextTokenIds.flatMap(x => Array(x, x)).map(_.toLong))
+
+      inferRequestGenEmbeddingsModel.set_input_tensor(nextTokenIdsTensor)
+      inferRequestGenEmbeddingsModel.infer()
+
+      val imageEmbeddings = inferRequestGenEmbeddingsModel.get_output_tensor()
+
+      nextInputEmbedsTensor = None
+      nextInputEmbedsTensor = Some(
+        new org.intel.openvino.Tensor(
+          Array(imageEmbeddings.get_shape()(0), 1, imageEmbeddings.get_shape()(1)),
+          imageEmbeddings.data()))
+
+      if (generatedTokens.isEmpty) {
+        generatedTokens = nextTokenIds.map(Array(_))
+      } else {
+        generatedTokens =
+          generatedTokens.zip(nextTokenIds).map { case (currentIds: Array[Int], nextId: Int) =>
+            currentIds ++ Array(nextId)
+          }
+      }
+
+      // repeat the nextTokenIds twice and add them to the decoder input ids
+      val repeatedNextTokenIds = nextTokenIds.flatMap(x => Array(x, x))
+
+      // extend decoder input ids to include the generated tokens. Decoder input ids are duplicated for each image
+      decoderInputIdsCopied =
+        decoderInputIdsCopied.zip(repeatedNextTokenIds).map { case (currentIds, nextId) =>
+          currentIds ++ Array(nextId)
+        }
+    }
+    generatedTokens
+  }
+
+  private def getNextImageTokens(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      cfgWeight: Float = 5.0f,
+      temperature: Float = 1.0f,
+      randomSeed: Option[Long] = None,
+      inputEmbeds: Option[Tensor],
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestGenHeadModel: InferRequest,
+      inferRequestLanguageModel: InferRequest): Array[Int] = {
+
+    val (inputIdsLong, inputPositionIDsLong): (Array[Long], Array[Long]) =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+        val posIdsLong = decoderInputIds.flatMap { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }
+        }
+        (inpIdsLong, posIdsLong)
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        val posIdsLong = decoderInputIds.map { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }.last
+        }
+        (inpIdsLong, posIdsLong)
+      }
+    val attentionMask: Array[Long] =
+      decoderInputIds.flatMap { tokenIds => tokenIds.map(_ => 1L) }
+
+    val batchSize: Int = decoderInputIds.length
+    val beamIdx: Array[Int] = new Array[Int](batchSize)
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+
+    val decoderAttentionMask: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize, decoderInputIds.head.length), attentionMask)
+    val decoderPositionIDs: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputPositionIDsLong)
+    val beamIdxTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize), beamIdx)
+
+    val inputEmbedsTensor: org.intel.openvino.Tensor = if (inputEmbeds.isDefined) {
+      inputEmbeds.get
+    } else {
+      val inputIdsLongTensor: org.intel.openvino.Tensor =
+        new org.intel.openvino.Tensor(shape, inputIdsLong)
+      inferRequestTextEmbeddingsModel.set_input_tensor(inputIdsLongTensor)
+      inferRequestTextEmbeddingsModel.infer()
+
+      val textEmbeddings = inferRequestTextEmbeddingsModel.get_output_tensor()
+      textEmbeddings
+    }
+
+    inferRequestLanguageModel.set_tensor("inputs_embeds", inputEmbedsTensor)
+    inferRequestLanguageModel.set_tensor("attention_mask", decoderAttentionMask)
+    inferRequestLanguageModel.set_tensor("position_ids", decoderPositionIDs)
+    inferRequestLanguageModel.set_tensor("beam_idx", beamIdxTensor)
+
+    inferRequestLanguageModel.infer()
+
+    val result = inferRequestLanguageModel.get_tensor("last_hidden_state")
+    val resultShape = result.get_shape()
+    // select the last hidden state
+    // (2*parallel_images, sequence_length, hidden_size)
+    // Reshape the tensor
+    val reshapedArray: Array[Array[Array[Float]]] =
+      reshape3D(result.data(), resultShape(0), resultShape(1), resultShape(2))
+    val lastResult = reshapedArray.map { x =>
+      x(resultShape(1) - 1)
+    }.toArray
+    val lastResultTensor =
+      new org.intel.openvino.Tensor(Array(resultShape(0), resultShape(2)), lastResult.flatten)
+
+    inferRequestGenHeadModel.set_input_tensor(lastResultTensor)
+    inferRequestGenHeadModel.infer()
+
+    val logits = inferRequestGenHeadModel.get_output_tensor()
+    val logitsShape = logits.get_shape()
+
+    val logitsRaw = logits.data()
+    val reshapedLogits: Array[Array[Float]] =
+      reshape2D(logitsRaw, logitsShape(0), logitsShape(1))
+    // every second element starting from 0 to the end will be the conditional logits\
+    val logitCond = reshapedLogits.zipWithIndex.filter(_._2 % 2 == 0).map(_._1)
+    // every second element starting from 1 to the end will be the unconditional logits
+    val logitUncond = reshapedLogits.zipWithIndex.filter(_._2 % 2 == 1).map(_._1)
+
+    val logitDiff = logitCond.zip(logitUncond).map { case (cond, uncond) =>
+      cond.zip(uncond).map { case (c, u) =>
+        u + cfgWeight * (c - u)
+      }
+    }
+
+    val probs = logitDiff.map(softmax)
+    val nextTokenIds = multinomial(probs, numSamples = 1, seed = randomSeed)
+    // pick a random token from the nextTokenIds
+//    val randomIndex = new Random()
+//    nextTokenIds.map(x => x(randomIndex.nextInt(x.length)))
+    nextTokenIds.map(_.head)
+
+  }
+
+  private def multinomial(
+      probs: Array[Array[Float]],
+      numSamples: Int = 1,
+      seed: Option[Long] = None): Array[Array[Int]] = {
+    val random = seed.map(s => new Random(s)).getOrElse(new Random())
+    probs.map { p =>
+      require(p.nonEmpty, "Probability array cannot be empty")
+      require(p.forall(_ >= 0.0f), "Probabilities must be non-negative")
+      require(Math.abs(p.sum - 1.0f) < 1e-3, "Probabilities must sum to approximately 1.0")
+      require(p.exists(_ > 0.0f), "Probability array cannot contain all zeros")
+
+      val cumSum = p.scanLeft(0.0f)(_ + _).drop(1)
+
+      (0 until numSamples).map { _ =>
+        val rand = Math.nextAfter(random.nextFloat(), Float.PositiveInfinity)
+        cumSum.indexWhere(_ > rand) match {
+          case -1 => cumSum.length - 1 // Ensure a valid index is always chosen
+          case idx => idx
+        }
+      }.toArray
+    }.toArray
+  }
+
+  private def argmax(scores: Array[Float]): Int =
+    scores.zipWithIndex.maxBy { case (score, _) =>
+      score
+    }._2
+
+  private def greedyGenerationFinished(
+      decoderIds: Seq[Array[Int]],
+      eosTokenId: Int,
+      maxOutputLength: Int): Boolean = {
+    if (decoderIds.isEmpty) {
+      false
+    } else {
+      decoderIds.forall { ids =>
+        ids.length >= maxOutputLength || ids.last == eosTokenId
+      }
+    }
+  }
+
+  def getResizeSizes(
+      width: Int,
+      height: Int,
+      minSize: Int = 14,
+      imageSize: Int = 384): (Int, Int) = {
+    val maxSize = math.max(width, height)
+    (
+      math.max((height.toFloat / maxSize * imageSize).toInt, minSize),
+      math.max((width.toFloat / maxSize * imageSize).toInt, minSize))
+  }
+
+  def expandToSquare(img: BufferedImage, r: Int, g: Int, b: Int): BufferedImage = {
+    val backgroundColor = new Color(r, g, b)
+    val width = img.getWidth
+    val height = img.getHeight
+
+    if (width == height) {
+      img
+    } else {
+      val size = Math.max(width, height)
+      val squaredImage = new BufferedImage(size, size, img.getType)
+      val g2d: Graphics2D = squaredImage.createGraphics()
+
+      // Fill the background
+      g2d.setColor(backgroundColor)
+      g2d.fillRect(0, 0, size, size)
+
+      // Calculate the position to center the original image
+      val x = if (width < height) (size - width) / 2 else 0
+      val y = if (height < width) (size - height) / 2 else 0
+
+      // Draw the original image onto the new square image
+      g2d.drawImage(img, x, y, null)
+      g2d.dispose()
+
+      squaredImage
+    }
+  }
+  private def encodeImage(
+      annotations: Array[AnnotationImage],
+      preprocessor: Preprocessor): Array[Array[Array[Array[Array[Float]]]]] = {
+
+    val batchProcessedImages = annotations.map { annot =>
+      val bufferedImage = ImageIOUtils.byteToBufferedImage(
+        bytes = annot.result,
+        w = annot.width,
+        h = annot.height,
+        nChannels = annot.nChannels)
+
+      val (resize_height, resize_width): (Int, Int) = getResizeSizes(
+        width = bufferedImage.getWidth,
+        height = bufferedImage.getHeight,
+        imageSize = preprocessor.size)
+
+      val resizedImage = if (preprocessor.do_resize) {
+        ImageResizeUtils.resizeBufferedImage(
+          width = resize_height,
+          height = resize_width,
+          preprocessor.resample)(bufferedImage)
+      } else bufferedImage
+
+      val resizedImageSquare = expandToSquare(
+        resizedImage,
+        (preprocessor.image_mean(0) * 255).toInt,
+        (preprocessor.image_mean(1) * 255).toInt,
+        (preprocessor.image_mean(2) * 255).toInt)
+
+      val normalizedImage =
+        ImageResizeUtils.normalizeAndConvertBufferedImage(
+          img = resizedImageSquare,
+          mean = preprocessor.image_mean,
+          std = preprocessor.image_std,
+          doNormalize = preprocessor.do_normalize,
+          doRescale = preprocessor.do_rescale,
+          rescaleFactor = preprocessor.rescale_factor)
+
+      Array(normalizedImage)
+    }
+
+    batchProcessedImages
+
+  }
+
+  def getMultimodalEmbeddings(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Array[Float]]]]],
+      inferRequestVisionEmbeddingsModel: InferRequest,
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestMergeModel: InferRequest): org.intel.openvino.Tensor = {
+    val inputIdsLong: Array[Long] =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+
+        inpIdsLong
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        inpIdsLong
+      }
+    val batchSize: Int = decoderInputIds.length
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+    val inputIdsLongTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputIdsLong)
+
+    val imageEmbeddings: org.intel.openvino.Tensor =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        val pixelValuesTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(
+            Array(
+              pixelValues.length,
+              pixelValues.head.length,
+              pixelValues.head.head.length,
+              pixelValues.head.head.head.length,
+              pixelValues.head.head.head.head.length),
+            pixelValues.flatten.flatten.flatten.flatten.map(_.toFloat))
+
+        // Get image embeddings
+        inferRequestVisionEmbeddingsModel.set_input_tensor(pixelValuesTensor)
+
+        inferRequestVisionEmbeddingsModel.infer()
+
+        val imageEmbeddings = inferRequestVisionEmbeddingsModel.get_output_tensor()
+
+        // Get text embeddings
+        inferRequestTextEmbeddingsModel.set_input_tensor(inputIdsLongTensor)
+
+        inferRequestTextEmbeddingsModel.infer()
+
+        val textEmbeddings = inferRequestTextEmbeddingsModel.get_output_tensor()
+
+        // Merge image and text embeddings
+        inferRequestMergeModel.set_tensor("vision_embeds", imageEmbeddings)
+        inferRequestMergeModel.set_tensor("inputs_embeds", textEmbeddings)
+        inferRequestMergeModel.set_tensor("input_ids", inputIdsLongTensor)
+
+        inferRequestMergeModel.infer()
+
+        inferRequestMergeModel.get_tensor("final_embeddings")
+      } else {
+        // Get text embeddings
+        inferRequestTextEmbeddingsModel.set_input_tensor(inputIdsLongTensor)
+
+        inferRequestTextEmbeddingsModel.infer()
+
+        val textEmbeddings = inferRequestTextEmbeddingsModel.get_output_tensor()
+
+        textEmbeddings
+      }
+    imageEmbeddings
+  }
+
+  def softmax(logitValues: Array[Float]): Array[Float] = {
+    val maxLogit = logitValues.max
+    val logitsExp = logitValues.map(l => Math.exp(l - maxLogit))
+    val expSum = logitsExp.sum
+    logitsExp.map(exp => (exp / expSum).toFloat)
+  }
+
+  // logSoftmax
+  def logSoftmax(logitValues: Array[Float]): Array[Float] = {
+    val maxLogit = logitValues.max
+    val logitsExp = logitValues.map(l => Math.exp(l - maxLogit))
+    val expSum = logitsExp.sum
+    val logSumExp = Math.log(expSum)
+    logitValues.map(l => l - maxLogit - logSumExp).map(_.toFloat)
+  }
+
+  // Function to reshape the flattened array
+  def reshapeArray(flatArray: Array[Float], shape: Array[Int]): Any = {
+    require(flatArray.length == shape.product, "Shape does not match data length")
+
+    def recursiveReshape(data: Array[Float], shape: List[Int]): Any = shape match {
+      case Nil => data.head // Base case: return a single element
+      case head :: Nil => data.grouped(head).toArray.asInstanceOf[Array[Any]] // 1D array
+      case head :: tail =>
+        data
+          .grouped(head)
+          .map(subArr => recursiveReshape(subArr, tail))
+          .toArray
+          .asInstanceOf[Array[Any]] // Cast to Array[Any] to preserve structure
+    }
+
+    recursiveReshape(flatArray, shape.toList).asInstanceOf[Array[Any]]
+  }
+
+  def reshape2D(data: Array[Float], rows: Int, cols: Int): Array[Array[Float]] = {
+//    data.grouped(cols).toArray.map(_.toArray)
+//    i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+//    i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    0.until(rows)
+      .map { i =>
+        data.slice(i * cols, (i + 1) * cols)
+      }
+      .toArray
+  }
+
+  def reshape3D(
+      data: Array[Float],
+      depth: Int,
+      rows: Int,
+      cols: Int): Array[Array[Array[Float]]] = {
+//    data.grouped(rows * cols).toArray.map { slice =>
+//      reshape2D(slice, rows, cols)
+//    }
+    // use the depth to slice the data
+    0.until(depth)
+      .map { i =>
+        data.slice(i * rows * cols, (i + 1) * rows * cols)
+      }
+      .map { slice =>
+        reshape2D(slice, rows, cols)
+      }
+      .toArray
+  }
+
+  def reshape4D(
+      data: Array[Float],
+      batch: Int,
+      depth: Int,
+      rows: Int,
+      cols: Int): Array[Array[Array[Array[Float]]]] = {
+    data.grouped(depth * rows * cols).toArray.map { slice =>
+      reshape3D(slice, depth, rows, cols)
+    }
+  }
+
+  def transposeArray[T: ClassTag](
+      inputArray: Array[T],
+      inputArrayShape: Array[Int],
+      axes: Array[Int]): Array[T] = {
+    require(
+      inputArrayShape.length == axes.length,
+      "Axes must have the same length as the shape dimensions")
+
+    val outputShape = axes.map(inputArrayShape(_))
+    val size = inputArray.length
+    val inputStrides = inputArrayShape.scanRight(1)(_ * _).tail
+    val outputStrides = outputShape.scanRight(1)(_ * _).tail
+
+    def getTransposedIndex(index: Int): Int = {
+      val originalIndices =
+        inputArrayShape.indices.map(i => (index / inputStrides(i)) % inputArrayShape(i))
+      val transposedIndices = axes.map(originalIndices)
+      transposedIndices.zip(outputStrides).map { case (idx, stride) => idx * stride }.sum
+    }
+
+    val outputArray = new Array[T](size)
+    for (i <- inputArray.indices) {
+      outputArray(getTransposedIndex(i)) = inputArray(i)
+    }
+    outputArray
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/LLaVA.scala b/src/main/scala/com/johnsnowlabs/ml/ai/LLaVA.scala
new file mode 100644
index 00000000000000..067d44a3418693
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/LLaVA.scala
@@ -0,0 +1,511 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.ml.ai
+
+import breeze.optimize.BatchSize
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.LLAVAWrappers
+import com.johnsnowlabs.nlp.annotators.common.Sentence
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.nlp.annotators.common.SentenceSplit
+import com.johnsnowlabs.nlp.annotators.cv.util.transform.ImageResizeUtils
+
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.nlp.annotators.cv.util.io.ImageIOUtils
+import com.johnsnowlabs.nlp.annotators.tokenizer.bpe.{BpeTokenizer, LLAVATokenizer, SpecialTokens}
+import org.intel.openvino.InferRequest
+
+import scala.collection.JavaConverters._
+
+private[johnsnowlabs] class LLaVA(
+    val onnxWrappers: Option[DecoderWrappers],
+    val openvinoWrapper: Option[LLAVAWrappers],
+    merges: Map[(String, String), Int],
+    vocabulary: Map[String, Int],
+    addedTokens: Map[String, Int],
+    preprocessor: Preprocessor,
+    generationConfig: GenerationConfig,
+    imageTokenLength: Int,
+    imageToken: Int)
+    extends Serializable {
+
+  val detectedEngine: String =
+    if (onnxWrappers.isDefined) ONNX.name
+    else if (openvinoWrapper.isDefined) Openvino.name
+    else Openvino.name
+
+  private val GenerationConfig(
+    bosTokenId: Int,
+    paddingTokenId: Int,
+    eosTokenId: Int,
+    vocabSize: Int,
+    beginSuppressTokens,
+    suppressTokenIds,
+    forcedDecoderIds) =
+    generationConfig
+  val reversedVocabulary: Map[Int, String] = vocabulary.map(_.swap)
+
+  val specialTokens: SpecialTokens = SpecialTokens(
+    vocabulary,
+    startTokenString = reversedVocabulary(bosTokenId),
+    endTokenString = reversedVocabulary(eosTokenId),
+    unkTokenString = reversedVocabulary(eosTokenId),
+    maskTokenString = reversedVocabulary(eosTokenId),
+    padTokenString = reversedVocabulary(paddingTokenId),
+    additionalStrings = addedTokens.keys.toArray)
+
+  val bpeTokenizer: LLAVATokenizer = BpeTokenizer
+    .forModel(
+      "llava",
+      merges = merges,
+      vocab = vocabulary,
+      specialTokens = Some(specialTokens),
+      addPrefixSpaceToSentence = false,
+      alwaysAddPrefix = false,
+      prependString = "")
+    .asInstanceOf[LLAVATokenizer]
+
+  /** Decode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of decoded sentences
+    */
+  def decode(sentences: Array[Array[Int]]): Seq[String] = {
+    sentences.map(s => bpeTokenizer.decodeTokens(s.map(_.toInt)))
+  }
+
+  /** Encode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of encoded sentences
+    */
+  def encodeText(sentences: Seq[Annotation], imgTokenLen: List[Int]): Seq[Array[Int]] = {
+
+    val pattern = raw"<\|image\|>".r
+
+    // raise an error if the pattern is not found in the text
+    if (pattern.findFirstIn(sentences.head.result).isEmpty) {
+      throw new IllegalArgumentException("The pattern <\\|image\\|> is not found in the text")
+    }
+
+    // split the sentences into chunks based on the pattern and tokenize them
+    // eg in python prompt_chunks = [self.tokenizer(chunk).input_ids for chunk in re.split(pattern, texts)]
+    val promptChunks = sentences
+      .map(s => {
+        val sentWithTask = s.result
+        var offsetLength = 0
+        pattern
+          .split(sentWithTask)
+          .zipWithIndex
+          .map(s => {
+            val sentenceWithTask = Sentence(
+              content = s._1,
+              start = offsetLength,
+              end = offsetLength + s._1.length,
+              index = s._2)
+            offsetLength += s._1.length
+            bpeTokenizer
+              .tokenize(sentenceWithTask)
+              .map(bpeTokenizer.encode)
+              .flatMap(_.map(_.pieceId))
+          })
+      })
+
+    // inject the image padding tokens of length imgTokenLen between the prompt chunks and reduce the Seq[Array[Array[Int]]] to Seq[Array[Int]]
+    val tokens = promptChunks
+      .zip(imgTokenLen)
+      .map(s => {
+        val (promptChunk, imgTokenLen) = s
+        val imgPaddingTokens = Array.fill(imgTokenLen)(imageToken)
+        val combinedChunks = promptChunk
+          .map(_.toArray)
+          .reduce(_ ++ imgPaddingTokens ++ _)
+        Array(bosTokenId) ++ combinedChunks
+      })
+
+    //    val tokens = SentenceSplit
+    //      .unpack(sentences)
+    //      .map(s => {
+    //        val sentWithTask = s
+    //        bpeTokenizer
+    //          .tokenize(sentWithTask)
+    //          .map(bpeTokenizer.encode)
+    //          .flatMap(_.map(_.pieceId))
+    //      })
+    tokens
+  }
+
+  def encode(
+      imageAnnotations: Seq[AnnotationImage],
+      sentences: Seq[Annotation],
+      preprocessor: Preprocessor,
+      imageTokenLength: Int = imageTokenLength)
+      : (Seq[Array[Int]], Array[Array[Array[Array[Float]]]]) = {
+    val preprocessedImages = encodeImage(imageAnnotations.toArray, preprocessor)
+    val encodedText = encodeText(sentences, List(imageTokenLength)).toArray
+
+    (encodedText, preprocessedImages)
+  }
+
+  def tag(
+      batch: Seq[Array[Int]],
+      images: Array[Array[Array[Array[Float]]]],
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long],
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int,
+      stopTokenIds: Array[Int]): Array[Array[Int]] = {
+
+    val pixelValues = images
+    val ignoreTokenIdsInt = ignoreTokenIds
+    val expandedDecoderInputsVals = batch
+    val sequencesLength = expandedDecoderInputsVals.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+    //    val pixelValues = images._1
+    //    val imageSizes = images._2
+    val numReturn_sequences = 1
+    // from config
+
+    var effectiveBatch_size = 1
+    var effectiveBatch_mult = 1
+
+    if (doSample) {
+      effectiveBatch_size = expandedDecoderInputsVals.length * numReturn_sequences
+      effectiveBatch_mult = numReturn_sequences
+    } else {
+      effectiveBatch_size = expandedDecoderInputsVals.length
+      effectiveBatch_mult = 1
+    }
+
+    val inferRequestLanguageModel =
+      openvinoWrapper.get.languageModel.getCompiledModel().create_infer_request()
+    val inferRequestVisionEmbeddingsModel =
+      openvinoWrapper.get.visionEmbeddingsModel.getCompiledModel().create_infer_request()
+    val inferRequestTextEmbeddingsModel =
+      openvinoWrapper.get.textEmbeddingsModel.getCompiledModel().create_infer_request()
+    val inferRequestMergeModel =
+      openvinoWrapper.get.mergeModel.getCompiledModel().create_infer_request()
+
+    val generatedIds = generateGreedy(
+      batch.toArray,
+      batch.toArray,
+      pixelValues,
+      maxOutputLength,
+      inferRequestLanguageModel,
+      inferRequestVisionEmbeddingsModel,
+      inferRequestTextEmbeddingsModel,
+      inferRequestMergeModel)
+    generatedIds
+  }
+
+  def generateGreedy(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Float]]]],
+      maxOutputLength: Int,
+      inferRequestLanguageModel: InferRequest,
+      inferRequestVisionEmbeddingsModel: InferRequest,
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestMergeModel: InferRequest): Array[Array[Int]] = {
+
+    var generatedIds: Array[Array[Int]] = Array()
+    var decoderInputIdsCopied = decoderInputIds
+    while (!greedyGenerationFinished(generatedIds, eosTokenId, maxOutputLength)) {
+      val decoderOutputs = getModelOutputs(
+        encoderInputIds,
+        decoderInputIdsCopied,
+        pixelValues,
+        inferRequestLanguageModel,
+        inferRequestVisionEmbeddingsModel,
+        inferRequestTextEmbeddingsModel,
+        inferRequestMergeModel)
+
+      val nextTokenIds = decoderOutputs.map { scores =>
+        argmax(scores)
+      }
+
+      if (generatedIds.isEmpty) {
+        generatedIds = nextTokenIds.map(Array(_))
+      } else {
+        generatedIds =
+          generatedIds.zip(nextTokenIds).map { case (currentIds: Array[Int], nextId: Int) =>
+            currentIds ++ Array(nextId)
+          }
+      }
+
+      // extend decoder input ids
+      decoderInputIdsCopied =
+        decoderInputIdsCopied.zip(nextTokenIds).map { case (currentIds, nextId) =>
+          currentIds ++ Array(nextId)
+        }
+    }
+    generatedIds
+  }
+
+  def predict(
+      sentences: Seq[Annotation],
+      imageAnnotations: Seq[AnnotationImage],
+      batchSize: Int,
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long] = None,
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int): Seq[Annotation] = {
+
+    val (encodedText, preprocessedImages) = encode(imageAnnotations, sentences, preprocessor)
+    val tagged = tag(
+      encodedText,
+      preprocessedImages,
+      minOutputLength,
+      maxOutputLength,
+      doSample,
+      temperature,
+      topK,
+      topP,
+      repetitionPenalty,
+      noRepeatNgramSize,
+      randomSeed,
+      ignoreTokenIds,
+      beamSize,
+      maxInputLength,
+      Array(eosTokenId))
+    val decoded = decode(tagged)
+
+    var sentBegin, nextSentEnd = 0
+    val annotations = decoded.map { content =>
+      nextSentEnd += content.length - 1
+      val annots = new Annotation(
+        annotatorType = DOCUMENT,
+        begin = sentBegin,
+        end = nextSentEnd,
+        result = content,
+        metadata = Map())
+      sentBegin += nextSentEnd + 1
+      annots
+    }
+    annotations
+  }
+
+  def getModelOutputs(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Float]]]],
+      inferRequestLanguageModel: InferRequest,
+      inferRequestVisionEmbeddingsModel: InferRequest,
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestMergeModel: InferRequest): Array[Array[Float]] = {
+
+    val inputEmbeds = getMultimodalEmbeddings(
+      encoderInputIds,
+      decoderInputIds,
+      pixelValues,
+      inferRequestVisionEmbeddingsModel,
+      inferRequestTextEmbeddingsModel,
+      inferRequestMergeModel)
+
+    val (inputIdsLong, inputPositionIDsLong): (Array[Long], Array[Long]) =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+        val posIdsLong = decoderInputIds.flatMap { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }
+        }
+        (inpIdsLong, posIdsLong)
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        val posIdsLong = decoderInputIds.map { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }.last
+        }
+        (inpIdsLong, posIdsLong)
+      }
+    val attentionMask: Array[Long] =
+      decoderInputIds.flatMap { tokenIds => tokenIds.map(_ => 1L) }
+
+    val batchSize: Int = decoderInputIds.length
+    val beamIdx: Array[Int] = new Array[Int](batchSize)
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+
+    val decoderAttentionMask: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize, decoderInputIds.head.length), attentionMask)
+    val decoderPositionIDs: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputPositionIDsLong)
+    val beamIdxTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize), beamIdx)
+
+    inferRequestLanguageModel.set_tensor("inputs_embeds", inputEmbeds)
+    inferRequestLanguageModel.set_tensor("attention_mask", decoderAttentionMask)
+    inferRequestLanguageModel.set_tensor("position_ids", decoderPositionIDs)
+    inferRequestLanguageModel.set_tensor("beam_idx", beamIdxTensor)
+
+    inferRequestLanguageModel.infer()
+
+    val result = inferRequestLanguageModel.get_tensor("logits")
+    val logitsRaw = result.data()
+
+    val sequenceLength = inputIdsLong.length / batchSize
+    val decoderOutputs = (0 until batchSize).map(i => {
+      logitsRaw
+        .slice(
+          i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+          i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    })
+    decoderOutputs.toArray
+  }
+
+  private def argmax(scores: Array[Float]): Int =
+    scores.zipWithIndex.maxBy { case (score, _) =>
+      score
+    }._2
+
+  private def greedyGenerationFinished(
+      decoderIds: Seq[Array[Int]],
+      eosTokenId: Int,
+      maxOutputLength: Int): Boolean = {
+    if (decoderIds.isEmpty) {
+      false
+    } else {
+      decoderIds.forall { ids =>
+        ids.length >= maxOutputLength || ids.last == eosTokenId
+      }
+    }
+  }
+
+  private def encodeImage(
+      annotations: Array[AnnotationImage],
+      preprocessor: Preprocessor): Array[Array[Array[Array[Float]]]] = {
+
+    val batchProcessedImages = annotations.map { annot =>
+      val bufferedImage = ImageIOUtils.byteToBufferedImage(
+        bytes = annot.result,
+        w = annot.width,
+        h = annot.height,
+        nChannels = annot.nChannels)
+
+      val resizedImage = if (preprocessor.do_resize) {
+        ImageResizeUtils.resizeBufferedImage(
+          width = preprocessor.size,
+          height = preprocessor.size,
+          preprocessor.resample)(bufferedImage)
+      } else bufferedImage
+
+      val normalizedImage =
+        ImageResizeUtils.normalizeAndConvertBufferedImage(
+          img = resizedImage,
+          mean = preprocessor.image_mean,
+          std = preprocessor.image_std,
+          doNormalize = preprocessor.do_normalize,
+          doRescale = preprocessor.do_rescale,
+          rescaleFactor = preprocessor.rescale_factor)
+
+      normalizedImage
+    }
+
+    batchProcessedImages
+
+  }
+
+  def getMultimodalEmbeddings(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Float]]]],
+      inferRequestVisionEmbeddingsModel: InferRequest,
+      inferRequestTextEmbeddingsModel: InferRequest,
+      inferRequestMergeModel: InferRequest): org.intel.openvino.Tensor = {
+    val inputIdsLong: Array[Long] =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+
+        inpIdsLong
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        inpIdsLong
+      }
+    val batchSize: Int = decoderInputIds.length
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+    val inputIdsLongTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputIdsLong)
+
+    val imageEmbeddings: org.intel.openvino.Tensor =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        val pixelValuesTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(
+            Array(batchSize, 3, 336, 336),
+            pixelValues.flatten.flatten.flatten.map(_.toFloat))
+
+        // Get image embeddings
+        inferRequestVisionEmbeddingsModel.set_input_tensor(pixelValuesTensor)
+
+        inferRequestVisionEmbeddingsModel.infer()
+
+        val imageEmbeddings = inferRequestVisionEmbeddingsModel.get_output_tensor()
+
+        // Get text embeddings
+        inferRequestTextEmbeddingsModel.set_input_tensor(inputIdsLongTensor)
+
+        inferRequestTextEmbeddingsModel.infer()
+
+        val textEmbeddings = inferRequestTextEmbeddingsModel.get_output_tensor()
+
+        // Merge image and text embeddings
+        inferRequestMergeModel.set_tensor("vision_embeds", imageEmbeddings)
+        inferRequestMergeModel.set_tensor("inputs_embeds", textEmbeddings)
+        inferRequestMergeModel.set_tensor("input_ids", inputIdsLongTensor)
+
+        inferRequestMergeModel.infer()
+
+        inferRequestMergeModel.get_tensor("final_embedding")
+      } else {
+        // Get text embeddings
+        inferRequestTextEmbeddingsModel.set_input_tensor(inputIdsLongTensor)
+
+        inferRequestTextEmbeddingsModel.infer()
+
+        val textEmbeddings = inferRequestTextEmbeddingsModel.get_output_tensor()
+
+        textEmbeddings
+      }
+    imageEmbeddings
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/MLLama.scala b/src/main/scala/com/johnsnowlabs/ml/ai/MLLama.scala
new file mode 100644
index 00000000000000..f0136ab7f4947b
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/MLLama.scala
@@ -0,0 +1,612 @@
+package com.johnsnowlabs.ml.ai
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.MLLamaWrappers
+import com.johnsnowlabs.nlp.annotators.common.Sentence
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.nlp.annotators.common.SentenceSplit
+import com.johnsnowlabs.nlp.annotators.cv.util.transform.ImageResizeUtils
+import com.johnsnowlabs.nlp.annotators.cv.util.transform.MllamaUtils
+
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.nlp.annotators.cv.util.io.ImageIOUtils
+import com.johnsnowlabs.nlp.annotators.tokenizer.bpe.{
+  BpeTokenizer,
+  MLLamaTokenizer,
+  SpecialTokens
+}
+import org.intel.openvino.InferRequest
+
+import scala.collection.JavaConverters._
+
+private[johnsnowlabs] class MLLama(
+    val onnxWrappers: Option[DecoderWrappers],
+    val openvinoWrapper: Option[MLLamaWrappers],
+    merges: Map[(String, String), Int],
+    vocabulary: Map[String, Int],
+    addedTokens: Map[String, Int],
+    preprocessor: Preprocessor,
+    generationConfig: GenerationConfig,
+    imageToken: Int,
+    maxImageTiles: Int = 4,
+    numVisionTokens: Int = 1601,
+    paddingConstant: Int = 0)
+    extends Serializable {
+
+  val detectedEngine: String =
+    if (onnxWrappers.isDefined) ONNX.name
+    else if (openvinoWrapper.isDefined) Openvino.name
+    else Openvino.name
+
+  private val GenerationConfig(
+    bosTokenId: Int,
+    paddingTokenId: Int,
+    eosTokenId: Int,
+    vocabSize: Int,
+    beginSuppressTokens,
+    suppressTokenIds,
+    forcedDecoderIds) =
+    generationConfig
+  val reversedVocabulary: Map[Int, String] = vocabulary.map(_.swap)
+
+  val specialTokens: SpecialTokens = SpecialTokens(
+    vocabulary,
+    startTokenString = reversedVocabulary(bosTokenId),
+    endTokenString = reversedVocabulary(eosTokenId),
+    unkTokenString = reversedVocabulary(eosTokenId),
+    maskTokenString = reversedVocabulary(eosTokenId),
+    padTokenString = reversedVocabulary(paddingTokenId),
+    additionalStrings = addedTokens.keys.toArray)
+
+  val bpeTokenizer: MLLamaTokenizer = BpeTokenizer
+    .forModel(
+      "mllama",
+      merges = merges,
+      vocab = vocabulary,
+      specialTokens = Some(specialTokens),
+      addPrefixSpaceToSentence = false,
+      alwaysAddPrefix = true,
+      prependString = "")
+    .asInstanceOf[MLLamaTokenizer]
+
+  /** Decode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of decoded sentences
+    */
+  def decode(sentences: Array[Array[Int]]): Seq[String] = {
+    sentences.map(s => bpeTokenizer.decodeTokens(s.map(_.toInt)))
+  }
+
+  /** Encode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of encoded sentences
+    */
+  def encodeText(sentences: Seq[Annotation]): Seq[Array[Int]] = {
+
+    val pattern = raw"<\|image\|>".r
+
+    // raise an error if the pattern is not found in the text
+    if (pattern.findFirstIn(sentences.head.result).isEmpty) {
+      throw new IllegalArgumentException("The pattern <\\|image\\|> is not found in the text")
+    }
+
+    val tokens = SentenceSplit
+      .unpack(sentences)
+      .map(s => {
+        val sentWithTask = s
+        Array(bosTokenId) ++ bpeTokenizer
+          .tokenize(sentWithTask)
+          .map(bpeTokenizer.encode)
+          .flatMap(_.map(_.pieceId))
+      })
+    tokens
+  }
+
+  private def encode(
+      imageAnnotations: Seq[AnnotationImage],
+      sentences: Seq[Annotation],
+      preprocessor: Preprocessor): Map[String, Any] = {
+    val (preprocessedImages, aspectRatioIds, aspectRatioMask, numTiles) =
+      encodeImage(imageAnnotations.toArray, preprocessor, maxImageTiles, paddingConstant)
+    val encodedText = encodeText(sentences).toArray
+
+    val crossAttentionMask = encodedText.map { sentence =>
+      MllamaUtils.getCrossAttentionTokenMask(sentence, imageToken)
+    }
+    val maxLength = encodedText.map(_.length).max
+    val crossAttentionMaskDense = MllamaUtils.convertSparseCrossAttentionMaskToDense(
+      crossAttentionMask,
+      numTiles.map(_.toArray).toArray,
+      maxImageTiles,
+      maxLength)
+
+    Map(
+      "pixelValues" -> preprocessedImages,
+      "aspectRatioIds" -> aspectRatioIds,
+      "aspectRatioMask" -> aspectRatioMask,
+      "crossAttentionMask" -> crossAttentionMaskDense,
+      "numTiles" -> numTiles,
+      "encodedText" -> encodedText)
+
+  }
+
+  def tag(
+      inputs: Map[String, Any],
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long],
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int,
+      stopTokenIds: Array[Int]): Array[Array[Int]] = {
+
+    val inputIds = inputs("encodedText").asInstanceOf[Array[Array[Int]]]
+    val ignoreTokenIdsInt = ignoreTokenIds
+    val expandedDecoderInputsVals = inputIds
+    val sequencesLength = expandedDecoderInputsVals.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+    val numReturn_sequences = 1
+    // from config
+
+    var effectiveBatch_size = 1
+    var effectiveBatch_mult = 1
+
+    if (doSample) {
+      effectiveBatch_size = expandedDecoderInputsVals.length * numReturn_sequences
+      effectiveBatch_mult = numReturn_sequences
+    } else {
+      effectiveBatch_size = expandedDecoderInputsVals.length
+      effectiveBatch_mult = 1
+    }
+    val inferRequestLanguageModel: InferRequest =
+      openvinoWrapper.get.languageModel.getCompiledModel().create_infer_request()
+    val inferRequestVisionEmbeddingsModel: InferRequest =
+      openvinoWrapper.get.visionEmbeddingsModel.getCompiledModel().create_infer_request()
+    val inferRequestReshapeModel: InferRequest =
+      openvinoWrapper.get.reshapeModel.getCompiledModel().create_infer_request()
+    val generatedIds = generateGreedy(
+      inputIds,
+      inputIds,
+      inputs,
+      maxOutputLength,
+      inferRequestLanguageModel,
+      inferRequestVisionEmbeddingsModel,
+      inferRequestReshapeModel)
+    generatedIds
+  }
+
+  def generateGreedy(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      inputs: Map[String, Any],
+      maxOutputLength: Int,
+      inferRequestLanguageModel: InferRequest,
+      inferRequestVisionEmbeddingsModel: InferRequest,
+      inferRequestReshapeModel: InferRequest): Array[Array[Int]] = {
+
+    var generatedIds: Array[Array[Int]] = Array()
+    var decoderInputIdsCopied = decoderInputIds.clone()
+    val pixelValues =
+      inputs("pixelValues").asInstanceOf[Array[Array[Array[Array[Array[Array[Float]]]]]]]
+    val aspectRatioIds = inputs("aspectRatioIds").asInstanceOf[Array[Array[Int]]]
+    val aspectRatioMask = inputs("aspectRatioMask").asInstanceOf[Array[Array[Array[Int]]]]
+
+    val crossAttentionKeyValues = getCrossAttentionKeyValues(
+      encoderInputIds,
+      decoderInputIds,
+      pixelValues,
+      aspectRatioIds,
+      aspectRatioMask,
+      inferRequestVisionEmbeddingsModel)
+
+    while (!greedyGenerationFinished(generatedIds, eosTokenId, maxOutputLength)) {
+      val decoderOutputs = getModelOutputs(
+        encoderInputIds,
+        decoderInputIdsCopied,
+        inputs,
+        crossAttentionKeyValues,
+        inferRequestLanguageModel)
+
+      val nextTokenIds = decoderOutputs.map { scores =>
+        argmax(scores)
+      }
+
+      if (generatedIds.isEmpty) {
+        generatedIds = nextTokenIds.map(Array(_))
+      } else {
+        generatedIds =
+          generatedIds.zip(nextTokenIds).map { case (currentIds: Array[Int], nextId: Int) =>
+            currentIds ++ Array(nextId)
+          }
+      }
+
+      // extend decoder input ids
+      decoderInputIdsCopied =
+        decoderInputIdsCopied.zip(nextTokenIds).map { case (currentIds, nextId) =>
+          currentIds ++ Array(nextId)
+        }
+    }
+    generatedIds
+  }
+
+  def predict(
+      sentences: Seq[Annotation],
+      imageAnnotations: Seq[AnnotationImage],
+      batchSize: Int,
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long] = None,
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int): Seq[Annotation] = {
+
+    val inputs = encode(imageAnnotations, sentences, preprocessor)
+
+    val tagged = tag(
+      inputs,
+      minOutputLength,
+      maxOutputLength,
+      doSample,
+      temperature,
+      topK,
+      topP,
+      repetitionPenalty,
+      noRepeatNgramSize,
+      randomSeed,
+      ignoreTokenIds,
+      beamSize,
+      maxInputLength,
+      Array(eosTokenId))
+    val decoded = decode(tagged)
+
+    var sentBegin, nextSentEnd = 0
+    val annotations = decoded.map { content =>
+      nextSentEnd += content.length - 1
+      val annots = new Annotation(
+        annotatorType = DOCUMENT,
+        begin = sentBegin,
+        end = nextSentEnd,
+        result = content,
+        metadata = Map())
+      sentBegin += nextSentEnd + 1
+      annots
+    }
+    annotations
+  }
+
+  def getModelOutputs(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      inputs: Map[String, Any],
+      crossAttentionKeyValues: Array[(String, org.intel.openvino.Tensor)],
+      inferRequestLanguageModel: InferRequest): Array[Array[Float]] = {
+    val inferRequestReshapeModel =
+      openvinoWrapper.get.reshapeModel.getCompiledModel().create_infer_request()
+
+    val numTiles = inputs("numTiles").asInstanceOf[List[List[Int]]]
+    val (inputIdsLong, inputPositionIDsLong, crossAttentionMaskDense)
+        : (Array[Long], Array[Long], Array[Array[Array[Array[Int]]]]) =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+        val posIdsLong = decoderInputIds.flatMap { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }
+        }
+        val crossAttentionMask =
+          inputs("crossAttentionMask").asInstanceOf[Array[Array[Array[Array[Int]]]]]
+        (inpIdsLong, posIdsLong, crossAttentionMask)
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        val posIdsLong = decoderInputIds.map { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }.last
+        }
+        val crossAttentionMask = decoderInputIds.map { sentence =>
+          MllamaUtils.getCrossAttentionTokenMask(sentence, imageToken)
+        }
+        val maxLength = decoderInputIds.map(_.length).max
+        val crossAttentionMaskDense = MllamaUtils.convertSparseCrossAttentionMaskToDense(
+          crossAttentionMask,
+          numTiles.map(_.toArray).toArray,
+          maxImageTiles,
+          maxLength)
+        (inpIdsLong, posIdsLong, crossAttentionMaskDense)
+      }
+    val attentionMask: Array[Long] =
+      decoderInputIds.flatMap { tokenIds => tokenIds.map(_ => 1L) }
+
+    val batchSize: Int = decoderInputIds.length
+    val beamIdx: Array[Int] = new Array[Int](batchSize)
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+
+    val inputIdsTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputIdsLong)
+
+    val decoderAttentionMask: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize, decoderInputIds.head.length), attentionMask)
+    val decoderPositionIDs: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputPositionIDsLong)
+    val beamIdxTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize), beamIdx)
+
+    val crossAttentionMaskDenseTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(
+        Array(
+          batchSize,
+          crossAttentionMaskDense.head.length,
+          crossAttentionMaskDense.head.head.length,
+          crossAttentionMaskDense.head.head.head.length),
+        crossAttentionMaskDense.flatten.flatten.flatten.map(_.toLong))
+
+    val numVisionTokensTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array[Int](), Array(numVisionTokens.toLong))
+
+    val pastCrossAttentionKVLength: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(
+        Array[Int](),
+        Array(
+          crossAttentionKeyValues.head._2
+            .get_shape()(crossAttentionKeyValues.head._2.get_shape().length - 2)
+            .toLong))
+    inferRequestReshapeModel.set_tensor("current_input_ids", inputIdsTensor)
+    inferRequestReshapeModel.set_tensor("attention_mask", decoderAttentionMask)
+    inferRequestReshapeModel.set_tensor("cross_attention_mask", crossAttentionMaskDenseTensor)
+    inferRequestReshapeModel.set_tensor("num_vision_tokens", numVisionTokensTensor)
+    inferRequestReshapeModel.set_tensor("past_cross_attn_kv_length", pastCrossAttentionKVLength)
+
+    inferRequestReshapeModel.infer()
+    val crossAttentionMaskReshaped =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        inferRequestReshapeModel.get_tensor("cross_attention_mask_first_pass")
+      } else {
+        inferRequestReshapeModel.get_tensor("cross_attention_mask_second_pass")
+      }
+    val cachePosition = inferRequestReshapeModel.get_tensor("cache_position")
+    val fullTextRowMaskedOutMask =
+      inferRequestReshapeModel.get_tensor("full_text_row_masked_out_mask")
+
+    // recreate the tensors by extracting the values from the reshaped tensors
+
+    val clonedCrossAttentionMaskReshapedTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(
+        crossAttentionMaskReshaped.get_shape(),
+        crossAttentionMaskReshaped.data().map(_.toFloat))
+
+    val clonedCachePositionTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(
+        cachePosition.get_shape(),
+        cachePosition.as_int().map(_.toLong))
+
+    val clonedFullTextRowMaskedOutMaskTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(
+        fullTextRowMaskedOutMask.get_shape(),
+        fullTextRowMaskedOutMask.data().map(_.toFloat))
+
+//    val crossAttentionMaskReshapedTensor: org.intel.openvino.Tensor =
+//      new org.intel.openvino.Tensor(
+//        crossAttentionMaskReshaped.get_shape(),
+//        crossAttentionMaskReshaped.as_int().map(_.toFloat))
+
+    inferRequestLanguageModel.set_tensor("input_ids", inputIdsTensor)
+    inferRequestLanguageModel.set_tensor("attention_mask", decoderAttentionMask)
+    inferRequestLanguageModel.set_tensor("position_ids", decoderPositionIDs)
+    inferRequestLanguageModel.set_tensor("beam_idx", beamIdxTensor)
+    inferRequestLanguageModel.set_tensor(
+      "cross_attention_mask",
+      clonedCrossAttentionMaskReshapedTensor)
+    inferRequestLanguageModel.set_tensor("cache_position", clonedCachePositionTensor)
+    inferRequestLanguageModel.set_tensor(
+      "full_text_row_masked_out_mask",
+      clonedFullTextRowMaskedOutMaskTensor)
+
+    for ((name, tensor) <- crossAttentionKeyValues) {
+      inferRequestLanguageModel.set_tensor(name, tensor)
+    }
+
+    inferRequestLanguageModel.infer()
+
+    val result = inferRequestLanguageModel.get_tensor("logits")
+    val logitsRaw = result.data()
+
+    val sequenceLength = inputIdsLong.length / batchSize
+    val decoderOutputs = (0 until batchSize).map(i => {
+      logitsRaw
+        .slice(
+          i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+          i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    })
+    decoderOutputs.toArray
+  }
+
+  private def argmax(scores: Array[Float]): Int = {
+    // Validate that the array is not empty
+    require(scores.nonEmpty, "Input array must not be empty")
+
+    // Initialize variables to track the maximum score and its index
+    var maxIndex = 0
+    var maxValue = scores(0)
+
+    // Iterate through the array to find the maximum value and its index
+    for (i <- 1 until scores.length) {
+      if (scores(i) > maxValue) {
+        maxValue = scores(i)
+        maxIndex = i
+      }
+    }
+
+    maxIndex
+  }
+
+  private def greedyGenerationFinished(
+      decoderIds: Seq[Array[Int]],
+      eosTokenId: Int,
+      maxOutputLength: Int): Boolean = {
+    if (decoderIds.isEmpty) {
+      false
+    } else {
+      decoderIds.forall { ids =>
+        ids.length >= maxOutputLength || ids.last == eosTokenId
+      }
+    }
+  }
+
+  private def encodeImage(
+      annotations: Array[AnnotationImage],
+      preprocessor: Preprocessor,
+      maxImageTiles: Int,
+      paddingConstant: Int): (
+      Array[Array[Array[Array[Array[Array[Float]]]]]],
+      Array[Array[Int]],
+      Array[Array[Array[Int]]],
+      List[List[Int]]) = {
+
+    val processed: Array[(Array[Array[Array[Array[Float]]]], List[(Int, Int)])] =
+      annotations.map { annot =>
+        val bufferedImage = ImageIOUtils.byteToBufferedImage(
+          bytes = annot.result,
+          w = annot.width,
+          h = annot.height,
+          nChannels = annot.nChannels)
+
+        val (resizedImage, (numTilesHeight, numTilesWidth)) =
+          if (preprocessor.do_resize) {
+            MllamaUtils.resizeImage(
+              width = preprocessor.size,
+              height = preprocessor.size,
+              resample = preprocessor.resample,
+              maxImageTiles = maxImageTiles)(bufferedImage)
+          } else (bufferedImage, (annot.height, annot.width))
+
+        val paddedImage = MllamaUtils.pad(
+          image = resizedImage,
+          paddingConstant = paddingConstant,
+          aspectRatio = (numTilesHeight, numTilesWidth),
+          tileHeight = preprocessor.size,
+          tileWidth = preprocessor.size)
+
+        val imageTiles: Array[Array[Array[Array[Float]]]] = MllamaUtils.splitToTiles(
+          image = paddedImage,
+          numTilesHeight = numTilesHeight,
+          numTilesWidth = numTilesWidth,
+          mean = preprocessor.image_mean,
+          std = preprocessor.image_std,
+          doNormalize = preprocessor.do_normalize,
+          doRescale = preprocessor.do_rescale,
+          rescaleFactor = preprocessor.rescale_factor)
+
+        val aspectRatioList: List[(Int, Int)] = List((numTilesHeight, numTilesWidth))
+
+        (imageTiles, aspectRatioList)
+      }
+
+    val (batchProcessedImages, batchAspectRatios) = processed.unzip
+
+    val (images, numTiles) =
+      MllamaUtils.packImages(
+        batchImages = List(batchProcessedImages),
+        maxImageTiles = maxImageTiles)
+
+    val aspectRatioIds: Array[Array[Int]] =
+      MllamaUtils.convertAspectRatiosToIds(
+        batchAspectRatios.toList,
+        maxImageTiles = maxImageTiles)
+
+    val aspectRatioMask: Array[Array[Array[Int]]] =
+      MllamaUtils.buildAspectRatioMask(batchAspectRatios.toList, maxImageTiles = maxImageTiles)
+
+    (images, aspectRatioIds, aspectRatioMask, numTiles)
+
+  }
+
+  def getCrossAttentionKeyValues(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Array[Array[Float]]]]]],
+      aspectRatioIds: Array[Array[Int]],
+      aspectRatioMask: Array[Array[Array[Int]]],
+      inferRequestVisionEmbeddingsModel: InferRequest)
+      : Array[(String, org.intel.openvino.Tensor)] = {
+
+    // filter out the cross attention output names only containing the word "cross_attn_key_values"
+    val crossAttentionOutputNames =
+      openvinoWrapper.get.visionEmbeddingsModel
+        .getCompiledModel()
+        .outputs()
+        .asScala
+        .filter(_.get_any_name().contains("cross_attn_key_values"))
+        .map(_.get_any_name())
+        .toArray
+
+    val crossAttentionKeyValues: Array[(String, org.intel.openvino.Tensor)] = {
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        val pixelValuesShape = Array(
+          pixelValues.length,
+          pixelValues.head.length,
+          pixelValues.head.head.length,
+          pixelValues.head.head.head.length,
+          pixelValues.head.head.head.head.length,
+          pixelValues.head.head.head.head.head.length)
+        val pixelValuesTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(
+            pixelValuesShape,
+            pixelValues.flatten.flatten.flatten.flatten.flatten)
+
+        val aspectRatioIdsShape = Array(aspectRatioIds.length, aspectRatioIds.head.length)
+        val aspectRatioIdsTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(aspectRatioIdsShape, aspectRatioIds.flatten.map(_.toLong))
+
+        val aspectRatioMaskShape = Array(
+          aspectRatioMask.length,
+          aspectRatioMask.head.length,
+          aspectRatioMask.head.head.length)
+
+        val aspectRatioMaskTensor: org.intel.openvino.Tensor = new org.intel.openvino.Tensor(
+          aspectRatioMaskShape,
+          aspectRatioMask.flatten.flatten.map(_.toLong))
+
+        // Get image embeddings
+        inferRequestVisionEmbeddingsModel.set_tensor("pixel_values", pixelValuesTensor)
+        inferRequestVisionEmbeddingsModel.set_tensor("aspect_ratio_ids", aspectRatioIdsTensor)
+        inferRequestVisionEmbeddingsModel.set_tensor("aspect_ratio_mask", aspectRatioMaskTensor)
+
+        inferRequestVisionEmbeddingsModel.infer()
+
+        val crossAttentionKeyValues: Array[(String, org.intel.openvino.Tensor)] =
+          crossAttentionOutputNames.map { outputName =>
+            (outputName, inferRequestVisionEmbeddingsModel.get_tensor(outputName))
+          }
+        // return the cross attention output names and the key values
+        crossAttentionKeyValues
+      } else {
+        // shouldn't be called
+        throw new IllegalArgumentException("Should not be called for subsequent passes")
+        Array()
+      }
+    }
+    crossAttentionKeyValues
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/OLMo.scala b/src/main/scala/com/johnsnowlabs/ml/ai/OLMo.scala
new file mode 100644
index 00000000000000..4ac08acc05d7ae
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/OLMo.scala
@@ -0,0 +1,363 @@
+/*
+ * Copyright 2017 - 2023  John Snow Labs
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package com.johnsnowlabs.ml.ai
+
+import ai.onnxruntime.{OnnxTensor, OrtEnvironment, OrtSession}
+import com.johnsnowlabs.ml.ai.util.Generation.{Generate, GenerationConfig}
+import com.johnsnowlabs.ml.onnx.OnnxSession
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.onnx.TensorResources.implicits._
+import com.johnsnowlabs.ml.tensorflow.sentencepiece.SentencePieceWrapper
+import com.johnsnowlabs.nlp.Annotation
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp.annotators.common.SentenceSplit
+import com.johnsnowlabs.nlp.annotators.tokenizer.bpe.{BpeTokenizer, OLMoTokenizer}
+import org.intel.openvino.InferRequest
+import org.tensorflow.{Session, Tensor}
+
+import scala.collection.JavaConverters._
+
+private[johnsnowlabs] class OLMo(
+    val onnxWrappers: DecoderWrappers,
+    merges: Map[(String, String), Int],
+    vocabulary: Map[String, Int],
+    generationConfig: GenerationConfig)
+    extends Serializable
+    with Generate {
+
+  private val onnxSessionOptions: Map[String, String] = new OnnxSession().getSessionOptions
+  val bpeTokenizer: OLMoTokenizer = BpeTokenizer
+    .forModel("olmo", merges = merges, vocab = vocabulary, padWithSequenceTokens = false)
+    .asInstanceOf[OLMoTokenizer]
+  private val GenerationConfig(
+    bosTokenId: Int,
+    paddingTokenId: Int,
+    eosTokenId: Int,
+    vocabSize: Int,
+    beginSuppressTokens,
+    suppressTokenIds,
+    forcedDecoderIds) =
+    generationConfig
+
+  /** Decode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of decoded sentences
+    */
+  def decode(sentences: Array[Array[Int]]): Seq[String] = {
+    sentences.map(s => bpeTokenizer.decodeTokens(s.map(_.toInt)))
+  }
+
+  /** Encode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of encoded sentences
+    */
+  def encode(sentences: Seq[Annotation]): Seq[Array[Int]] = {
+    SentenceSplit
+      .unpack(sentences)
+      .map(s => {
+        val sentWithTask = s
+        bpeTokenizer
+          .tokenize(sentWithTask)
+          .map(bpeTokenizer.encode)
+          .flatMap(_.map(_.pieceId))
+      })
+  }
+
+  def tag(
+      batch: Seq[Array[Int]],
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long],
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int): Array[Array[Int]] = {
+    val (encoderSession, env) = onnxWrappers.decoder.getSession(onnxSessionOptions)
+    val ignoreTokenIdsInt = ignoreTokenIds
+    val expandedDecoderInputsVals = batch
+    val sequencesLength = expandedDecoderInputsVals.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+
+    val numReturn_sequences = 1
+    // from config
+
+    var effectiveBatch_size = 1
+    var effectiveBatch_mult = 1
+
+    if (doSample) {
+      effectiveBatch_size = expandedDecoderInputsVals.length * numReturn_sequences
+      effectiveBatch_mult = numReturn_sequences
+    } else {
+      effectiveBatch_size = expandedDecoderInputsVals.length
+      effectiveBatch_mult = 1
+    }
+
+    // Run the prompt through the decoder and get the past
+//    val decoderOutputs =
+//      generateGreedyOnnx(
+//        expandedDecoderInputsVals.toArray,
+//        (encoderSession, env),
+//        maxOutputLength)
+
+    // dummy tensors for decoder encode state and attention mask
+    val decoderEncoderStateTensors = Right(OnnxTensor.createTensor(env, Array(0)))
+    val encoderAttentionMaskTensors = Right(OnnxTensor.createTensor(env, Array(1)))
+
+    // output with beam search
+    val modelOutputs = generate(
+      batch,
+      decoderEncoderStateTensors,
+      encoderAttentionMaskTensors,
+      expandedDecoderInputsVals.toArray,
+      maxOutputLength + maxSentenceLength,
+      minOutputLength,
+      doSample,
+      beamSize,
+      1,
+      temperature,
+      topK,
+      topP,
+      repetitionPenalty,
+      noRepeatNgramSize,
+      this.vocabSize,
+      this.eosTokenId,
+      this.paddingTokenId,
+      randomSeed,
+      ignoreTokenIdsInt,
+      Right((env, encoderSession)),
+      applySoftmax = false)
+
+//    decoderOutputs
+    modelOutputs
+  }
+
+  def predict(
+      sentences: Seq[Annotation],
+      batchSize: Int,
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long] = None,
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int): Seq[Annotation] = {
+
+    val batchDecoder = sentences.grouped(batchSize).toArray.flatMap { batch =>
+      val batchSP = encode(batch)
+      val spIds = tag(
+        batchSP,
+        minOutputLength,
+        maxOutputLength,
+        doSample,
+        temperature,
+        topK,
+        topP,
+        repetitionPenalty,
+        noRepeatNgramSize,
+        randomSeed,
+        ignoreTokenIds,
+        beamSize,
+        maxInputLength)
+
+      decode(spIds)
+
+    }
+
+    var sentBegin, nextSentEnd = 0
+    val annotations = batchDecoder.zip(sentences).map { case (content, sent) =>
+      nextSentEnd += content.length - 1
+      val annots = new Annotation(
+        annotatorType = DOCUMENT,
+        begin = sentBegin,
+        end = nextSentEnd,
+        result = content,
+        metadata = sent.metadata)
+      sentBegin += nextSentEnd + 1
+      annots
+    }
+    annotations
+  }
+
+  private def getDecoderOutputsWithPast(
+      inputIds: Array[Array[Int]],
+      decoderPast: Map[String, OnnxTensor],
+      onnxSession: (OrtSession, OrtEnvironment))
+      : (Array[Array[Float]], Map[String, OnnxTensor]) = {
+    val (session, env) = onnxSession
+
+    val lastTokens: Array[Array[Long]] =
+      inputIds.map { tokenIds =>
+        Array(tokenIds.last.toLong)
+      }
+
+    val lastTokensTensor: OnnxTensor =
+      OnnxTensor.createTensor(env, lastTokens)
+    val decoderAttentionMask: OnnxTensor =
+      OnnxTensor.createTensor(env, lastTokens.map(_.map(_ => 1L)))
+    val decoderWithPastInputs: java.util.Map[String, OnnxTensor] = (Map(
+      OnnxSignatures.decoderInputIDs -> lastTokensTensor,
+      OnnxSignatures.decoderAttentionMask -> decoderAttentionMask) ++ decoderPast).asJava
+    val sessionOutput = session.run(decoderWithPastInputs)
+    val logits = sessionOutput.getFloatArray(OnnxSignatures.decoderOutput)
+    val decoderPresent = sessionOutput.getOnnxTensors(OnnxSignatures.decoderPresent)
+    lastTokensTensor.close()
+    val batchLogits = logits.grouped(vocabSize).toArray
+    (batchLogits, decoderPresent)
+
+  }
+
+  override def getModelOutput(
+      encoderInputIds: Seq[Array[Int]],
+      decoderInputIds: Seq[Array[Int]],
+      decoderEncoderStateTensors: Either[Tensor, OnnxTensor],
+      encoderAttentionMaskTensors: Either[Tensor, OnnxTensor],
+      maxLength: Int,
+      session: Either[Session, (OrtEnvironment, OrtSession)],
+      ovInferRequest: Option[InferRequest]): Array[Array[Float]] = {
+
+    session.fold(
+      tfSession => {
+        // not implemented yet
+        Array()
+      },
+      onnxSession => {
+        val (env, decoderSession) = onnxSession
+        val decoderOutputs =
+          getDecoderOutputs(decoderInputIds.toArray, onnxSession = (decoderSession, env))
+        decoderOutputs
+      })
+
+  }
+  private def getDecoderOutputs(
+      inputIds: Array[Array[Int]],
+      onnxSession: (OrtSession, OrtEnvironment)): (Array[Array[Float]]) = {
+    val (session, env) = onnxSession
+
+    val inputIdsLong: Array[Array[Long]] =
+      inputIds.map { tokenIds => tokenIds.map(_.toLong) }
+
+    val inputPositionIDsLong: Array[Array[Long]] =
+      inputIds.map { tokenIds =>
+        tokenIds.zipWithIndex.map { case (_, i) =>
+          i.toLong
+        }
+      }
+
+    val inputIdsLongTensor: OnnxTensor =
+      OnnxTensor.createTensor(env, inputIdsLong)
+    val decoderAttentionMask: OnnxTensor =
+      OnnxTensor.createTensor(env, inputIdsLong.map(_.map(_ => 1L)))
+    val decoderPositionIDs: OnnxTensor =
+      OnnxTensor.createTensor(env, inputPositionIDsLong)
+
+    val decoderInputs: java.util.Map[String, OnnxTensor] = Map(
+      OnnxSignatures.decoderInputIDs -> inputIdsLongTensor,
+      OnnxSignatures.decoderAttentionMask -> decoderAttentionMask,
+      OnnxSignatures.decoderPositionIDs -> decoderPositionIDs).asJava
+    val sessionOutput = session.run(decoderInputs)
+
+    val sequenceLength = inputIds.head.length
+    val batchSize = inputIds.length
+
+//    val logits = sessionOutput.getFloatArray(OnnxSignatures.decoderOutput)
+//    inputIdsLongTensor.close()
+//    decoderPositionIDs.close()
+//    decoderAttentionMask.close()
+//    val batchLogits = logits.grouped(vocabSize).toArray
+//    batchLogits
+
+    val logitsRaw = sessionOutput.getFloatArray(OnnxSignatures.decoderOutput)
+    val decoderOutputs = (0 until batchSize).map(i => {
+      logitsRaw
+        .slice(
+          i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+          i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    })
+    decoderOutputs.toArray
+  }
+
+  /** Gets the index with the highest score
+    *
+    * @param scores
+    *   Array of Scores to max
+    * @return
+    *   Index of the highest score
+    */
+  private def argmax(scores: Array[Float]): Int =
+    scores.zipWithIndex.maxBy { case (score, _) =>
+      score
+    }._2
+  private def greedyGenerationFinished(
+      decoderIds: Seq[Array[Int]],
+      eosTokenId: Int,
+      maxOutputLength: Int): Boolean =
+    decoderIds.map(_.last).forall(_ == eosTokenId) || decoderIds.head.length == maxOutputLength
+
+  private def generateGreedyOnnx(
+      inputIds: Array[Array[Int]],
+      onnxSession: (OrtSession, OrtEnvironment),
+      maxOutputLength: Int): (Array[Array[Int]]) = {
+
+    val sequencesLength = inputIds.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+    var generatedIds: Array[Array[Int]] = inputIds
+    while (!greedyGenerationFinished(
+        generatedIds,
+        eosTokenId,
+        maxOutputLength + maxSentenceLength)) {
+
+      val (batchLogits: Array[Array[Float]]) =
+        Array(getDecoderOutputs(generatedIds, onnxSession).last)
+
+      val nextTokenIds: Array[Int] = batchLogits.map(argmax)
+      generatedIds =
+        generatedIds.zip(nextTokenIds).map { case (currentIds: Array[Int], nextId: Int) =>
+          currentIds ++ Array(nextId)
+        }
+    }
+    generatedIds
+  }
+
+  private object OnnxSignatures {
+    val decoderInputIDs: String = "input_ids"
+    val decoderAttentionMask: String = "attention_mask"
+    val decoderPositionIDs: String = "position_ids"
+
+    // create decoder past for 32 layers of key and value eg. past_key_values.0.key and past_key_values.0.value
+    val decoderPast: Array[String] = (0 until 32)
+      .flatMap(i => Seq(s"past_key_values.$i.key", s"past_key_values.$i.value"))
+      .toArray
+    val decoderOutput: String = "logits"
+    val decoderPresent: Array[String] =
+      (0 until 32).flatMap(i => Seq(s"present.$i.key", s"present.$i.value")).toArray
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/Phi3V.scala b/src/main/scala/com/johnsnowlabs/ml/ai/Phi3V.scala
new file mode 100644
index 00000000000000..f00ae3e2e39810
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/Phi3V.scala
@@ -0,0 +1,489 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.ml.ai
+
+import breeze.optimize.BatchSize
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.Phi3VWrappers
+import com.johnsnowlabs.nlp.annotators.common.Sentence
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.nlp.annotators.common.SentenceSplit
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.nlp.annotators.cv.util.io.ImageIOUtils
+import com.johnsnowlabs.nlp.annotators.cv.util.transform.ImageResizeUtils
+import com.johnsnowlabs.nlp.annotators.cv.util.transform.Phi3vUtils
+import com.johnsnowlabs.nlp.annotators.tokenizer.bpe.{
+  BpeTokenizer,
+  Phi3VisionTokenizer,
+  SpecialTokens
+}
+import org.intel.openvino.InferRequest
+
+import scala.collection.JavaConverters._
+
+private[johnsnowlabs] class Phi3V(
+    val onnxWrappers: Option[DecoderWrappers],
+    val openvinoWrapper: Option[Phi3VWrappers],
+    merges: Map[(String, String), Int],
+    vocabulary: Map[String, Int],
+    addedTokens: Map[String, Int],
+    generationConfig: GenerationConfig)
+    extends Serializable {
+
+  val detectedEngine: String =
+    if (onnxWrappers.isDefined) ONNX.name
+    else if (openvinoWrapper.isDefined) Openvino.name
+    else Openvino.name
+
+  private val GenerationConfig(
+    bosTokenId: Int,
+    paddingTokenId: Int,
+    eosTokenId: Int,
+    vocabSize: Int,
+    beginSuppressTokens,
+    suppressTokenIds,
+    forcedDecoderIds) =
+    generationConfig
+  val reversedVocabulary: Map[Int, String] = vocabulary.map(_.swap)
+
+  val specialTokens: SpecialTokens = SpecialTokens(
+    vocabulary,
+    startTokenString = reversedVocabulary(bosTokenId),
+    endTokenString = reversedVocabulary(eosTokenId),
+    unkTokenString = reversedVocabulary(eosTokenId),
+    maskTokenString = reversedVocabulary(eosTokenId),
+    padTokenString = reversedVocabulary(paddingTokenId),
+    additionalStrings = addedTokens.keys.toArray)
+
+  val bpeTokenizer: Phi3VisionTokenizer = BpeTokenizer
+    .forModel(
+      "phi3v",
+      merges = merges,
+      vocab = vocabulary,
+      specialTokens = Some(specialTokens),
+      addPrefixSpaceToSentence = true,
+      alwaysAddPrefix = false,
+      prependString = "")
+    .asInstanceOf[Phi3VisionTokenizer]
+
+  /** Decode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of decoded sentences
+    */
+  def decode(sentences: Array[Array[Int]]): Seq[String] = {
+    sentences.map(s => bpeTokenizer.decodeTokens(s.map(_.toInt)))
+  }
+
+  /** Encode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of encoded sentences
+    */
+  def encodeText(sentences: Seq[Annotation], imgTokenLen: List[Int]): Seq[Array[Int]] = {
+
+    val pattern = raw"<\|image_\d+\|>".r
+
+    // raise an error if the pattern is not found in the text
+    if (pattern.findFirstIn(sentences.head.result).isEmpty) {
+      throw new IllegalArgumentException(
+        "The pattern <\\|image_\\d+\\|> is not found in the text")
+    }
+
+    // split the sentences into chunks based on the pattern and tokenize them
+    // eg in python prompt_chunks = [self.tokenizer(chunk).input_ids for chunk in re.split(pattern, texts)]
+    val promptChunks = sentences
+      .map(s => {
+        val sentWithTask = s.result
+        var offsetLength = 0
+        pattern
+          .split(sentWithTask)
+          .zipWithIndex
+          .map(s => {
+            val sentenceWithTask = Sentence(
+              content = s._1,
+              start = offsetLength,
+              end = offsetLength + s._1.length,
+              index = s._2)
+            offsetLength += s._1.length
+            bpeTokenizer
+              .tokenize(sentenceWithTask)
+              .map(bpeTokenizer.encode)
+              .flatMap(_.map(_.pieceId))
+          })
+      })
+
+    // inject the image padding tokens of length imgTokenLen between the prompt chunks and reduce the Seq[Array[Array[Int]]] to Seq[Array[Int]]
+    val tokens = promptChunks
+      .zip(imgTokenLen)
+      .map(s => {
+        val (promptChunk, imgTokenLen) = s
+        val imgPaddingTokens = Array.fill(imgTokenLen)(-1)
+        val combinedChunks = promptChunk
+          .map(_.toArray)
+          .reduce(_ ++ imgPaddingTokens ++ _)
+        Array(bosTokenId) ++ combinedChunks ++ Array(eosTokenId)
+      })
+
+//    val tokens = SentenceSplit
+//      .unpack(sentences)
+//      .map(s => {
+//        val sentWithTask = s
+//        bpeTokenizer
+//          .tokenize(sentWithTask)
+//          .map(bpeTokenizer.encode)
+//          .flatMap(_.map(_.pieceId))
+//      })
+    tokens
+  }
+  def encode(
+      imageAnnotations: Seq[AnnotationImage],
+      sentences: Seq[Annotation],
+      numOfCrops: Int = 16): (
+      Seq[Array[Int]],
+      (Array[Array[Array[Array[Array[Float]]]]], Array[Array[Int]], List[Int])) = {
+    val preprocessedImages = preprocessImage(imageAnnotations, numOfCrops)
+    val encodedText = encodeText(sentences, preprocessedImages._3).toArray
+
+    (encodedText, preprocessedImages)
+  }
+
+  def tag(
+      batch: Seq[Array[Int]],
+      images: (Array[Array[Array[Array[Array[Float]]]]], Array[Array[Int]], List[Int]),
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long],
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int,
+      stopTokenIds: Array[Int],
+      numOfCrops: Int = 16): Array[Array[Int]] = {
+
+    val (pixelValues, imageSizes, imgTokens) = images
+    val ignoreTokenIdsInt = ignoreTokenIds
+    val expandedDecoderInputsVals = batch
+    val sequencesLength = expandedDecoderInputsVals.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+//    val pixelValues = images._1
+//    val imageSizes = images._2
+    val numReturn_sequences = 1
+    // from config
+
+    var effectiveBatch_size = 1
+    var effectiveBatch_mult = 1
+
+    if (doSample) {
+      effectiveBatch_size = expandedDecoderInputsVals.length * numReturn_sequences
+      effectiveBatch_mult = numReturn_sequences
+    } else {
+      effectiveBatch_size = expandedDecoderInputsVals.length
+      effectiveBatch_mult = 1
+    }
+
+    val inferRequestWTE = openvinoWrapper.get.wte.getCompiledModel().create_infer_request()
+    val inferRequestReshape =
+      openvinoWrapper.get.reshape.getCompiledModel().create_infer_request()
+    val inferRequestLanguageModel =
+      openvinoWrapper.get.languageModel.getCompiledModel().create_infer_request()
+
+    val generatedIds = generateGreedy(
+      batch.toArray,
+      batch.toArray,
+      pixelValues,
+      imageSizes,
+      maxOutputLength,
+      numOfCrops,
+      inferRequestWTE,
+      inferRequestReshape,
+      inferRequestLanguageModel)
+    generatedIds
+  }
+
+  def generateGreedy(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Array[Float]]]]],
+      imageSizes: Array[Array[Int]],
+      maxOutputLength: Int,
+      numOfCrops: Int,
+      inferRequestWTE: InferRequest,
+      inferRequestReshape: InferRequest,
+      inferRequestLanguageModel: InferRequest): Array[Array[Int]] = {
+
+    var generatedIds: Array[Array[Int]] = Array()
+    var decoderInputIdsCopied = decoderInputIds
+    while (!greedyGenerationFinished(generatedIds, eosTokenId, maxOutputLength)) {
+      val decoderOutputs = getModelOutputs(
+        encoderInputIds,
+        decoderInputIdsCopied,
+        pixelValues,
+        imageSizes,
+        numOfCrops,
+        inferRequestWTE,
+        inferRequestReshape,
+        inferRequestLanguageModel)
+
+      val nextTokenIds = decoderOutputs.map { scores =>
+        argmax(scores)
+      }
+
+      if (generatedIds.isEmpty) {
+        generatedIds = nextTokenIds.map(Array(_))
+      } else {
+        generatedIds =
+          generatedIds.zip(nextTokenIds).map { case (currentIds: Array[Int], nextId: Int) =>
+            currentIds ++ Array(nextId)
+          }
+      }
+
+      // extend decoder input ids
+      decoderInputIdsCopied =
+        decoderInputIdsCopied.zip(nextTokenIds).map { case (currentIds, nextId) =>
+          currentIds ++ Array(nextId)
+        }
+    }
+    generatedIds
+  }
+
+  def predict(
+      sentences: Seq[Annotation],
+      imageAnnotations: Seq[AnnotationImage],
+      batchSize: Int,
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long] = None,
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int): Seq[Annotation] = {
+
+    val (encodedText, preprocessedImages) = encode(imageAnnotations, sentences)
+    val (pixelValues, imageSizes, imgTokens) = preprocessedImages
+    val tagged = tag(
+      encodedText,
+      preprocessedImages,
+      minOutputLength,
+      maxOutputLength,
+      doSample,
+      temperature,
+      topK,
+      topP,
+      repetitionPenalty,
+      noRepeatNgramSize,
+      randomSeed,
+      ignoreTokenIds,
+      beamSize,
+      maxInputLength,
+      Array(eosTokenId))
+    val decoded = decode(tagged)
+
+    var sentBegin, nextSentEnd = 0
+    val annotations = decoded.map { content =>
+      nextSentEnd += content.length - 1
+      val annots = new Annotation(
+        annotatorType = DOCUMENT,
+        begin = sentBegin,
+        end = nextSentEnd,
+        result = content,
+        metadata = Map())
+      sentBegin += nextSentEnd + 1
+      annots
+    }
+    annotations
+  }
+
+  def getModelOutputs(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Array[Float]]]]],
+      imageSizes: Array[Array[Int]],
+      numOfCrops: Int,
+      inferRequestWTE: InferRequest,
+      inferRequestReshape: InferRequest,
+      inferRequestLanguageModel: InferRequest): Array[Array[Float]] = {
+
+    val imageEmbeddings = getImageEmbeddings(
+      encoderInputIds,
+      decoderInputIds,
+      pixelValues,
+      imageSizes,
+      numOfCrops,
+      inferRequestReshape,
+      inferRequestWTE)
+
+    val (inputIdsLong, inputPositionIDsLong): (Array[Long], Array[Long]) =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+        val posIdsLong = decoderInputIds.flatMap { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }
+        }
+        (inpIdsLong, posIdsLong)
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        val posIdsLong = decoderInputIds.map { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }.last
+        }
+        (inpIdsLong, posIdsLong)
+      }
+    val attentionMask: Array[Long] =
+      decoderInputIds.flatMap { tokenIds => tokenIds.map(_ => 1L) }
+
+    val batchSize: Int = decoderInputIds.length
+    val beamIdx: Array[Int] = new Array[Int](batchSize)
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+
+    val decoderAttentionMask: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize, decoderInputIds.head.length), attentionMask)
+    val decoderPositionIDs: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputPositionIDsLong)
+    val beamIdxTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize), beamIdx)
+
+    inferRequestLanguageModel.set_tensor("inputs_embeds", imageEmbeddings)
+    inferRequestLanguageModel.set_tensor("attention_mask", decoderAttentionMask)
+    inferRequestLanguageModel.set_tensor("position_ids", decoderPositionIDs)
+    inferRequestLanguageModel.set_tensor("beam_idx", beamIdxTensor)
+
+    inferRequestLanguageModel.infer()
+
+    val result = inferRequestLanguageModel.get_tensor("logits")
+    val logitsRaw = result.data()
+
+    val sequenceLength = inputIdsLong.length / batchSize
+    val decoderOutputs = (0 until batchSize).map(i => {
+      logitsRaw
+        .slice(
+          i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+          i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    })
+    decoderOutputs.toArray
+  }
+
+  private def argmax(scores: Array[Float]): Int =
+    scores.zipWithIndex.maxBy { case (score, _) =>
+      score
+    }._2
+
+  private def greedyGenerationFinished(
+      decoderIds: Seq[Array[Int]],
+      eosTokenId: Int,
+      maxOutputLength: Int): Boolean = {
+    if (decoderIds.isEmpty) {
+      false
+    } else {
+      decoderIds.forall { ids =>
+        ids.length >= maxOutputLength || ids.last == eosTokenId
+      }
+    }
+  }
+
+  def preprocessImage(imageAnnotations: Seq[AnnotationImage], numOfCrops: Int = 16)
+      : (Array[Array[Array[Array[Array[Float]]]]], Array[Array[Int]], List[Int]) = {
+
+    val hdTransformedImage = imageAnnotations
+      .map(annotations => {
+        val bufferedImage = ImageIOUtils.byteToBufferedImage(
+          bytes = annotations.result,
+          w = annotations.width,
+          h = annotations.height,
+          nChannels = annotations.nChannels)
+
+        Phi3vUtils.HDTransform(bufferedImage, numOfCrops)
+      })
+      .toList
+    val (processedImages, imageSizes, imgTokens) =
+      Phi3vUtils.processHdImages(hdTransformedImage, numOfCrops)
+    val pixelValues =
+      Phi3vUtils.processedImagesTo5DArray(processedImages, normalize = true)
+    (pixelValues, imageSizes, imgTokens)
+  }
+
+  def getImageEmbeddings(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: Array[Array[Array[Array[Array[Float]]]]],
+      imageSizes: Array[Array[Int]],
+      numOfCrops: Int,
+      inferRequestReshape: InferRequest,
+      inferRequestWTE: InferRequest): org.intel.openvino.Tensor = {
+    val inputIdsLong: Array[Long] =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+
+        inpIdsLong
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        inpIdsLong
+      }
+    val batchSize: Int = decoderInputIds.length
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+    val inputIdsLongTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputIdsLong)
+
+    val imageEmbeddings: org.intel.openvino.Tensor =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        val pixelValuesTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(
+            Array(batchSize, numOfCrops + 1, 3, 336, 336),
+            pixelValues.flatten.flatten.flatten.flatten.map(_.toFloat))
+
+        val imageSizesTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(Array(batchSize, 2), imageSizes.flatten.map(_.toLong))
+        inferRequestReshape.set_tensor("input_ids", inputIdsLongTensor)
+        inferRequestReshape.set_tensor("pixel_values", pixelValuesTensor)
+        inferRequestReshape.set_tensor("image_sizes", imageSizesTensor)
+
+        inferRequestReshape.infer()
+
+        inferRequestReshape.get_output_tensor()
+
+      } else {
+        inferRequestWTE.set_input_tensor(inputIdsLongTensor)
+
+        inferRequestWTE.infer()
+
+        inferRequestWTE.get_output_tensor()
+      }
+    imageEmbeddings
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/Qwen2VL.scala b/src/main/scala/com/johnsnowlabs/ml/ai/Qwen2VL.scala
new file mode 100644
index 00000000000000..91ac3d6c2f858b
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/Qwen2VL.scala
@@ -0,0 +1,644 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.ml.ai
+
+import breeze.optimize.BatchSize
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.Qwen2VLWrappers
+import com.johnsnowlabs.nlp.annotators.common.Sentence
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.nlp.annotators.common.SentenceSplit
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.nlp.annotators.cv.util.io.ImageIOUtils
+import com.johnsnowlabs.nlp.annotators.cv.util.transform.ImageResizeUtils
+import com.johnsnowlabs.nlp.annotators.cv.util.transform.Qwen2VLUtils.{
+  IMAGE_FACTOR,
+  MAX_PIXELS,
+  MAX_RATIO,
+  MIN_PIXELS,
+  imageBufferToArray,
+  smartResize
+}
+import com.johnsnowlabs.nlp.annotators.tokenizer.bpe.{
+  BpeTokenizer,
+  LLAMA3Tokenizer,
+  Qwen2VLTokenizer,
+  SpecialTokens
+}
+import org.intel.openvino.InferRequest
+
+import scala.collection.JavaConverters._
+
+private[johnsnowlabs] class Qwen2VL(
+    val onnxWrappers: Option[DecoderWrappers],
+    val openvinoWrapper: Option[Qwen2VLWrappers],
+    merges: Map[(String, String), Int],
+    vocabulary: Map[String, Int],
+    addedTokens: Map[String, Int],
+    preprocessor: Preprocessor,
+    generationConfig: GenerationConfig,
+    minPixels: Int = MIN_PIXELS,
+    maxPixels: Int = MAX_PIXELS,
+    imageToken: Int = 151655)
+    extends Serializable {
+
+  val detectedEngine: String =
+    if (onnxWrappers.isDefined) ONNX.name
+    else if (openvinoWrapper.isDefined) Openvino.name
+    else Openvino.name
+
+  private val GenerationConfig(
+    bosTokenId: Int,
+    paddingTokenId: Int,
+    eosTokenId: Int,
+    vocabSize: Int,
+    beginSuppressTokens,
+    suppressTokenIds,
+    forcedDecoderIds) =
+    generationConfig
+  val reversedVocabulary: Map[Int, String] = vocabulary.map(_.swap)
+
+  val specialTokens: SpecialTokens = SpecialTokens(
+    vocabulary,
+    startTokenString = reversedVocabulary(bosTokenId),
+    endTokenString = reversedVocabulary(eosTokenId),
+    unkTokenString = reversedVocabulary(eosTokenId),
+    maskTokenString = reversedVocabulary(eosTokenId),
+    padTokenString = reversedVocabulary(paddingTokenId),
+    additionalStrings = addedTokens.keys.toArray)
+
+  val bpeTokenizer: Qwen2VLTokenizer = BpeTokenizer
+    .forModel(
+      "qwen2vl",
+      merges = merges,
+      vocab = vocabulary,
+      specialTokens = Some(specialTokens),
+      addPrefixSpaceToSentence = false,
+      alwaysAddPrefix = false,
+      prependString = "")
+    .asInstanceOf[Qwen2VLTokenizer]
+
+  /** Decode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of decoded sentences
+    */
+  def decode(sentences: Array[Array[Int]]): Seq[String] = {
+    sentences.map(s => bpeTokenizer.decodeTokens(s.map(_.toInt)))
+  }
+
+  /** Encode a sequence of sentences
+    * @param sentences
+    *   Sequence of sentences
+    * @return
+    *   Sequence of encoded sentences
+    */
+  def encodeText(sentences: Seq[Annotation], imgTokenLen: List[Int]): Seq[Array[Int]] = {
+
+//    val pattern = raw"<\|image_\d+\|>".r
+//    <|vision_start|><|image_pad|><|vision_end|>
+
+    val pattern = raw"<\|image_pad\|>".r
+    // raise an error if the pattern is not found in the text
+    if (pattern.findFirstIn(sentences.head.result).isEmpty) {
+      throw new IllegalArgumentException("The pattern <\\|image_pad\\|> is not found in the text")
+    }
+
+    // split the sentences into chunks based on the pattern and tokenize them
+    // eg in python prompt_chunks = [self.tokenizer(chunk).input_ids for chunk in re.split(pattern, texts)]
+    val promptChunks = sentences
+      .map(s => {
+        val sentWithTask = s.result
+        var offsetLength = 0
+        pattern
+          .split(sentWithTask)
+          .zipWithIndex
+          .map(s => {
+            val sentenceWithTask = Sentence(
+              content = s._1,
+              start = offsetLength,
+              end = offsetLength + s._1.length,
+              index = s._2)
+            offsetLength += s._1.length
+            bpeTokenizer
+              .tokenize(sentenceWithTask)
+              .map(bpeTokenizer.encode)
+              .flatMap(_.map(_.pieceId))
+          })
+      })
+
+    // inject the image padding tokens of length imgTokenLen between the prompt chunks and reduce the Seq[Array[Array[Int]]] to Seq[Array[Int]]
+    val tokens = promptChunks
+      .zip(imgTokenLen)
+      .map(s => {
+        val (promptChunk, imgTokenLen) = s
+        val imgPaddingTokens = Array.fill(imgTokenLen)(imageToken)
+        val combinedChunks = promptChunk
+          .map(_.toArray)
+          .reduce(_ ++ imgPaddingTokens ++ _)
+        Array(bosTokenId) ++ combinedChunks
+      })
+
+    //    val tokens = SentenceSplit
+    //      .unpack(sentences)
+    //      .map(s => {
+    //        val sentWithTask = s
+    //        bpeTokenizer
+    //          .tokenize(sentWithTask)
+    //          .map(bpeTokenizer.encode)
+    //          .flatMap(_.map(_.pieceId))
+    //      })
+    tokens
+  }
+  def encode(
+      imageAnnotations: Seq[AnnotationImage],
+      sentences: Seq[Annotation],
+      preprocessor: Preprocessor)
+      : (Seq[Array[Int]], (org.intel.openvino.Tensor, (Int, Int, Int))) = {
+    val preprocessedImages = preprocessImage(
+      imageAnnotations,
+      preprocessor,
+      minPixels = minPixels,
+      maxPixels = maxPixels)
+    val imageTokenLength = preprocessedImages._2._2 * preprocessedImages._2._3 / 4
+    val encodedText = encodeText(sentences, List(imageTokenLength)).toArray
+
+    (encodedText, preprocessedImages)
+  }
+
+  def tag(
+      batch: Seq[Array[Int]],
+      images: (org.intel.openvino.Tensor, (Int, Int, Int)),
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long],
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int,
+      stopTokenIds: Array[Int],
+      numOfCrops: Int = 16): Array[Array[Int]] = {
+
+    val (pixelValues, (grid_t, grid_h, grid_w)) = images
+    val imageGridTHW: Array[Array[Int]] = Array(Array(grid_t, grid_h, grid_w))
+    val ignoreTokenIdsInt = ignoreTokenIds
+    val expandedDecoderInputsVals = batch
+    val sequencesLength = expandedDecoderInputsVals.map(x => x.length).toArray
+    val maxSentenceLength = sequencesLength.max // - curLen
+    //    val pixelValues = images._1
+    //    val imageSizes = images._2
+    val numReturn_sequences = 1
+    // from config
+
+    var effectiveBatch_size = 1
+    var effectiveBatch_mult = 1
+
+    if (doSample) {
+      effectiveBatch_size = expandedDecoderInputsVals.length * numReturn_sequences
+      effectiveBatch_mult = numReturn_sequences
+    } else {
+      effectiveBatch_size = expandedDecoderInputsVals.length
+      effectiveBatch_mult = 1
+    }
+
+    val inferRequestImageEmbed =
+      openvinoWrapper.get.imageEmbedding.getCompiledModel().create_infer_request()
+    val inferRequestImageEmbedMerger =
+      openvinoWrapper.get.imageEmbeddingMerger.getCompiledModel().create_infer_request()
+    val inferRequestRotaryEmbedding =
+      openvinoWrapper.get.rotaryEmbedding.getCompiledModel().create_infer_request()
+    val inferRequestTextEmbedding =
+      openvinoWrapper.get.textEmbedding.getCompiledModel().create_infer_request()
+    val inferRequestMultimodalModelMerge =
+      openvinoWrapper.get.multimodalMergeModel.getCompiledModel().create_infer_request()
+    val inferRequestLanguageModel =
+      openvinoWrapper.get.languageModel.getCompiledModel().create_infer_request()
+
+    val generatedIds = generateGreedy(
+      batch.toArray,
+      batch.toArray,
+      pixelValues,
+      imageGridTHW,
+      maxOutputLength,
+      inferRequestImageEmbed,
+      inferRequestImageEmbedMerger,
+      inferRequestRotaryEmbedding,
+      inferRequestTextEmbedding,
+      inferRequestMultimodalModelMerge,
+      inferRequestLanguageModel)
+    generatedIds
+  }
+
+  def generateGreedy(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: org.intel.openvino.Tensor,
+      imageGridTHW: Array[Array[Int]],
+      maxOutputLength: Int,
+      inferRequestImageEmbed: InferRequest,
+      inferRequestImageEmbedMerger: InferRequest,
+      inferRequestRotaryEmbedding: InferRequest,
+      inferRequestTextEmbedding: InferRequest,
+      inferRequestMultimodalModelMerge: InferRequest,
+      inferRequestLanguageModel: InferRequest): Array[Array[Int]] = {
+
+    var generatedIds: Array[Array[Int]] = Array()
+    var decoderInputIdsCopied = decoderInputIds
+    while (!greedyGenerationFinished(generatedIds, eosTokenId, maxOutputLength)) {
+      val decoderOutputs = getModelOutputs(
+        encoderInputIds,
+        decoderInputIdsCopied,
+        pixelValues,
+        imageGridTHW,
+        inferRequestImageEmbed,
+        inferRequestImageEmbedMerger,
+        inferRequestRotaryEmbedding,
+        inferRequestTextEmbedding,
+        inferRequestMultimodalModelMerge,
+        inferRequestLanguageModel)
+
+      val nextTokenIds = decoderOutputs.map { scores =>
+        argmax(scores)
+      }
+
+      if (generatedIds.isEmpty) {
+        generatedIds = nextTokenIds.map(Array(_))
+      } else {
+        generatedIds =
+          generatedIds.zip(nextTokenIds).map { case (currentIds: Array[Int], nextId: Int) =>
+            currentIds ++ Array(nextId)
+          }
+      }
+
+      // extend decoder input ids
+      decoderInputIdsCopied =
+        decoderInputIdsCopied.zip(nextTokenIds).map { case (currentIds, nextId) =>
+          currentIds ++ Array(nextId)
+        }
+    }
+    generatedIds
+  }
+
+  def predict(
+      sentences: Seq[Annotation],
+      imageAnnotations: Seq[AnnotationImage],
+      batchSize: Int,
+      minOutputLength: Int,
+      maxOutputLength: Int,
+      doSample: Boolean,
+      temperature: Double,
+      topK: Int,
+      topP: Double,
+      repetitionPenalty: Double,
+      noRepeatNgramSize: Int,
+      randomSeed: Option[Long] = None,
+      ignoreTokenIds: Array[Int] = Array(),
+      beamSize: Int,
+      maxInputLength: Int): Seq[Annotation] = {
+
+    val (encodedText, preprocessedImages) = encode(imageAnnotations, sentences, preprocessor)
+//    val (pixelValues, imageSizes, imgTokens) = preprocessedImages
+    val tagged = tag(
+      encodedText,
+      preprocessedImages,
+      minOutputLength,
+      maxOutputLength,
+      doSample,
+      temperature,
+      topK,
+      topP,
+      repetitionPenalty,
+      noRepeatNgramSize,
+      randomSeed,
+      ignoreTokenIds,
+      beamSize,
+      maxInputLength,
+      Array(eosTokenId))
+    val decoded = decode(tagged)
+
+    var sentBegin, nextSentEnd = 0
+    val annotations = decoded.map { content =>
+      nextSentEnd += content.length - 1
+      val annots = new Annotation(
+        annotatorType = DOCUMENT,
+        begin = sentBegin,
+        end = nextSentEnd,
+        result = content,
+        metadata = Map())
+      sentBegin += nextSentEnd + 1
+      annots
+    }
+    annotations
+  }
+
+  def getModelOutputs(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: org.intel.openvino.Tensor,
+      imageGridTHW: Array[Array[Int]],
+      inferRequestImageEmbed: InferRequest,
+      inferRequestImageEmbedMerger: InferRequest,
+      inferRequestRotaryEmbedding: InferRequest,
+      inferRequestTextEmbedding: InferRequest,
+      inferRequestMultimodalModelMerge: InferRequest,
+      inferRequestLanguageModel: InferRequest): Array[Array[Float]] = {
+
+    val imageEmbeddings = getImageEmbeddings(
+      encoderInputIds,
+      decoderInputIds,
+      pixelValues,
+      imageGridTHW,
+      inferRequestImageEmbed,
+      inferRequestImageEmbedMerger,
+      inferRequestRotaryEmbedding,
+      inferRequestTextEmbedding,
+      inferRequestMultimodalModelMerge)
+
+    val (inputIdsLong, inputPositionIDsLong): (Array[Long], Array[Long]) =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+        val posIdsLong = decoderInputIds.flatMap { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }
+        }
+        (inpIdsLong, posIdsLong)
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        val posIdsLong = decoderInputIds.map { tokenIds =>
+          tokenIds.zipWithIndex.map { case (_, i) =>
+            i.toLong
+          }.last
+        }
+        (inpIdsLong, posIdsLong)
+      }
+    val attentionMask: Array[Long] =
+      decoderInputIds.flatMap { tokenIds => tokenIds.map(_ => 1L) }
+
+    val batchSize: Int = decoderInputIds.length
+    val beamIdx: Array[Int] = new Array[Int](batchSize)
+    val shape: Array[Int] = Array(3, 1, inputIdsLong.length / batchSize)
+
+    val reshapedArray = Array(Array(inputPositionIDsLong))
+
+    // Expand the array by replicating the first dimension
+    val inputPositionIDsLongX3 =
+      reshapedArray.map(x => Array(x, x, x)).flatten.flatten.flatten
+
+    val decoderAttentionMask: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize, decoderInputIds.head.length), attentionMask)
+    val decoderPositionIDs: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputPositionIDsLongX3)
+    val beamIdxTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(Array(batchSize), beamIdx)
+
+    val imgEmbeddingTensor =
+      new org.intel.openvino.Tensor(imageEmbeddings.get_shape(), imageEmbeddings.data())
+
+    inferRequestLanguageModel.set_tensor("inputs_embeds", imgEmbeddingTensor)
+    inferRequestLanguageModel.set_tensor("attention_mask", decoderAttentionMask)
+    inferRequestLanguageModel.set_tensor("position_ids", decoderPositionIDs)
+    inferRequestLanguageModel.set_tensor("beam_idx", beamIdxTensor)
+
+    inferRequestLanguageModel.infer()
+
+    val result = inferRequestLanguageModel.get_tensor("logits")
+    val logitsRaw = result.data()
+
+    val sequenceLength = inputIdsLong.length / batchSize
+    val decoderOutputs = (0 until batchSize).map(i => {
+      logitsRaw
+        .slice(
+          i * sequenceLength * vocabSize + (sequenceLength - 1) * vocabSize,
+          i * sequenceLength * vocabSize + sequenceLength * vocabSize)
+    })
+    decoderOutputs.toArray
+  }
+
+  private def argmax(scores: Array[Float]): Int =
+    scores.zipWithIndex.maxBy { case (score, _) =>
+      score
+    }._2
+
+  private def greedyGenerationFinished(
+      decoderIds: Seq[Array[Int]],
+      eosTokenId: Int,
+      maxOutputLength: Int): Boolean = {
+    if (decoderIds.isEmpty) {
+      false
+    } else {
+      decoderIds.forall { ids =>
+        ids.length >= maxOutputLength || ids.last == eosTokenId
+      }
+    }
+  }
+
+  def preprocessImage(
+      imageAnnotations: Seq[AnnotationImage],
+      preprocessor: Preprocessor,
+      sizeFactor: Int = IMAGE_FACTOR,
+      minPixels: Int = MIN_PIXELS,
+      maxPixels: Int = MAX_PIXELS): (org.intel.openvino.Tensor, (Int, Int, Int)) = {
+
+    val rescaledImage = imageAnnotations
+      .map(annotations => {
+
+        val (width, height) = smartResize(
+          annotations.height,
+          annotations.width,
+          factor = sizeFactor,
+          minPixels = MIN_PIXELS,
+          maxPixels = MAX_PIXELS)
+
+        val bufferedImage = ImageIOUtils.byteToBufferedImage(
+          bytes = annotations.result,
+          w = annotations.width,
+          h = annotations.height,
+          nChannels = annotations.nChannels)
+
+        val resizedImage =
+          ImageResizeUtils.resizeBufferedImage(height = height, width = width, resample = 3)(
+            bufferedImage)
+
+        val resizedDimensions = smartResize(
+          resizedImage.getHeight,
+          resizedImage.getWidth,
+          factor = sizeFactor,
+          minPixels = minPixels,
+          maxPixels = maxPixels)
+
+        val (resizedWidth, resizedHeight) = resizedDimensions
+
+        val resizedImageArray = ImageResizeUtils.resizeBufferedImage(
+          width = resizedWidth,
+          height = resizedHeight,
+          resample = 3)(resizedImage)
+
+        val normalizedImage =
+          ImageResizeUtils.normalizeAndConvertBufferedImage(
+            img = resizedImageArray,
+            mean = preprocessor.image_mean,
+            std = preprocessor.image_std,
+            doNormalize = preprocessor.do_normalize,
+            doRescale = preprocessor.do_rescale,
+            rescaleFactor = preprocessor.rescale_factor)
+
+        normalizedImage
+      })
+      .toArray
+
+    val inferRequestPatchReshape =
+      openvinoWrapper.get.patchReshapeModel.getCompiledModel().create_infer_request()
+
+    val patchTensor = new org.intel.openvino.Tensor(
+      Array(
+        rescaledImage.length,
+        rescaledImage.head.length,
+        rescaledImage.head.head.length,
+        rescaledImage.head.head.head.length),
+      rescaledImage.flatten.flatten.flatten.map(_.toFloat))
+
+    // 2.0f if rescaledImage.length == 1 else 1.0f
+    val factor: Long = if (rescaledImage.length == 1) 2L else 1L
+    val repetitionFactorTensor = new org.intel.openvino.Tensor(Array[Int](), Array(factor))
+    inferRequestPatchReshape.set_tensor("patches", patchTensor)
+    inferRequestPatchReshape.set_tensor("repetition_factor", repetitionFactorTensor)
+
+    inferRequestPatchReshape.infer()
+
+    val pixel_values = inferRequestPatchReshape.get_output_tensor()
+    val grid_t = if (rescaledImage.length == 1) 1 else Math.ceil(rescaledImage.length / 2).toInt
+    val grid_h = (rescaledImage.head.head.length / 14).toInt
+    val grid_w = (rescaledImage.head.head.head.length / 14).toInt
+    (pixel_values, (grid_t, grid_h, grid_w))
+  }
+
+  def getImageEmbeddings(
+      encoderInputIds: Array[Array[Int]],
+      decoderInputIds: Array[Array[Int]],
+      pixelValues: org.intel.openvino.Tensor,
+      imageGridTHW: Array[Array[Int]],
+      inferRequestImageEmbed: InferRequest,
+      inferRequestImageEmbedMerger: InferRequest,
+      inferRequestRotaryEmbedding: InferRequest,
+      inferRequestTextEmbedding: InferRequest,
+      inferRequestMultimodalModelMerge: InferRequest): org.intel.openvino.Tensor = {
+    val inputIdsLong: Array[Long] =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        // First pass
+        val inpIdsLong = decoderInputIds.flatMap { tokenIds => tokenIds.map(_.toLong) }
+
+        inpIdsLong
+      } else {
+        // Subsequent passes
+        val inpIdsLong = decoderInputIds.map { tokenIds => tokenIds.last.toLong }
+        inpIdsLong
+      }
+    val batchSize: Int = decoderInputIds.length
+    val shape: Array[Int] = Array(batchSize, inputIdsLong.length / batchSize)
+    val inputIdsLongTensor: org.intel.openvino.Tensor =
+      new org.intel.openvino.Tensor(shape, inputIdsLong)
+
+    val imageEmbeddings: org.intel.openvino.Tensor =
+      if (encoderInputIds.head.length == decoderInputIds.head.length) {
+        val pixelValuesTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(pixelValues.get_shape(), pixelValues.data())
+//
+//        val pixelValuesTensor = pixelValues
+        inferRequestImageEmbed.set_input_tensor(pixelValuesTensor)
+
+        inferRequestImageEmbed.infer()
+
+        val hiddenStates = inferRequestImageEmbed.get_output_tensor()
+
+        val rotaryEmbeds = imageGridTHW.map(imageTHW => {
+          val imageTHWTensor: org.intel.openvino.Tensor =
+            new org.intel.openvino.Tensor(Array[Int](3), imageTHW.map(_.toLong))
+          inferRequestRotaryEmbedding.set_input_tensor(imageTHWTensor)
+          inferRequestRotaryEmbedding.infer()
+
+          val rotary = inferRequestRotaryEmbedding.get_output_tensor()
+          val rotaryData = rotary.data()
+          (rotaryData, rotary.get_shape())
+        })
+
+        // rotary_pos_emb = torch.cat([torch.from_numpy(rotary_embedding(x)[0]) for x in image_grid_thw], dim=0)
+
+        val rotaryPosEmb = rotaryEmbeds.flatMap(_._1)
+        // shape should be batch_size x seq_len, hidden_size
+        val rotaryShape =
+          Array(rotaryEmbeds.length * rotaryEmbeds.head._2(0), rotaryEmbeds.head._2(1))
+//        println("Rotary Shape: " + rotaryShape.mkString(","))
+//        println("Rotary Pos Emb: " + rotaryPosEmb.length)
+        val rotaryPosEmbTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(rotaryShape, rotaryPosEmb)
+
+        // attention_mask = torch.zeros((1, hidden_states.shape[0], hidden_states.shape[0]), dtype=torch.bool)
+
+        val attentionMask: Array[Float] =
+          Array.fill(hiddenStates.get_shape()(0) * hiddenStates.get_shape()(0))(1f)
+
+//        println("Hidden States Shape: " + hiddenStates.get_shape().mkString(","))
+//        println("attentionMask Shape: " + attentionMask.length)
+
+        val attentionMaskTensor: org.intel.openvino.Tensor =
+          new org.intel.openvino.Tensor(
+            Array(1, hiddenStates.get_shape()(0), hiddenStates.get_shape()(0)),
+            attentionMask)
+
+        inferRequestImageEmbedMerger.set_tensor("hidden_states", hiddenStates)
+        inferRequestImageEmbedMerger.set_tensor("rotary_pos_emb", rotaryPosEmbTensor)
+        inferRequestImageEmbedMerger.set_tensor("attention_mask", attentionMaskTensor)
+
+        inferRequestImageEmbedMerger.infer()
+
+        val imageEmbedMerged = inferRequestImageEmbedMerger.get_output_tensor()
+
+        inferRequestTextEmbedding.set_input_tensor(inputIdsLongTensor)
+        inferRequestTextEmbedding.infer()
+
+        val textEmbeddings = inferRequestTextEmbedding.get_output_tensor()
+
+        inferRequestMultimodalModelMerge.set_tensor("inputs_embeds", textEmbeddings)
+        inferRequestMultimodalModelMerge.set_tensor("vision_embeds", imageEmbedMerged)
+        inferRequestMultimodalModelMerge.set_tensor("input_ids", inputIdsLongTensor)
+
+        inferRequestMultimodalModelMerge.infer()
+
+        inferRequestMultimodalModelMerge.get_output_tensor()
+
+      } else {
+        inferRequestTextEmbedding.set_input_tensor(inputIdsLongTensor)
+        inferRequestTextEmbedding.infer()
+
+        inferRequestTextEmbedding.get_output_tensor()
+      }
+    imageEmbeddings
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/RoBertaClassification.scala b/src/main/scala/com/johnsnowlabs/ml/ai/RoBertaClassification.scala
index e19082535f2332..3743435a2f487f 100644
--- a/src/main/scala/com/johnsnowlabs/ml/ai/RoBertaClassification.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/RoBertaClassification.scala
@@ -478,6 +478,89 @@ private[johnsnowlabs] class RoBertaClassification(
     (startScores, endScores)
   }
 
+  override def tagSpanMultipleChoice(batch: Seq[Array[Int]]): Array[Float] = {
+    val logits = detectedEngine match {
+      case ONNX.name => computeLogitsMultipleChoiceWithOnnx(batch)
+      case Openvino.name => computeLogitsMultipleChoiceWithOv(batch)
+    }
+
+    calculateSoftmax(logits)
+  }
+
+  private def computeLogitsMultipleChoiceWithOnnx(batch: Seq[Array[Int]]): Array[Float] = {
+    val sequenceLength = batch.head.length
+    val inputIds = Array(batch.map(x => x.map(_.toLong)).toArray)
+    val attentionMask = Array(
+      batch.map(sentence => sentence.map(x => if (x == 0L) 0L else 1L)).toArray)
+
+    val (ortSession, ortEnv) = onnxWrapper.get.getSession(onnxSessionOptions)
+    val tokenTensors = OnnxTensor.createTensor(ortEnv, inputIds)
+    val maskTensors = OnnxTensor.createTensor(ortEnv, attentionMask)
+
+    val inputs =
+      Map("input_ids" -> tokenTensors, "attention_mask" -> maskTensors).asJava
+
+    try {
+      val output = ortSession.run(inputs)
+      try {
+
+        val logits = output
+          .get("logits")
+          .get()
+          .asInstanceOf[OnnxTensor]
+          .getFloatBuffer
+          .array()
+
+        tokenTensors.close()
+        maskTensors.close()
+
+        logits
+      } finally if (output != null) output.close()
+    } catch {
+      case e: Exception =>
+        // Log the exception as a warning
+        println("Exception in computeLogitsMultipleChoiceWithOnnx: ", e)
+        // Rethrow the exception to propagate it further
+        throw e
+    }
+  }
+
+  private def computeLogitsMultipleChoiceWithOv(batch: Seq[Array[Int]]): Array[Float] = {
+    val (numChoices, sequenceLength) = (batch.length, batch.head.length)
+    // batch_size, num_choices, sequence_length
+    val shape = Some(Array(1, numChoices, sequenceLength))
+    val (tokenTensors, maskTensors, _) =
+      PrepareEmbeddings.prepareOvLongBatchTensorsWithSegment(
+        batch,
+        sequenceLength,
+        numChoices,
+        sentencePadTokenId,
+        shape)
+
+    val compiledModel = openvinoWrapper.get.getCompiledModel()
+    val inferRequest = compiledModel.create_infer_request()
+    inferRequest.set_tensor("input_ids", tokenTensors)
+    inferRequest.set_tensor("attention_mask", maskTensors)
+
+    inferRequest.infer()
+
+    try {
+      try {
+        val logits = inferRequest
+          .get_output_tensor()
+          .data()
+
+        logits
+      }
+    } catch {
+      case e: Exception =>
+        // Log the exception as a warning
+        logger.warn("Exception in computeLogitsMultipleChoiceWithOv", e)
+        // Rethrow the exception to propagate it further
+        throw e
+    }
+  }
+
   private def computeLogitsWithTF(
       batch: Seq[Array[Int]],
       maxSentenceLength: Int): (Array[Float], Array[Float]) = {
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/XlmRoBertaClassification.scala b/src/main/scala/com/johnsnowlabs/ml/ai/XlmRoBertaClassification.scala
index 909211a38be8eb..c0e1698108150f 100644
--- a/src/main/scala/com/johnsnowlabs/ml/ai/XlmRoBertaClassification.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/XlmRoBertaClassification.scala
@@ -469,6 +469,90 @@ private[johnsnowlabs] class XlmRoBertaClassification(
     (startScores, endScores)
   }
 
+  override def tagSpanMultipleChoice(batch: Seq[Array[Int]]): Array[Float] = {
+    val logits = detectedEngine match {
+      case ONNX.name => computeLogitsMultipleChoiceWithOnnx(batch)
+      case Openvino.name => computeLogitsMultipleChoiceWithOv(batch)
+    }
+
+    calculateSoftmax(logits)
+  }
+
+  private def computeLogitsMultipleChoiceWithOnnx(batch: Seq[Array[Int]]): Array[Float] = {
+    val sequenceLength = batch.head.length
+    val inputIds = Array(batch.map(x => x.map(_.toLong)).toArray)
+    val attentionMask = Array(
+      batch.map(sentence => sentence.map(x => if (x == 0L) 0L else 1L)).toArray)
+    val tokenTypeIds = Array(batch.map(_ => Array.fill(sequenceLength)(0L)).toArray)
+
+    val (ortSession, ortEnv) = onnxWrapper.get.getSession(onnxSessionOptions)
+    val tokenTensors = OnnxTensor.createTensor(ortEnv, inputIds)
+    val maskTensors = OnnxTensor.createTensor(ortEnv, attentionMask)
+
+    val inputs =
+      Map("input_ids" -> tokenTensors, "attention_mask" -> maskTensors).asJava
+
+    try {
+      val output = ortSession.run(inputs)
+      try {
+
+        val logits = output
+          .get("logits")
+          .get()
+          .asInstanceOf[OnnxTensor]
+          .getFloatBuffer
+          .array()
+
+        tokenTensors.close()
+        maskTensors.close()
+
+        logits
+      } finally if (output != null) output.close()
+    } catch {
+      case e: Exception =>
+        // Log the exception as a warning
+        println("Exception in computeLogitsMultipleChoiceWithOnnx: ", e)
+        // Rethrow the exception to propagate it further
+        throw e
+    }
+  }
+
+  private def computeLogitsMultipleChoiceWithOv(batch: Seq[Array[Int]]): Array[Float] = {
+    val (numChoices, sequenceLength) = (batch.length, batch.head.length)
+    // batch_size, num_choices, sequence_length
+    val shape = Some(Array(1, numChoices, sequenceLength))
+    val (tokenTensors, maskTensors, _) =
+      PrepareEmbeddings.prepareOvLongBatchTensorsWithSegment(
+        batch,
+        sequenceLength,
+        numChoices,
+        sentencePadTokenId,
+        shape)
+
+    val compiledModel = openvinoWrapper.get.getCompiledModel()
+    val inferRequest = compiledModel.create_infer_request()
+    inferRequest.set_tensor("input_ids", tokenTensors)
+    inferRequest.set_tensor("attention_mask", maskTensors)
+
+    inferRequest.infer()
+
+    try {
+      try {
+        val logits = inferRequest
+          .get_output_tensor()
+          .data()
+
+        logits
+      }
+    } catch {
+      case e: Exception =>
+        // Log the exception as a warning
+        logger.warn("Exception in computeLogitsMultipleChoiceWithOv", e)
+        // Rethrow the exception to propagate it further
+        throw e
+    }
+  }
+
   private def computeLogitsWithTF(
       batch: Seq[Array[Int]],
       maxSentenceLength: Int): (Array[Float], Array[Float]) = {
diff --git a/src/main/scala/com/johnsnowlabs/ml/ai/util/Generation/Generate.scala b/src/main/scala/com/johnsnowlabs/ml/ai/util/Generation/Generate.scala
index 24d2ac1d3f6696..912a35409673be 100644
--- a/src/main/scala/com/johnsnowlabs/ml/ai/util/Generation/Generate.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/ai/util/Generation/Generate.scala
@@ -311,7 +311,7 @@ trait Generate {
           beamIndices(beamIdx(elem)) :+ beamIdx(elem)
         }
         currentLength = currentLength + 1
-        if (beamScorer.isDone || (expandedInputs.head.length >= maxLength)) {
+        if (beamScorer.isDone || (expandedInputs.head.length > maxLength)) {
           break
 
         }
diff --git a/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapper.scala b/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapper.scala
index ef7091c3b5cd12..6f68ead3a51ef0 100644
--- a/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapper.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapper.scala
@@ -77,6 +77,7 @@ object GGUFWrapper {
       new LlamaModel(modelParameters)
     }
 
+  /** Reads the GGUF model from file during loadSavedModel. */
   def read(sparkSession: SparkSession, modelPath: String): GGUFWrapper = {
     // TODO Better Sanity Check
     val modelFile = new File(modelPath)
@@ -92,6 +93,9 @@ object GGUFWrapper {
     new GGUFWrapper(modelFile.getName, modelFile.getParent)
   }
 
+  /** Reads the GGUF model from the folder passed by the Spark Reader during loading of a
+    * serialized model.
+    */
   def readModel(modelFolderPath: String, spark: SparkSession): GGUFWrapper = {
     def findGGUFModelInFolder(folderPath: String): String = {
       val folder = new File(folderPath)
diff --git a/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapperMultiModal.scala b/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapperMultiModal.scala
new file mode 100644
index 00000000000000..89eb8f517360f2
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapperMultiModal.scala
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.ml.gguf
+
+import com.johnsnowlabs.nlp.llama.{LlamaModel, ModelParameters}
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import org.apache.hadoop.fs.{FileSystem, Path}
+import org.apache.spark.SparkFiles
+import org.apache.spark.sql.SparkSession
+
+import java.io.File
+import java.nio.file.{Files, Paths}
+
+class GGUFWrapperMultiModal(var modelFileName: String, var mmprojFileName: String)
+    extends Serializable {
+
+  /** For Deserialization */
+  def this() = {
+    this(null, null)
+  }
+
+  // Important for serialization on none-kryo serializers
+  @transient private var llamaModel: LlamaModel = _
+
+  def getSession(modelParameters: ModelParameters): LlamaModel =
+    this.synchronized {
+      if (llamaModel == null) {
+        val modelFilePath = SparkFiles.get(modelFileName)
+        val mmprojFilePath = SparkFiles.get(mmprojFileName)
+        val filesExist =
+          Paths.get(modelFilePath).toFile.exists() && Paths.get(mmprojFilePath).toFile.exists()
+
+        if (filesExist) {
+          modelParameters.setModelFilePath(modelFilePath)
+          modelParameters.setMMProj(mmprojFilePath)
+          llamaModel = GGUFWrapperMultiModal.withSafeGGUFModelLoader(modelParameters)
+        } else
+          throw new IllegalStateException(
+            s"Model file $modelFileName does not exist in SparkFiles.")
+      }
+      // TODO: if the model is already loaded then the model parameters will not apply. perhaps output a logline here.
+      llamaModel
+    }
+
+  def saveToFile(folder: String): Unit = {
+    val modelFilePath = SparkFiles.get(modelFileName)
+    val mmprojFilePath = SparkFiles.get(mmprojFileName)
+    val modelOutputPath = Paths.get(folder, modelFileName)
+    val mmprojOutputPath = Paths.get(folder, mmprojFileName)
+    Files.copy(Paths.get(modelFilePath), modelOutputPath)
+    Files.copy(Paths.get(mmprojFilePath), mmprojOutputPath)
+  }
+
+  // Destructor to free the model when this object is garbage collected
+  override def finalize(): Unit = {
+    if (llamaModel != null) {
+      llamaModel.close()
+    }
+  }
+
+}
+
+/** Companion object */
+object GGUFWrapperMultiModal {
+  private def withSafeGGUFModelLoader(modelParameters: ModelParameters): LlamaModel =
+    this.synchronized {
+      new LlamaModel(modelParameters)
+    }
+
+  /** Reads the GGUF model from file during loadSavedModel. */
+  def read(
+      sparkSession: SparkSession,
+      modelPath: String,
+      mmprojPath: String): GGUFWrapperMultiModal = {
+    val modelFile = new File(modelPath)
+    val mmprojFile = new File(mmprojPath)
+
+    if (!modelFile.getName.endsWith(".gguf"))
+      throw new IllegalArgumentException(s"Model file $modelPath is not a GGUF model file")
+
+    if (!mmprojFile.getName.endsWith(".gguf"))
+      throw new IllegalArgumentException(s"mmproj file $mmprojPath is not a GGUF model file")
+
+    if (!mmprojFile.getName.contains("mmproj"))
+      throw new IllegalArgumentException(
+        s"mmproj file $mmprojPath is not a GGUF mmproj file (should contain 'mmproj' in its name)")
+
+    if (modelFile.exists() && mmprojFile.exists()) {
+      sparkSession.sparkContext.addFile(modelPath)
+      sparkSession.sparkContext.addFile(mmprojPath)
+    } else
+      throw new IllegalArgumentException(
+        s"Model file $modelPath or mmproj file $mmprojPath does not exist")
+
+    new GGUFWrapperMultiModal(modelFile.getName, mmprojFile.getName)
+  }
+
+  /** Reads the GGUF model from the folder passed by the Spark Reader during loading of a
+    * serialized model.
+    */
+  def readModel(modelFolderPath: String, spark: SparkSession): GGUFWrapperMultiModal = {
+    def findGGUFModelsInFolder(folderPath: String): (String, String) = {
+      val folder = new File(folderPath)
+      if (folder.exists && folder.isDirectory) {
+        val ggufFiles: Array[String] = folder.listFiles
+          .filter(_.isFile)
+          .filter(_.getName.endsWith(".gguf"))
+          .map(_.getAbsolutePath)
+
+        val (ggufMainPath, ggufMmprojPath) =
+          if (ggufFiles.length == 2 && ggufFiles.exists(_.contains("mmproj"))) {
+            val Array(firstModel, secondModel) = ggufFiles
+            if (firstModel.contains("mmproj")) (secondModel, firstModel)
+            else (firstModel, secondModel)
+          } else
+            throw new IllegalArgumentException(
+              s"Could not determine main GGUF model or mmproj GGUF model in $folderPath." +
+                s" The folder should contain exactly two files:" +
+                s" One main GGUF model and one mmproj GGUF model." +
+                s" The mmproj model should have 'mmproj' in its name.")
+
+        (ggufMainPath, ggufMmprojPath)
+      } else {
+        throw new IllegalArgumentException(s"Path $folderPath is not a directory")
+      }
+    }
+
+    val uri = new java.net.URI(modelFolderPath.replaceAllLiterally("\\", "/"))
+    // In case the path belongs to a different file system but doesn't have the scheme prepended (e.g. dbfs)
+    val fileSystem: FileSystem = FileSystem.get(uri, spark.sparkContext.hadoopConfiguration)
+    val actualFolderPath = fileSystem.resolvePath(new Path(modelFolderPath)).toString
+    val localFolder = ResourceHelper.copyToLocal(actualFolderPath)
+    val (ggufMainPath, ggufMmprojPath) = findGGUFModelsInFolder(localFolder)
+    read(spark, ggufMainPath, ggufMmprojPath)
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/ml/onnx/OnnxSerializeModel.scala b/src/main/scala/com/johnsnowlabs/ml/onnx/OnnxSerializeModel.scala
index e985f2b0bcac99..27250cd5fceff6 100644
--- a/src/main/scala/com/johnsnowlabs/ml/onnx/OnnxSerializeModel.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/onnx/OnnxSerializeModel.scala
@@ -98,7 +98,11 @@ trait ReadOnnxModel {
     val fsPath = new Path(path, localModelFile).toString
 
     val onnxDataFile: Option[String] = if (modelName.isDefined && dataFilePostfix.isDefined) {
-      Some(fsPath.replaceAll(modelName.get, s"${suffix}_${modelName.get}${dataFilePostfix.get}"))
+      var modelNameWithoutSuffix = modelName.get.replace(".onnx", "")
+      Some(
+        fsPath.replaceAll(
+          modelName.get,
+          s"${suffix}_${modelNameWithoutSuffix}${dataFilePostfix.get}"))
     } else None
 
     if (onnxDataFile.isDefined) {
@@ -117,7 +121,8 @@ trait ReadOnnxModel {
         zipped = zipped,
         useBundle = useBundle,
         modelName = if (modelName.isDefined) modelName.get else onnxFile,
-        onnxFileSuffix = Some(suffix))
+        onnxFileSuffix = Some(suffix),
+        dataFileSuffix = dataFilePostfix)
 
     onnxWrapper
 
diff --git a/src/main/scala/com/johnsnowlabs/ml/onnx/OnnxWrapper.scala b/src/main/scala/com/johnsnowlabs/ml/onnx/OnnxWrapper.scala
index 6e748faa72ee63..1b5131446a944e 100644
--- a/src/main/scala/com/johnsnowlabs/ml/onnx/OnnxWrapper.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/onnx/OnnxWrapper.scala
@@ -134,7 +134,9 @@ object OnnxWrapper {
 
     val onnxDataFileExist: Boolean = {
       if (onnxFileSuffix.isDefined && dataFileSuffix.isDefined) {
-        val onnxDataFilePath = s"${onnxFileSuffix.get}_$modelName${dataFileSuffix.get}"
+        var modelNameWithoutSuffix = modelName.replace(".onnx", "")
+        val onnxDataFilePath =
+          s"${onnxFileSuffix.get}_$modelNameWithoutSuffix${dataFileSuffix.get}"
         onnxDataFile = Paths.get(parentDir, onnxDataFilePath).toFile
         onnxDataFile.exists()
       } else false
diff --git a/src/main/scala/com/johnsnowlabs/ml/openvino/OpenvinoWrapper.scala b/src/main/scala/com/johnsnowlabs/ml/openvino/OpenvinoWrapper.scala
index 0c2f65d4315e4e..caf87f43058826 100644
--- a/src/main/scala/com/johnsnowlabs/ml/openvino/OpenvinoWrapper.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/openvino/OpenvinoWrapper.scala
@@ -218,4 +218,40 @@ object OpenvinoWrapper {
       decoderWithPast: OpenvinoWrapper)
   case class DecoderWrappers(decoder: OpenvinoWrapper)
   case class EncoderDecoderWithoutPastWrappers(encoder: OpenvinoWrapper, decoder: OpenvinoWrapper)
+  case class JanusWrappers(
+      languageModel: OpenvinoWrapper,
+      lmHeadModel: OpenvinoWrapper,
+      visionEmbeddingsModel: OpenvinoWrapper,
+      textEmbeddingsModel: OpenvinoWrapper,
+      mergeModel: OpenvinoWrapper,
+      genHeadModel: OpenvinoWrapper,
+      genEmbeddingsModel: OpenvinoWrapper,
+      genDecoderModel: OpenvinoWrapper)
+  case class MLLamaWrappers(
+      visionEmbeddingsModel: OpenvinoWrapper,
+      languageModel: OpenvinoWrapper,
+      reshapeModel: OpenvinoWrapper)
+//  LANGUAGE_MODEL_NAME = "openvino_language_model.xml"
+//IMAGE_EMBEDDING_NAME = "openvino_vision_embeddings_model.xml"
+//IMAGE_EMBEDDING_MERGER_NAME = "openvino_vision_embeddings_merger_model.xml"
+//TEXT_EMBEDDING_NAME = "openvino_text_embeddings_model.xml"
+  // ROTARY_EMBEDDING_NAME = "openvino_rotary_embeddings_model.xml"
+  // PATCH_RESHAPE_NAME = "openvino_patch_reshape_model.xml"
+  case class Qwen2VLWrappers(
+      languageModel: OpenvinoWrapper,
+      imageEmbedding: OpenvinoWrapper,
+      imageEmbeddingMerger: OpenvinoWrapper,
+      textEmbedding: OpenvinoWrapper,
+      rotaryEmbedding: OpenvinoWrapper,
+      patchReshapeModel: OpenvinoWrapper,
+      multimodalMergeModel: OpenvinoWrapper)
+  case class LLAVAWrappers(
+      languageModel: OpenvinoWrapper,
+      visionEmbeddingsModel: OpenvinoWrapper,
+      textEmbeddingsModel: OpenvinoWrapper,
+      mergeModel: OpenvinoWrapper)
+  case class Phi3VWrappers(
+      wte: OpenvinoWrapper,
+      reshape: OpenvinoWrapper,
+      languageModel: OpenvinoWrapper)
 }
diff --git a/src/main/scala/com/johnsnowlabs/ml/util/LoadExternalModel.scala b/src/main/scala/com/johnsnowlabs/ml/util/LoadExternalModel.scala
index cd0761f0f9daa3..6001db840767d3 100644
--- a/src/main/scala/com/johnsnowlabs/ml/util/LoadExternalModel.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/util/LoadExternalModel.scala
@@ -18,6 +18,7 @@ package com.johnsnowlabs.ml.util
 
 import com.johnsnowlabs.ml.tensorflow.sentencepiece.SentencePieceWrapper
 import com.johnsnowlabs.nlp.util.io.{ExternalResource, ReadAs, ResourceHelper}
+import org.glassfish.jersey.internal.inject.Custom
 
 import java.io.File
 import java.nio.file.Paths
@@ -103,22 +104,42 @@ object LoadExternalModel {
 
   }
 
-  def isOpenvinoModel(modelPath: String, isEncoderDecoder: Boolean): Boolean = {
-    if (isEncoderDecoder) {
-      val ovEncoderModelXml = new File(modelPath, s"${Openvino.encoderModel}.xml")
-      val ovEncoderModelBin = new File(modelPath, s"${Openvino.encoderModel}.bin")
-      val ovDecoderModelXml = new File(modelPath, s"${Openvino.decoderModel}.xml")
-      val ovDecoderModelBin = new File(modelPath, s"${Openvino.decoderModel}.bin")
-      val ovDecoderModelWithPastXml = new File(modelPath, s"${Openvino.decoderModelWithPast}.xml")
-      val ovDecoderModelWithPastBin = new File(modelPath, s"${Openvino.decoderModelWithPast}.bin")
-
-      ovEncoderModelXml.exists() && ovEncoderModelBin.exists() &&
-      ovDecoderModelXml.exists() && ovDecoderModelBin.exists() &&
-      ovDecoderModelWithPastXml.exists() && ovDecoderModelWithPastBin.exists()
+  def isOpenvinoModel(
+      modelPath: String,
+      isEncoderDecoder: Boolean,
+      custom: Option[List[String]] = None): Boolean = {
+
+    if (custom.isDefined) {
+      for (model <- custom.get) {
+        val ovModelXml = new File(modelPath, s"${model}.xml")
+        val ovModelBin = new File(modelPath, s"${model}.bin")
+        if (!ovModelXml.exists() || !ovModelBin.exists()) {
+          // If any of the custom models are missing, return false
+          println(s"Custom model $model is missing")
+          println(s"Model $model not found in $modelPath")
+          return false
+        }
+      }
+      true
     } else {
-      val modelXml = new File(modelPath, s"${Openvino.ovModel}.xml")
-      val modelBin = new File(modelPath, s"${Openvino.ovModel}.bin")
-      modelXml.exists() && modelBin.exists()
+      if (isEncoderDecoder) {
+        val ovEncoderModelXml = new File(modelPath, s"${Openvino.encoderModel}.xml")
+        val ovEncoderModelBin = new File(modelPath, s"${Openvino.encoderModel}.bin")
+        val ovDecoderModelXml = new File(modelPath, s"${Openvino.decoderModel}.xml")
+        val ovDecoderModelBin = new File(modelPath, s"${Openvino.decoderModel}.bin")
+        val ovDecoderModelWithPastXml =
+          new File(modelPath, s"${Openvino.decoderModelWithPast}.xml")
+        val ovDecoderModelWithPastBin =
+          new File(modelPath, s"${Openvino.decoderModelWithPast}.bin")
+
+        ovEncoderModelXml.exists() && ovEncoderModelBin.exists() &&
+        ovDecoderModelXml.exists() && ovDecoderModelBin.exists() &&
+        ovDecoderModelWithPastXml.exists() && ovDecoderModelWithPastBin.exists()
+      } else {
+        val modelXml = new File(modelPath, s"${Openvino.ovModel}.xml")
+        val modelBin = new File(modelPath, s"${Openvino.ovModel}.bin")
+        modelXml.exists() && modelBin.exists()
+      }
     }
   }
 
@@ -126,7 +147,8 @@ object LoadExternalModel {
       modelPath: String,
       isEncoderDecoder: Boolean = false,
       withPast: Boolean = false,
-      isDecoder: Boolean = false): String = {
+      isDecoder: Boolean = false,
+      custom: Option[List[String]] = None): String = {
 
     /** Check if the path is correct */
     val f = new File(modelPath)
@@ -146,7 +168,7 @@ object LoadExternalModel {
     val onnxModelExist = isOnnxModel(modelPath, isEncoderDecoder, withPast, isDecoder)
 
     /*Openvino required model files*/
-    val openvinoModelExist = isOpenvinoModel(modelPath, isEncoderDecoder)
+    val openvinoModelExist = isOpenvinoModel(modelPath, isEncoderDecoder, custom)
 
     if (tfSavedModelExist) {
       TensorFlow.name
@@ -176,10 +198,11 @@ object LoadExternalModel {
       path: String,
       isEncoderDecoder: Boolean = false,
       withPast: Boolean = false,
-      isDecoder: Boolean = false): (String, String) = {
+      isDecoder: Boolean = false,
+      custom: Option[List[String]] = None): (String, String) = {
     val localPath: String = ResourceHelper.copyToLocal(path)
 
-    (localPath, detectEngine(localPath, isEncoderDecoder, withPast, isDecoder))
+    (localPath, detectEngine(localPath, isEncoderDecoder, withPast, isDecoder, custom))
   }
 
   def loadTextAsset(assetPath: String, assetName: String): Array[String] = {
diff --git a/src/main/scala/com/johnsnowlabs/nlp/AnnotatorModel.scala b/src/main/scala/com/johnsnowlabs/nlp/AnnotatorModel.scala
index 1a350c750fc958..e1e75926a89ffa 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/AnnotatorModel.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/AnnotatorModel.scala
@@ -111,6 +111,23 @@ abstract class AnnotatorModel[M <: Model[M]] extends RawAnnotator[M] with CanBeL
             })
             .withColumn(getOutputCol, wrapColumnMetadata(col(getOutputCol)))
           dfWithMetadata
+
+        case withBatchAnnotateTextImage: HasBatchedAnnotateTextImage[M] =>
+          implicit val encoder: ExpressionEncoder[Row] =
+            SparkNlpConfig.getEncoder(inputDataset, newStructType)
+          val processedDataFrame = inputDataset.mapPartitions(partition => {
+            withBatchAnnotateTextImage.batchProcess(partition)
+          })
+
+          // TODO: Do we really need to repeat this in every case?
+          /** Put back column metadata from `inputDataset` after destructive mapPartitions */
+          val dfWithMetadata = inputDataset.schema.fields
+            .foldLeft(processedDataFrame)((dataFrame, field) => {
+              dataFrame
+                .withColumn(field.name, dataFrame.col(field.name).as(field.name, field.metadata))
+            })
+            .withColumn(getOutputCol, wrapColumnMetadata(col(getOutputCol)))
+          dfWithMetadata
       }
     }
 
diff --git a/src/main/scala/com/johnsnowlabs/nlp/HasBatchedAnnotateTextImage.scala b/src/main/scala/com/johnsnowlabs/nlp/HasBatchedAnnotateTextImage.scala
new file mode 100644
index 00000000000000..6881e74dd12510
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/HasBatchedAnnotateTextImage.scala
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp
+
+import org.apache.spark.ml.Model
+import org.apache.spark.ml.param.IntParam
+import org.apache.spark.sql.Row
+
+trait HasBatchedAnnotateTextImage[M <: Model[M]] {
+
+  this: RawAnnotator[M] =>
+
+  /** Size of every batch (Default depends on model).
+    *
+    * @group param
+    */
+  val batchSize = new IntParam(this, "batchSize", "Size of every batch.")
+
+  /** Size of every batch.
+    *
+    * @group setParam
+    */
+  def setBatchSize(size: Int): this.type = {
+    val recommended = size
+    require(recommended > 0, "batchSize must be greater than 0")
+    set(this.batchSize, recommended)
+  }
+
+  /** Size of every batch.
+    *
+    * @group getParam
+    */
+  def getBatchSize: Int = $(batchSize)
+
+  private def getCaptionImageAnnotations(row: Row): (Annotation, AnnotationImage) = {
+    require(
+      getInputCols.length == 2,
+      "Only two input columns are allowed for this annotator:" +
+        " One for text caption and one for image.")
+
+    // Assuming we only have one annotation per field
+    val inputAnnotations: Array[Row] =
+      getInputCols.map(row.fieldIndex).map(i => row.getAs[Seq[Row]](i).head)
+
+    val (documentStruct: Row, imageStruct: Row) =
+      if (inputAnnotations.head.getString(0) == AnnotatorType.DOCUMENT) {
+        (inputAnnotations.head, inputAnnotations.last)
+      } else {
+        (inputAnnotations.last, inputAnnotations.head)
+      }
+
+    val document = Annotation(documentStruct)
+    val image = AnnotationImage(imageStruct)
+    (document, image)
+  }
+
+  def batchProcess(rows: Iterator[_]): Iterator[Row] = {
+    rows
+      .grouped(getBatchSize)
+      .flatMap { case batchedRows: Seq[Row] =>
+        val inputAnnotations: Seq[(Annotation, AnnotationImage)] =
+          batchedRows.map(getCaptionImageAnnotations)
+        val outputAnnotations = batchAnnotate(inputAnnotations)
+
+        batchedRows.zip(outputAnnotations).map { case (row, annotations) =>
+          row.toSeq ++ Array(annotations.map(a => Row(a.productIterator.toSeq: _*)))
+        }
+      }
+      .map(Row.fromSeq)
+  }
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    */
+  def batchAnnotate(batchedAnnotations: Seq[(Annotation, AnnotationImage)]): Seq[Seq[Annotation]]
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/ImageAssembler.scala b/src/main/scala/com/johnsnowlabs/nlp/ImageAssembler.scala
index 73b08bae40d695..ae620dc78cbaa5 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/ImageAssembler.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/ImageAssembler.scala
@@ -22,9 +22,9 @@ import org.apache.spark.ml.Transformer
 import org.apache.spark.ml.param.{Param, ParamMap}
 import org.apache.spark.ml.util.{DefaultParamsReadable, DefaultParamsWritable, Identifiable}
 import org.apache.spark.sql.expressions.UserDefinedFunction
-import org.apache.spark.sql.functions.udf
+import org.apache.spark.sql.functions.{col, regexp_replace, udf}
 import org.apache.spark.sql.types._
-import org.apache.spark.sql.{DataFrame, Dataset}
+import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}
 
 /** Prepares images read by Spark into a format that is processable by Spark NLP. This component
   * is needed to process images.
@@ -213,4 +213,49 @@ private[nlp] case class ImageFields(
 /** This is the companion object of [[ImageAssembler]]. Please refer to that class for the
   * documentation.
   */
-object ImageAssembler extends DefaultParamsReadable[ImageAssembler]
+object ImageAssembler extends DefaultParamsReadable[ImageAssembler] {
+
+  /** Helper function that loads images from a path and returns them as raw bytes, instead of the
+    * default OpenCV compatible format.
+    *
+    * Supported image types are JPEG, PNG, GIF, BMP (limited to images supported by stb_image.h).
+    *
+    * Multimodal inference with llama.cpp requires raw bytes as input.
+    *
+    * @param spark
+    *   The SparkSession
+    * @param path
+    *   The path to the images. Supported image types are JPEG, PNG, GIF, BMP.
+    * @return
+    *   A dataframe with the images as raw bytes, as well as their metadata.
+    */
+  def loadImagesAsBytes(spark: SparkSession, path: String): DataFrame = {
+    // Replace the path separator in the `origin` field and `path` column, so that they match
+    def replacePath(columnName: String) = regexp_replace(col(columnName), ":///", ":/")
+
+    val data: DataFrame =
+      spark.read
+        .format("image")
+        .option("dropInvalid", value = true)
+        .load(path)
+        .withColumn("image", col("image").withField("origin", replacePath("image.origin")))
+
+    val imageBytes: DataFrame =
+      spark.read
+        .format("binaryFile")
+        .option("pathGlobFilter", "*.{jpeg,jpg,png,gif,bmp,JPEG,JPG,PNG,GIF,BMP}")
+        .option("dropInvalid", value = true)
+        .load(path)
+        .withColumn("path", replacePath("path"))
+
+    // Join on path
+    val dfJoined =
+      data.join(imageBytes, data("image.origin") === imageBytes("path"), "inner")
+
+    // Replace image column data with image bytes
+    val dfImageReplaced =
+      dfJoined.withColumn("image", dfJoined("image").withField("data", dfJoined("content")))
+
+    dfImageReplaced
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotator.scala b/src/main/scala/com/johnsnowlabs/nlp/annotator.scala
index efbd3a288896c1..e88f5feaa9fb01 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotator.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotator.scala
@@ -833,4 +833,8 @@ package object annotator {
       extends ReadablePretrainedAutoGGUFEmbeddings
       with ReadAutoGGUFEmbeddings
 
+  type AutoGGUFVisionModel = com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFVisionModel
+  object AutoGGUFVisionModel
+      extends ReadablePretrainedAutoGGUFVisionModel
+      with ReadAutoGGUFVisionModel
 }
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/AlbertForMultipleChoice.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/AlbertForMultipleChoice.scala
new file mode 100644
index 00000000000000..5cfb4f4cb0eb2b
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/AlbertForMultipleChoice.scala
@@ -0,0 +1,356 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.classifier.dl
+
+import com.johnsnowlabs.ml.ai.AlbertClassification
+import com.johnsnowlabs.ml.onnx.{OnnxWrapper, ReadOnnxModel, WriteOnnxModel}
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.tensorflow.sentencepiece.{
+  ReadSentencePieceModel,
+  SentencePieceWrapper,
+  WriteSentencePieceModel
+}
+import com.johnsnowlabs.ml.tensorflow.{TensorflowWrapper, WriteTensorflowModel}
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadSentencePieceAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp._
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.{IntParam, Param}
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** AlbertForMultipleChoice can load ALBERT Models with a multiple choice classification head on
+  * top (a linear layer on top of the pooled output and a softmax) e.g. for RocStories/SWAG tasks.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val spanClassifier = AlbertForMultipleChoice.pretrained()
+  *   .setInputCols(Array("document_question", "document_context"))
+  *   .setOutputCol("answer")
+  * }}}
+  * The default model is `"albert_base_uncased_multiple_choice"`, if no name is provided.
+  *
+  * For available pretrained models please see the
+  * [[https://sparknlp.org/models?task=Multiple+Choice Models Hub]].
+  *
+  * Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. To
+  * see which models are compatible and how to import them see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/discussions/5669]] and to see more extended
+  * examples, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/AlbertForMultipleChoiceTestSpec.scala AlbertForMultipleChoiceTestSpec]].
+  *
+  * ==Example==
+  * {{{
+  * import spark.implicits._
+  * import com.johnsnowlabs.nlp.base._
+  * import com.johnsnowlabs.nlp.annotator._
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val document = new MultiDocumentAssembler()
+  *   .setInputCols("question", "context")
+  *   .setOutputCols("document_question", "document_context")
+  *
+  * val questionAnswering = AlbertForMultipleChoice.pretrained()
+  *   .setInputCols(Array("document_question", "document_context"))
+  *   .setOutputCol("answer")
+  *   .setCaseSensitive(false)
+  *
+  * val pipeline = new Pipeline().setStages(Array(
+  *   document,
+  *   questionAnswering
+  * ))
+  *
+  * val data = Seq("The Eiffel Tower is located in which country?", "Germany, France, Italy").toDF("question", "context")
+  * val result = pipeline.fit(data).transform(data)
+  *
+  * result.select("answer.result").show(false)
+  * +---------------------+
+  * |result               |
+  * +---------------------+
+  * |[France]              |
+  * ++--------------------+
+  * }}}
+  *
+  * @see
+  *   [[AlbertForQuestionAnswering]] for Question Answering tasks
+  * @see
+  *   [[https://sparknlp.org/docs/en/annotators Annotators Main Page]] for a list of transformer
+  *   based classifiers
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+
+class AlbertForMultipleChoice(override val uid: String)
+    extends AnnotatorModel[AlbertForMultipleChoice]
+    with HasBatchedAnnotate[AlbertForMultipleChoice]
+    with WriteTensorflowModel
+    with WriteOnnxModel
+    with WriteOpenvinoModel
+    with WriteSentencePieceModel
+    with HasCaseSensitiveProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("AlbertForMultipleChoice"))
+
+  override val inputAnnotatorTypes: Array[AnnotatorType] =
+    Array(AnnotatorType.DOCUMENT, AnnotatorType.DOCUMENT)
+  override val outputAnnotatorType: AnnotatorType = AnnotatorType.CHUNK
+
+  /** Max sentence length to process (Default: `128`)
+    *
+    * @group param
+    */
+  val maxSentenceLength =
+    new IntParam(this, "maxSentenceLength", "Max sentence length to process")
+
+  /** @group setParam */
+  def setMaxSentenceLength(value: Int): this.type = {
+    require(
+      value <= 512,
+      "ALBERT models do not support sequences longer than 512 because of trainable positional embeddings.")
+    require(value >= 1, "The maxSentenceLength must be at least 1")
+    set(maxSentenceLength, value)
+    this
+  }
+
+  /** @group getParam */
+  def getMaxSentenceLength: Int = $(maxSentenceLength)
+
+  val choicesDelimiter =
+    new Param[String](this, "choicesDelimiter", "Delimiter character use to split the choices")
+
+  def setChoicesDelimiter(value: String): this.type = set(choicesDelimiter, value)
+
+  private var _model: Option[Broadcast[AlbertClassification]] = None
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      tensorflowWrapper: Option[TensorflowWrapper],
+      onnxWrapper: Option[OnnxWrapper],
+      openvinoWrapper: Option[OpenvinoWrapper],
+      spp: SentencePieceWrapper): AlbertForMultipleChoice = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new AlbertClassification(
+            tensorflowWrapper,
+            onnxWrapper,
+            openvinoWrapper,
+            spp,
+            tags = Map.empty[String, Int])))
+    }
+
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: AlbertClassification = _model.get.value
+
+  /** Whether to lowercase tokens or not (Default: `false`).
+    *
+    * @group setParam
+    */
+  override def setCaseSensitive(value: Boolean): this.type = set(this.caseSensitive, value)
+
+  setDefault(
+    batchSize -> 8,
+    maxSentenceLength -> 128,
+    caseSensitive -> false,
+    choicesDelimiter -> ",")
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    *
+    * IMPORTANT: !MUST! return sequences of equal lengths !! IMPORTANT: !MUST! return sentences
+    * that belong to the same original row !! (challenging)
+    */
+  override def batchAnnotate(batchedAnnotations: Seq[Array[Annotation]]): Seq[Seq[Annotation]] = {
+    batchedAnnotations.map(annotations => {
+      if (annotations.nonEmpty) {
+        getModelIfNotSet.predictSpanMultipleChoice(
+          annotations,
+          $(choicesDelimiter),
+          $(maxSentenceLength),
+          $(caseSensitive))
+      } else {
+        Seq.empty[Annotation]
+      }
+    })
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    val suffix = "_albert_multiple_choice_classification"
+
+    getEngine match {
+      case ONNX.name =>
+        writeOnnxModel(
+          path,
+          spark,
+          getModelIfNotSet.onnxWrapper.get,
+          suffix,
+          AlbertForMultipleChoice.onnxFile)
+
+      case Openvino.name =>
+        writeOpenvinoModel(
+          path,
+          spark,
+          getModelIfNotSet.openvinoWrapper.get,
+          "openvino_model.xml",
+          AlbertForMultipleChoice.openvinoFile)
+
+    }
+
+    writeSentencePieceModel(
+      path,
+      spark,
+      getModelIfNotSet.spp,
+      "_albert",
+      AlbertForSequenceClassification.sppFile)
+
+  }
+
+}
+
+trait ReadablePretrainedAlbertForMultipleChoiceModel
+    extends ParamsAndFeaturesReadable[AlbertForMultipleChoice]
+    with HasPretrained[AlbertForMultipleChoice] {
+  override val defaultModelName: Some[String] = Some("albert_base_uncased_multiple_choice")
+
+  /** Java compliant-overrides */
+  override def pretrained(): AlbertForMultipleChoice = super.pretrained()
+
+  override def pretrained(name: String): AlbertForMultipleChoice = super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): AlbertForMultipleChoice =
+    super.pretrained(name, lang)
+
+  override def pretrained(
+      name: String,
+      lang: String,
+      remoteLoc: String): AlbertForMultipleChoice =
+    super.pretrained(name, lang, remoteLoc)
+}
+
+trait ReadAlbertForMultipleChoiceModel
+    extends ReadOnnxModel
+    with ReadOpenvinoModel
+    with ReadSentencePieceModel {
+  this: ParamsAndFeaturesReadable[AlbertForMultipleChoice] =>
+
+  override val onnxFile: String = "albert_mc_classification_onnx"
+  override val openvinoFile: String = "albert_mc_classification_openvino"
+  override val sppFile: String = "albert_spp"
+
+  def readModel(instance: AlbertForMultipleChoice, path: String, spark: SparkSession): Unit = {
+
+    val spp = readSentencePieceModel(path, spark, "_albert_spp", sppFile)
+
+    instance.getEngine match {
+      case ONNX.name =>
+        val onnxWrapper =
+          readOnnxModel(path, spark, "albert_mc_classification_onnx")
+        instance.setModelIfNotSet(spark, None, Some(onnxWrapper), None, spp)
+
+      case Openvino.name =>
+        val openvinoWrapper = readOpenvinoModel(path, spark, "albert_mc_classification_ov")
+        instance.setModelIfNotSet(spark, None, None, Some(openvinoWrapper), spp)
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(modelPath: String, spark: SparkSession): AlbertForMultipleChoice = {
+    val (localModelPath, detectedEngine) = modelSanityCheck(modelPath)
+
+    val spModel = loadSentencePieceAsset(localModelPath, "spiece.model")
+
+    /*Universal parameters for all engines*/
+    val annotatorModel = new AlbertForMultipleChoice()
+
+    annotatorModel.set(annotatorModel.engine, detectedEngine)
+
+    detectedEngine match {
+      case ONNX.name =>
+        val onnxWrapper = OnnxWrapper.read(
+          spark,
+          localModelPath,
+          zipped = false,
+          useBundle = true,
+          onnxFileSuffix = None)
+        annotatorModel
+          .setModelIfNotSet(spark, None, Some(onnxWrapper), None, spModel)
+
+      case Openvino.name =>
+        val ovWrapper: OpenvinoWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine)
+        annotatorModel
+          .setModelIfNotSet(spark, None, None, Some(ovWrapper), spModel)
+
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+}
+
+/** This is the companion object of [[AlbertForMultipleChoice]]. Please refer to that class for
+  * the documentation.
+  */
+object AlbertForMultipleChoice
+    extends ReadablePretrainedAlbertForMultipleChoiceModel
+    with ReadAlbertForMultipleChoiceModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/DistilBertForMultipleChoice.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/DistilBertForMultipleChoice.scala
new file mode 100644
index 00000000000000..5c4210d211a7ca
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/DistilBertForMultipleChoice.scala
@@ -0,0 +1,264 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.classifier.dl
+
+import com.johnsnowlabs.ml.ai.DistilBertClassification
+import com.johnsnowlabs.ml.onnx.{OnnxWrapper, ReadOnnxModel, WriteOnnxModel}
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.tensorflow.TensorflowWrapper
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.nlp.serialization.MapFeature
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.{IntParam, Param}
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+class DistilBertForMultipleChoice(override val uid: String)
+    extends AnnotatorModel[DistilBertForMultipleChoice]
+    with HasBatchedAnnotate[DistilBertForMultipleChoice]
+    with WriteOnnxModel
+    with WriteOpenvinoModel
+    with HasCaseSensitiveProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("DistilBertForMultipleChoice"))
+
+  override val inputAnnotatorTypes: Array[AnnotatorType] =
+    Array(AnnotatorType.DOCUMENT, AnnotatorType.DOCUMENT)
+  override val outputAnnotatorType: AnnotatorType = AnnotatorType.CHUNK
+
+  /** Vocabulary used to encode the words to ids with WordPieceEncoder
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** @group setParam */
+  def sentenceStartTokenId: Int = {
+    $$(vocabulary)("[CLS]")
+  }
+
+  /** @group setParam */
+  def sentenceEndTokenId: Int = {
+    $$(vocabulary)("[SEP]")
+  }
+
+  /** Max sentence length to process (Default: `512`)
+    *
+    * @group param
+    */
+  val maxSentenceLength =
+    new IntParam(this, "maxSentenceLength", "Max sentence length to process")
+
+  /** @group setParam */
+  def setMaxSentenceLength(value: Int): this.type = {
+    require(
+      value <= 512,
+      "DistilBERT models do not support sequences longer than 512 because of trainable positional embeddings.")
+    require(value >= 1, "The maxSentenceLength must be at least 1")
+    set(maxSentenceLength, value)
+    this
+  }
+
+  val choicesDelimiter =
+    new Param[String](this, "choicesDelimiter", "Delimiter character use to split the choices")
+
+  def setChoicesDelimiter(value: String): this.type = set(choicesDelimiter, value)
+
+  private var _model: Option[Broadcast[DistilBertClassification]] = None
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      tensorflowWrapper: Option[TensorflowWrapper],
+      onnxWrapper: Option[OnnxWrapper],
+      openvinoWrapper: Option[OpenvinoWrapper]): DistilBertForMultipleChoice = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new DistilBertClassification(
+            tensorflowWrapper,
+            onnxWrapper,
+            openvinoWrapper,
+            sentenceStartTokenId,
+            sentenceEndTokenId,
+            tags = Map.empty[String, Int],
+            vocabulary = $$(vocabulary))))
+    }
+
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: DistilBertClassification = _model.get.value
+
+  /** Whether to lowercase tokens or not (Default: `true`).
+    *
+    * @group setParam
+    */
+  override def setCaseSensitive(value: Boolean): this.type = set(this.caseSensitive, value)
+
+  setDefault(
+    batchSize -> 4,
+    maxSentenceLength -> 512,
+    caseSensitive -> false,
+    choicesDelimiter -> ",")
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    *
+    * IMPORTANT: !MUST! return sequences of equal lengths !! IMPORTANT: !MUST! return sentences
+    * that belong to the same original row !! (challenging)
+    */
+  override def batchAnnotate(batchedAnnotations: Seq[Array[Annotation]]): Seq[Seq[Annotation]] = {
+    batchedAnnotations.map(annotations => {
+      if (annotations.nonEmpty) {
+        getModelIfNotSet.predictSpanMultipleChoice(
+          annotations,
+          $(choicesDelimiter),
+          $(maxSentenceLength),
+          $(caseSensitive))
+      } else {
+        Seq.empty[Annotation]
+      }
+    })
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+
+    getEngine match {
+      case ONNX.name =>
+        writeOnnxModel(
+          path,
+          spark,
+          getModelIfNotSet.onnxWrapper.get,
+          "_distilbert_multiple_choice_classification",
+          DistilBertForMultipleChoice.onnxFile)
+      case Openvino.name =>
+        writeOpenvinoModel(
+          path,
+          spark,
+          getModelIfNotSet.openvinoWrapper.get,
+          "openvino_model.xml",
+          DistilBertForMultipleChoice.openvinoFile)
+    }
+  }
+
+}
+
+trait ReadablePretrainedDistilBertForMultipleChoiceModel
+    extends ParamsAndFeaturesReadable[DistilBertForMultipleChoice]
+    with HasPretrained[DistilBertForMultipleChoice] {
+  override val defaultModelName: Some[String] = Some("distilbert_base_uncased_multiple_choice")
+
+  /** Java compliant-overrides */
+  override def pretrained(): DistilBertForMultipleChoice = super.pretrained()
+
+  override def pretrained(name: String): DistilBertForMultipleChoice = super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): DistilBertForMultipleChoice =
+    super.pretrained(name, lang)
+
+  override def pretrained(
+      name: String,
+      lang: String,
+      remoteLoc: String): DistilBertForMultipleChoice =
+    super.pretrained(name, lang, remoteLoc)
+}
+
+trait ReadDistilBertForMultipleChoiceModel extends ReadOnnxModel with ReadOpenvinoModel {
+  this: ParamsAndFeaturesReadable[DistilBertForMultipleChoice] =>
+
+  override val onnxFile: String = "distilbert_mc_classification_onnx"
+  override val openvinoFile: String = "distilbert_mc_classification_openvino"
+
+  def readModel(
+      instance: DistilBertForMultipleChoice,
+      path: String,
+      spark: SparkSession): Unit = {
+    instance.getEngine match {
+      case ONNX.name =>
+        val onnxWrapper =
+          readOnnxModel(path, spark, "distilbert_mc_classification_onnx")
+        instance.setModelIfNotSet(spark, None, Some(onnxWrapper), None)
+      case Openvino.name =>
+        val openvinoWrapper = readOpenvinoModel(path, spark, "distilbert_mc_classification_ov")
+        instance.setModelIfNotSet(spark, None, None, Some(openvinoWrapper))
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(modelPath: String, spark: SparkSession): DistilBertForMultipleChoice = {
+    val (localModelPath, detectedEngine) = modelSanityCheck(modelPath)
+    val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+    val annotatorModel = new DistilBertForMultipleChoice().setVocabulary(vocabs)
+    annotatorModel.set(annotatorModel.engine, detectedEngine)
+
+    detectedEngine match {
+      case ONNX.name =>
+        val onnxWrapper =
+          OnnxWrapper.read(spark, localModelPath, zipped = false, useBundle = true)
+        annotatorModel
+          .setModelIfNotSet(spark, None, Some(onnxWrapper), None)
+      case Openvino.name =>
+        val ovWrapper: OpenvinoWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine)
+        annotatorModel
+          .setModelIfNotSet(spark, None, None, Some(ovWrapper))
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+
+}
+
+/** This is the companion object of [[DistilBertForMultipleChoice]]. Please refer to that class
+  * for the documentation.
+  */
+object DistilBertForMultipleChoice
+    extends ReadablePretrainedDistilBertForMultipleChoiceModel
+    with ReadDistilBertForMultipleChoiceModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/RoBertaForMultipleChoice.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/RoBertaForMultipleChoice.scala
new file mode 100644
index 00000000000000..92f129fa15beaf
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/RoBertaForMultipleChoice.scala
@@ -0,0 +1,308 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.classifier.dl
+
+import com.johnsnowlabs.ml.ai.RoBertaClassification
+import com.johnsnowlabs.ml.onnx.{OnnxWrapper, ReadOnnxModel, WriteOnnxModel}
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.tensorflow.TensorflowWrapper
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp.serialization.MapFeature
+import com.johnsnowlabs.nlp._
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.{IntParam, Param}
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+class RoBertaForMultipleChoice(override val uid: String)
+    extends AnnotatorModel[RoBertaForMultipleChoice]
+    with HasBatchedAnnotate[RoBertaForMultipleChoice]
+    with WriteOnnxModel
+    with WriteOpenvinoModel
+    with HasCaseSensitiveProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("RoBertaForMultipleChoice"))
+
+  /** Input Annotator Types: DOCUMENT, DOCUMENT
+    *
+    * @group anno
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] =
+    Array(AnnotatorType.DOCUMENT, AnnotatorType.DOCUMENT)
+
+  /** Output Annotator Types: CHUNK
+    *
+    * @group anno
+    */
+  override val outputAnnotatorType: AnnotatorType = AnnotatorType.CHUNK
+
+  def sentenceStartTokenId: Int = {
+    $$(vocabulary)("")
+  }
+
+  def sentenceEndTokenId: Int = {
+    $$(vocabulary)("")
+  }
+
+  def padTokenId: Int = {
+    $$(vocabulary)("")
+  }
+
+  /** Vocabulary used to encode the words to ids with WordPieceEncoder
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** Holding merges.txt coming from RoBERTa model
+    *
+    * @group param
+    */
+  val merges: MapFeature[(String, String), Int] = new MapFeature(this, "merges").setProtected()
+
+  /** @group setParam */
+  def setMerges(value: Map[(String, String), Int]): this.type = set(merges, value)
+
+  /** Max sentence length to process (Default: `128`)
+    *
+    * @group param
+    */
+  val maxSentenceLength =
+    new IntParam(this, "maxSentenceLength", "Max sentence length to process")
+
+  /** @group setParam */
+  def setMaxSentenceLength(value: Int): this.type = {
+    require(
+      value <= 512,
+      "RoBERTa models do not support sequences longer than 512 because of trainable positional embeddings.")
+    require(value >= 1, "The maxSentenceLength must be at least 1")
+    set(maxSentenceLength, value)
+    this
+  }
+
+  private var _model: Option[Broadcast[RoBertaClassification]] = None
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      tensorflowWrapper: Option[TensorflowWrapper],
+      onnxWrapper: Option[OnnxWrapper],
+      openvinoWrapper: Option[OpenvinoWrapper]): RoBertaForMultipleChoice = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new RoBertaClassification(
+            tensorflowWrapper,
+            onnxWrapper,
+            openvinoWrapper,
+            sentenceStartTokenId,
+            sentenceEndTokenId,
+            padTokenId,
+            tags = Map.empty[String, Int],
+            merges = $$(merges),
+            vocabulary = $$(vocabulary))))
+    }
+
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: RoBertaClassification = _model.get.value
+
+  /** Whether to lowercase tokens or not (Default: `true`).
+    *
+    * @group setParam
+    */
+  override def setCaseSensitive(value: Boolean): this.type = set(this.caseSensitive, value)
+
+  val choicesDelimiter =
+    new Param[String](this, "choicesDelimiter", "Delimiter character use to split the choices")
+
+  def setChoicesDelimiter(value: String): this.type = set(choicesDelimiter, value)
+
+  setDefault(
+    batchSize -> 8,
+    maxSentenceLength -> 128,
+    caseSensitive -> true,
+    choicesDelimiter -> ",")
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    *
+    * IMPORTANT: !MUST! return sequences of equal lengths !! IMPORTANT: !MUST! return sentences
+    * that belong to the same original row !! (challenging)
+    */
+  override def batchAnnotate(batchedAnnotations: Seq[Array[Annotation]]): Seq[Seq[Annotation]] = {
+    batchedAnnotations.map(annotations => {
+      if (annotations.nonEmpty) {
+        getModelIfNotSet.predictSpanMultipleChoice(
+          annotations,
+          $(choicesDelimiter),
+          $(maxSentenceLength),
+          $(caseSensitive))
+      } else {
+        Seq.empty[Annotation]
+      }
+    })
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    val suffix = "_roberta_classification"
+
+    getEngine match {
+      case ONNX.name =>
+        writeOnnxModel(
+          path,
+          spark,
+          getModelIfNotSet.onnxWrapper.get,
+          suffix,
+          RoBertaForMultipleChoice.onnxFile)
+
+      case Openvino.name =>
+        writeOpenvinoModel(
+          path,
+          spark,
+          getModelIfNotSet.openvinoWrapper.get,
+          "openvino_model.xml",
+          RoBertaForMultipleChoice.openvinoFile)
+    }
+
+  }
+
+}
+
+trait ReadablePretrainedRoBertaForMCModel
+    extends ParamsAndFeaturesReadable[RoBertaForMultipleChoice]
+    with HasPretrained[RoBertaForMultipleChoice] {
+  override val defaultModelName: Some[String] = Some("roberta_base_qa_squad2")
+
+  /** Java compliant-overrides */
+  override def pretrained(): RoBertaForMultipleChoice = super.pretrained()
+
+  override def pretrained(name: String): RoBertaForMultipleChoice = super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): RoBertaForMultipleChoice =
+    super.pretrained(name, lang)
+
+  override def pretrained(
+      name: String,
+      lang: String,
+      remoteLoc: String): RoBertaForMultipleChoice =
+    super.pretrained(name, lang, remoteLoc)
+}
+
+trait ReadRoBertaForMultipleChoiceDLModel extends ReadOnnxModel with ReadOpenvinoModel {
+  this: ParamsAndFeaturesReadable[RoBertaForMultipleChoice] =>
+
+  override val onnxFile: String = "roberta_mc_classification_onnx"
+  override val openvinoFile: String = "roberta_mc_classification_openvino"
+
+  def readModel(instance: RoBertaForMultipleChoice, path: String, spark: SparkSession): Unit = {
+
+    instance.getEngine match {
+      case ONNX.name =>
+        val onnxWrapper =
+          readOnnxModel(
+            path,
+            spark,
+            "roberta_mc_classification_onnx",
+            zipped = true,
+            useBundle = false,
+            None)
+        instance.setModelIfNotSet(spark, None, Some(onnxWrapper), None)
+
+      case Openvino.name =>
+        val openvinoWrapper = readOpenvinoModel(path, spark, "roberta_mc_classification_openvino")
+        instance.setModelIfNotSet(spark, None, None, Some(openvinoWrapper))
+
+    }
+
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(modelPath: String, spark: SparkSession): RoBertaForMultipleChoice = {
+
+    val (localModelPath, detectedEngine) = modelSanityCheck(modelPath)
+
+    val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+
+    val bytePairs = loadTextAsset(localModelPath, "merges.txt")
+      .map(_.split(" "))
+      .filter(w => w.length == 2)
+      .map { case Array(c1, c2) => (c1, c2) }
+      .zipWithIndex
+      .toMap
+
+    /*Universal parameters for all engines*/
+    val annotatorModel = new RoBertaForMultipleChoice()
+      .setVocabulary(vocabs)
+      .setMerges(bytePairs)
+
+    annotatorModel.set(annotatorModel.engine, detectedEngine)
+
+    detectedEngine match {
+      case ONNX.name =>
+        val onnxWrapper =
+          OnnxWrapper.read(spark, localModelPath, zipped = false, useBundle = true)
+        annotatorModel
+          .setModelIfNotSet(spark, None, Some(onnxWrapper), None)
+
+      case Openvino.name =>
+        val ovWrapper: OpenvinoWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine)
+        annotatorModel
+          .setModelIfNotSet(spark, None, None, Some(ovWrapper))
+
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+}
+
+/** This is the companion object of [[RoBertaForMultipleChoice]]. Please refer to that class for
+  * the documentation.
+  */
+object RoBertaForMultipleChoice
+    extends ReadablePretrainedRoBertaForMCModel
+    with ReadRoBertaForMultipleChoiceDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/XlmRoBertaForMultipleChoice.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/XlmRoBertaForMultipleChoice.scala
new file mode 100644
index 00000000000000..cf13af8aba7f53
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/XlmRoBertaForMultipleChoice.scala
@@ -0,0 +1,352 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.classifier.dl
+
+import com.johnsnowlabs.ml.ai.XlmRoBertaClassification
+import com.johnsnowlabs.ml.onnx.{OnnxWrapper, ReadOnnxModel, WriteOnnxModel}
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.tensorflow.TensorflowWrapper
+import com.johnsnowlabs.ml.tensorflow.sentencepiece.{
+  ReadSentencePieceModel,
+  SentencePieceWrapper,
+  WriteSentencePieceModel
+}
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadSentencePieceAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp._
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.{IntParam, Param}
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** RoBertaForMultipleChoice can load BERT Models with a multiple choice classification head on
+  * top (a linear layer on top of the pooled output and a softmax) e.g. for RocStories/SWAG tasks.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val spanClassifier = RoBertaForMultipleChoice.pretrained()
+  *   .setInputCols(Array("document_question", "document_context"))
+  *   .setOutputCol("answer")
+  * }}}
+  * The default model is `"bert_base_uncased_multiple_choice"`, if no name is provided.
+  *
+  * For available pretrained models please see the
+  * [[https://sparknlp.org/models?task=Multiple+Choice Models Hub]].
+  *
+  * Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. To
+  * see which models are compatible and how to import them see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/discussions/5669]] and to see more extended
+  * examples, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/RoBertaForMultipleChoiceTestSpec.scala RoBertaForMultipleChoiceTestSpec]].
+  *
+  * ==Example==
+  * {{{
+  * import spark.implicits._
+  * import com.johnsnowlabs.nlp.base._
+  * import com.johnsnowlabs.nlp.annotator._
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val document = new MultiDocumentAssembler()
+  *   .setInputCols("question", "context")
+  *   .setOutputCols("document_question", "document_context")
+  *
+  * val questionAnswering = RoBertaForMultipleChoice.pretrained()
+  *   .setInputCols(Array("document_question", "document_context"))
+  *   .setOutputCol("answer")
+  *   .setCaseSensitive(false)
+  *
+  * val pipeline = new Pipeline().setStages(Array(
+  *   document,
+  *   questionAnswering
+  * ))
+  *
+  * val data = Seq("The Eiffel Tower is located in which country?", "Germany, France, Italy").toDF("question", "context")
+  * val result = pipeline.fit(data).transform(data)
+  *
+  * result.select("answer.result").show(false)
+  * +---------------------+
+  * |result               |
+  * +---------------------+
+  * |[France]              |
+  * ++--------------------+
+  * }}}
+  *
+  * @see
+  *   [[BertForQuestionAnswering]] for Question Answering tasks
+  * @see
+  *   [[https://sparknlp.org/docs/en/annotators Annotators Main Page]] for a list of transformer
+  *   based classifiers
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+
+class XlmRoBertaForMultipleChoice(override val uid: String)
+    extends AnnotatorModel[XlmRoBertaForMultipleChoice]
+    with HasBatchedAnnotate[XlmRoBertaForMultipleChoice]
+    with WriteOnnxModel
+    with WriteOpenvinoModel
+    with WriteSentencePieceModel
+    with HasCaseSensitiveProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("XlmRoBertaForMultipleChoice"))
+
+  /** Input Annotator Types: DOCUMENT, DOCUMENT
+    *
+    * @group anno
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] =
+    Array(AnnotatorType.DOCUMENT, AnnotatorType.DOCUMENT)
+
+  /** Output Annotator Types: CHUNK
+    *
+    * @group anno
+    */
+  override val outputAnnotatorType: AnnotatorType = AnnotatorType.CHUNK
+
+  /** Max sentence length to process (Default: `128`)
+    *
+    * @group param
+    */
+  val maxSentenceLength =
+    new IntParam(this, "maxSentenceLength", "Max sentence length to process")
+
+  /** @group setParam */
+  def setMaxSentenceLength(value: Int): this.type = {
+    require(
+      value <= 512,
+      "XLM-RoBERTa models do not support sequences longer than 512 because of trainable positional embeddings.")
+    require(value >= 1, "The maxSentenceLength must be at least 1")
+    set(maxSentenceLength, value)
+    this
+  }
+
+  val choicesDelimiter =
+    new Param[String](this, "choicesDelimiter", "Delimiter character use to split the choices")
+
+  def setChoicesDelimiter(value: String): this.type = set(choicesDelimiter, value)
+
+  private var _model: Option[Broadcast[XlmRoBertaClassification]] = None
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      tensorflowWrapper: Option[TensorflowWrapper],
+      onnxWrapper: Option[OnnxWrapper],
+      openvinoWrapper: Option[OpenvinoWrapper],
+      spp: SentencePieceWrapper): XlmRoBertaForMultipleChoice = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new XlmRoBertaClassification(
+            tensorflowWrapper,
+            onnxWrapper,
+            openvinoWrapper,
+            spp,
+            tags = Map.empty[String, Int])))
+    }
+
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: XlmRoBertaClassification = _model.get.value
+
+  /** Whether to lowercase tokens or not (Default: `true`).
+    *
+    * @group setParam
+    */
+  override def setCaseSensitive(value: Boolean): this.type = set(this.caseSensitive, value)
+
+  setDefault(
+    batchSize -> 8,
+    maxSentenceLength -> 128,
+    caseSensitive -> true,
+    choicesDelimiter -> ",")
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    *
+    * IMPORTANT: !MUST! return sequences of equal lengths !! IMPORTANT: !MUST! return sentences
+    * that belong to the same original row !! (challenging)
+    */
+  override def batchAnnotate(batchedAnnotations: Seq[Array[Annotation]]): Seq[Seq[Annotation]] = {
+    batchedAnnotations.map(annotations => {
+      if (annotations.nonEmpty) {
+        getModelIfNotSet.predictSpanMultipleChoice(
+          annotations,
+          $(choicesDelimiter),
+          $(maxSentenceLength),
+          $(caseSensitive))
+      } else {
+        Seq.empty[Annotation]
+      }
+    })
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    writeSentencePieceModel(
+      path,
+      spark,
+      getModelIfNotSet.spp,
+      "_xlmroberta",
+      XlmRoBertaForSequenceClassification.sppFile)
+    getEngine match {
+      case ONNX.name =>
+        writeOnnxModel(
+          path,
+          spark,
+          getModelIfNotSet.onnxWrapper.get,
+          "_xlm_roberta_mc_classification",
+          XlmRoBertaForMultipleChoice.onnxFile)
+      case Openvino.name =>
+        writeOpenvinoModel(
+          path,
+          spark,
+          getModelIfNotSet.openvinoWrapper.get,
+          "openvino_model.xml",
+          XlmRoBertaForMultipleChoice.openvinoFile)
+
+    }
+  }
+
+}
+
+trait ReadablePretrainedXmlRoBertaForMultipleChoiceModel
+    extends ParamsAndFeaturesReadable[XlmRoBertaForMultipleChoice]
+    with HasPretrained[XlmRoBertaForMultipleChoice] {
+  override val defaultModelName: Some[String] = Some("bert_base_uncased_multiple_choice")
+
+  /** Java compliant-overrides */
+  override def pretrained(): XlmRoBertaForMultipleChoice = super.pretrained()
+
+  override def pretrained(name: String): XlmRoBertaForMultipleChoice = super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): XlmRoBertaForMultipleChoice =
+    super.pretrained(name, lang)
+
+  override def pretrained(
+      name: String,
+      lang: String,
+      remoteLoc: String): XlmRoBertaForMultipleChoice =
+    super.pretrained(name, lang, remoteLoc)
+}
+
+trait ReadRoBertaForMultipleChoiceModelDLModel
+    extends ReadOnnxModel
+    with ReadOpenvinoModel
+    with ReadSentencePieceModel {
+  this: ParamsAndFeaturesReadable[XlmRoBertaForMultipleChoice] =>
+
+  override val onnxFile: String = "xlm_roberta_mc_classification_onnx"
+  override val openvinoFile: String = "xlm_roberta_mc_classification_openvino"
+  override val sppFile: String = "xlmroberta_spp"
+
+  def readModel(
+      instance: XlmRoBertaForMultipleChoice,
+      path: String,
+      spark: SparkSession): Unit = {
+    val spp = readSentencePieceModel(path, spark, "_xlmroberta_spp", sppFile)
+    instance.getEngine match {
+      case ONNX.name =>
+        val onnxWrapper =
+          readOnnxModel(path, spark, "xlm_roberta_qa_classification_onnx")
+        instance.setModelIfNotSet(spark, None, Some(onnxWrapper), None, spp)
+      case Openvino.name =>
+        val openvinoWrapper = readOpenvinoModel(path, spark, "xlm_roberta_qa_classification_ov")
+        instance.setModelIfNotSet(spark, None, None, Some(openvinoWrapper), spp)
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(modelPath: String, spark: SparkSession): XlmRoBertaForMultipleChoice = {
+    val (localModelPath, detectedEngine) = modelSanityCheck(modelPath)
+
+    val spModel = loadSentencePieceAsset(localModelPath, "sentencepiece.bpe.model")
+
+    /*Universal parameters for all engines*/
+    val annotatorModel = new XlmRoBertaForMultipleChoice()
+
+    annotatorModel.set(annotatorModel.engine, detectedEngine)
+
+    detectedEngine match {
+      case ONNX.name =>
+        val onnxWrapper =
+          OnnxWrapper.read(spark, localModelPath, zipped = false, useBundle = true)
+        annotatorModel
+          .setModelIfNotSet(spark, None, Some(onnxWrapper), None, spModel)
+
+      case Openvino.name =>
+        val ovWrapper: OpenvinoWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine)
+        annotatorModel
+          .setModelIfNotSet(spark, None, None, Some(ovWrapper), spModel)
+
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+
+}
+
+/** This is the companion object of [[XlmRoBertaForMultipleChoice]]. Please refer to that class
+  * for the documentation.
+  */
+object XlmRoBertaForMultipleChoice
+    extends ReadablePretrainedXmlRoBertaForMultipleChoiceModel
+    with ReadRoBertaForMultipleChoiceModelDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/Cleaner.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/Cleaner.scala
new file mode 100644
index 00000000000000..5a25373a7e8d80
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/Cleaner.scala
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.cleaners
+
+import com.johnsnowlabs.ml.tensorflow.sentencepiece.ReadSentencePieceModel
+import com.johnsnowlabs.nlp.Annotation
+import com.johnsnowlabs.nlp.AnnotatorType.CHUNK
+import com.johnsnowlabs.nlp.annotators.cleaners.util.CleanerHelper
+import com.johnsnowlabs.nlp.annotators.cleaners.util.CleanerHelper._
+import com.johnsnowlabs.nlp.annotators.seq2seq.{
+  MarianTransformer,
+  ReadMarianMTDLModel,
+  ReadablePretrainedMarianMTModel
+}
+import org.apache.spark.ml.param.Param
+import org.apache.spark.ml.util.Identifiable
+
+//TODO: Add documentation at the beginning as other transformers e.g. Chunker
+class Cleaner(override val uid: String) extends MarianTransformer {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("CLEANER"))
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  override val outputAnnotatorType: AnnotatorType = CHUNK
+
+  val encoding = new Param[String](
+    this,
+    "encoding",
+    "The encoding to be used for decoding the byte string (default is utf-8)")
+
+  def setEncoding(value: String): this.type = set(this.encoding, value)
+
+  val cleanPrefixPattern = new Param[String](
+    this,
+    "cleanPrefixPattern",
+    "The pattern for the prefix. Can be a simple string or a regex pattern.")
+
+  def setCleanPrefixPattern(value: String): this.type = set(this.cleanPrefixPattern, value)
+
+  val cleanPostfixPattern = new Param[String](
+    this,
+    "cleanPostfixPattern",
+    "The pattern for the postfix. Can be a simple string or a regex pattern.")
+
+  def setCleanPostfixPattern(value: String): this.type = set(this.cleanPrefixPattern, value)
+
+  /** cleanerMode can take the following values:
+    *   - `bytes_string_to_string`: Converts a string representation of a byte string (e.g.,
+    *     containing escape sequences) to an Annotation structure using the specified encoding.
+    */
+  val cleanerMode: Param[String] = new Param[String](
+    this,
+    "cleanerMode",
+    "possible values: " +
+      "clean, bytes_string_to_string, clean_non_ascii_chars, clean_ordered_bullets, clean_postfix," +
+      " clean_prefix, remove_punctuation, replace_unicode_characters")
+
+  def setCleanerMode(value: String): this.type = {
+    value.trim.toLowerCase() match {
+      case "clean" => set(this.cleanerMode, value)
+      case "bytes_string_to_string" => set(this.cleanerMode, value)
+      case "clean_non_ascii_chars" => set(this.cleanerMode, value)
+      case "clean_ordered_bullets" => set(this.cleanerMode, value)
+      case "clean_postfix" => set(this.cleanerMode, value)
+      case "clean_prefix" => set(this.cleanerMode, value)
+      case "remove_punctuation" => set(this.cleanerMode, value)
+      case "replace_unicode_characters" => set(this.cleanerMode, value)
+      case "translate" => set(this.cleanerMode, value)
+      case _ => throw new IllegalArgumentException(s"Cleaner mode $value is not supported.")
+    }
+    set(this.cleanerMode, value)
+  }
+
+  val extraWhitespace =
+    new Param[Boolean](this, "extraWhitespace", "Whether to remove extra whitespace.")
+
+  def setExtraWhitespace(value: Boolean): this.type = set(this.extraWhitespace, value)
+
+  val dashes = new Param[Boolean](this, "dashes", "Whether to handle dashes in text.")
+
+  def setDashes(value: Boolean): this.type = set(this.dashes, value)
+
+  val bullets = new Param[Boolean](this, "bullets", "Whether to handle bullets in text.")
+
+  def setBullets(value: Boolean): this.type = set(this.bullets, value)
+
+  val trailingPunctuation = new Param[Boolean](
+    this,
+    "trailingPunctuation",
+    "Whether to remove trailing punctuation from text.")
+
+  def setTrailingPunctuation(value: Boolean): this.type = set(this.trailingPunctuation, value)
+
+  val lowercase = new Param[Boolean](this, "lowercase", "Whether to convert text to lowercase.")
+
+  def setLowercase(value: Boolean): this.type = set(this.lowercase, value)
+
+  val ignoreCase = new Param[Boolean](this, "ignoreCase", "If true, ignores case in the pattern.")
+
+  def setIgnoreCase(value: Boolean): this.type = set(this.ignoreCase, value)
+
+  val strip = new Param[Boolean](
+    this,
+    "strip",
+    "If true, removes leading or trailing whitespace from the cleaned string.")
+
+  def setStrip(value: Boolean): this.type = set(this.strip, value)
+
+  setDefault(
+    encoding -> "utf-8",
+    extraWhitespace -> false,
+    dashes -> false,
+    bullets -> false,
+    trailingPunctuation -> false,
+    lowercase -> false,
+    ignoreCase -> false,
+    strip -> true,
+    cleanerMode -> "translate")
+
+  override def batchAnnotate(batchedAnnotations: Seq[Array[Annotation]]): Seq[Seq[Annotation]] = {
+    require($(cleanerMode) != "undefined", "Extractor mode must be set.")
+
+    if ($(cleanerMode) == "translate") {
+      return super.batchAnnotate(batchedAnnotations)
+    }
+
+    batchedAnnotations.map { annotations =>
+      $(cleanerMode) match {
+        case "clean" => annotations.map(buildAnnotation(clean)).toSeq
+        case "bytes_string_to_string" =>
+          annotations.map(buildAnnotation(bytesStringToString)).toSeq
+        case "clean_non_ascii_chars" => annotations.map(buildAnnotation(cleanNonAsciiChars)).toSeq
+        case "clean_ordered_bullets" =>
+          annotations.map(buildAnnotation(cleanOrderedBullets)).toSeq
+        case "clean_postfix" => annotations.map(buildAnnotation(cleanPostfix)).toSeq
+        case "clean_prefix" => annotations.map(buildAnnotation(cleanPrefix)).toSeq
+        case "remove_punctuation" => annotations.map(buildAnnotation(removePunctuation)).toSeq
+        case "replace_unicode_characters" =>
+          annotations.map(buildAnnotation(replaceUnicodeCharacters)).toSeq
+      }
+    }
+  }
+
+  def buildAnnotation(transformation: String => String)(annotation: Annotation): Annotation = {
+    val cleanText = transformation(annotation.result)
+    Annotation(
+      annotatorType = outputAnnotatorType,
+      begin = 0,
+      end = cleanText.length,
+      result = cleanText,
+      metadata = Map())
+  }
+
+  /** Converts a string representation of a byte string (e.g., containing escape sequences) to an
+    * Annotation structure using the specified encoding.
+    *
+    * @param text
+    *   The string representation of the byte string.
+    * @return
+    *   The String containing the decoded result
+    */
+  private def bytesStringToString(text: String): String = {
+    CleanerHelper.bytesStringToString(text, $(encoding))
+  }
+
+  private def clean(text: String): String = {
+
+    var cleanedText = if ($(lowercase)) text.toLowerCase else text
+    cleanedText =
+      if ($(trailingPunctuation)) cleanTrailingPunctuation(cleanedText) else cleanedText
+    cleanedText = if ($(dashes)) cleanDashes(cleanedText) else cleanedText
+    cleanedText = if ($(extraWhitespace)) cleanExtraWhitespace(cleanedText) else cleanedText
+    cleanedText = if ($(bullets)) cleanBullets(cleanedText) else cleanedText
+
+    cleanedText.trim
+  }
+
+  /** Cleans a prefix from a string based on a pattern.
+    *
+    * @param text
+    *   The text to clean.
+    * @return
+    *   The cleaned string.
+    */
+  private def cleanPrefix(text: String): String = {
+    CleanerHelper.cleanPrefix(text, $(cleanPrefixPattern), $(ignoreCase), $(strip))
+  }
+
+  /** Cleans a postfix from a string based on a pattern.
+    *
+    * @param text
+    *   The text to clean.
+    * @return
+    *   The cleaned string.
+    */
+  private def cleanPostfix(text: String): String = {
+    CleanerHelper.cleanPostfix(text, $(cleanPrefixPattern), $(ignoreCase), $(strip))
+  }
+
+}
+
+object Cleaner
+    extends ReadablePretrainedMarianMTModel
+    with ReadMarianMTDLModel
+    with ReadSentencePieceModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/Extractor.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/Extractor.scala
new file mode 100644
index 00000000000000..23b4b5741b033f
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/Extractor.scala
@@ -0,0 +1,366 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.cleaners
+
+import com.johnsnowlabs.nlp.AnnotatorType.{CHUNK, DOCUMENT}
+import com.johnsnowlabs.nlp.{Annotation, AnnotatorModel, HasSimpleAnnotate}
+import org.apache.spark.ml.param.{IntParam, Param}
+import org.apache.spark.ml.util.Identifiable
+
+import scala.util.matching.Regex
+
+//TODO: Add documentation at the beginning as other transformers e.g. Extractor
+class Extractor(override val uid: String)
+    extends AnnotatorModel[Extractor]
+    with HasSimpleAnnotate[Extractor] {
+
+  def this() = this(Identifiable.randomUID("Extractor"))
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(DOCUMENT)
+  override val outputAnnotatorType: AnnotatorType = CHUNK
+
+  private val EMAIL_DATETIMETZ_PATTERN =
+    "[A-Za-z]{3},\\s\\d{1,2}\\s[A-Za-z]{3}\\s\\d{4}\\s\\d{2}:\\d{2}:\\d{2}\\s[+-]\\d{4}"
+  private val EMAIL_ADDRESS_PATTERN = "(?i)[a-z0-9\\.\\-+_]+@[a-z0-9\\.\\-+_]+\\.[a-z]+"
+
+  private val IPV4_PATTERN: String =
+    """(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3}"""
+  private val IPV6_PATTERN: String =
+    """[a-z0-9]{4}::[a-z0-9]{4}:[a-z0-9]{4}:[a-z0-9]{4}:[a-z0-9]{4}%?[0-9]*"""
+  private val IP_ADDRESS_PATTERN: String = s"($IPV4_PATTERN|$IPV6_PATTERN)"
+  private val IP_ADDRESS_NAME_PATTERN = "[a-zA-Z0-9-]*\\.[a-zA-Z]*\\.[a-zA-Z]*"
+
+  private val MAPI_ID_PATTERN = "[0-9]*\\.[0-9]*\\.[0-9]*\\.[0-9]*"
+  private val US_PHONE_NUMBERS_PATTERN =
+    "(?:\\+?(\\d{1,3}))?[-. (]*(\\d{3})?[-. )]*(\\d{3})[-. ]*(\\d{4})(?: *x(\\d+))?\\s*$"
+
+  private val IMAGE_URL_PATTERN =
+    """(?i)https?://(?:[a-z0-9$_@.&+!*\\(\\),%-])+(?:/[a-z0-9$_@.&+!*\\(\\),%-]*)*\.(?:jpg|jpeg|png|gif|bmp|heic)"""
+
+  val emailDateTimeTzPattern = new Param[String](
+    this,
+    "emailDateTimeTzPattern",
+    "Specifies the date-time pattern for email timestamps, including time zone formatting.")
+
+  /** @group setParam */
+  def setEmailDateTimeTzPattern(value: String): this.type = set(emailDateTimeTzPattern, value)
+
+  val emailAddress =
+    new Param[String](this, "emailAddress", "Specifies the pattern for email addresses.")
+
+  val ipAddressPattern =
+    new Param[String](this, "ipAddressPattern", "Specifies the pattern for IP addresses.")
+
+  /** @group setParam */
+  def setIpAddressPattern(value: String): this.type = set(ipAddressPattern, value)
+
+  val ipAddressNamePattern = new Param[String](
+    this,
+    "ipAddressNamePattern",
+    "Specifies the pattern for IP addresses with names.")
+
+  /** @group setParam */
+  def setIpAddressNamePattern(value: String): this.type = set(ipAddressNamePattern, value)
+
+  val mapiIdPattern =
+    new Param[String](this, "mapiIdPattern", "Specifies the pattern for MAPI IDs.")
+
+  /** @group setParam */
+  def setMapiIdPattern(value: String): this.type = set(mapiIdPattern, value)
+
+  val usPhoneNumbersPattern = new Param[String](
+    this,
+    "usPhoneNumbersPattern",
+    "Specifies the pattern for US phone numbers.")
+
+  val imageUrlPattern =
+    new Param[String](this, "imageUrlPattern", "Specifies the pattern for image URLs.")
+
+  /** @group setParam */
+  def setImageUrlPattern(value: String): this.type = set(imageUrlPattern, value)
+
+  val textPattern =
+    new Param[String](this, "textPattern", "Specifies the pattern for text after and before.")
+
+  def setTextPattern(value: String): this.type = set(textPattern, value)
+
+  val index = new IntParam(
+    this,
+    "index",
+    "Specifies the index of the pattern to extract in text after or before")
+
+  /** @group setParam */
+  def setIndex(value: Int): this.type = set(index, value)
+
+  /** extractorMode can take the following values:
+    *   - `email_date`: extract email date
+    *   - `email_address`: extract email address
+    *   - `ip_address`: extract ip address
+    *   - `ip_address_name`: extract ip address with name
+    *   - `mapi_id`: extract mapi id
+    *   - `us_phone_numbers`: extract US phone numbers
+    *   - `image_urls`: extract image URLs
+    *   - `bullets`: extract ordered bullets
+    *   - `text_after`: extract text after a pattern
+    *   - `text_before`: extract text before a pattern
+    * @group param
+    */
+  val extractorMode: Param[String] = new Param[String](
+    this,
+    "extractorMode",
+    "possible values: " +
+      "email_date, email_address, ip_address, ip_address_name, mapi_id, us_phone_numbers, image_urls, bullets, text_after, text_before")
+
+  /** @group setParam */
+  def setExtractorMode(value: String): this.type = {
+    value.trim.toLowerCase() match {
+      case "email_date" => set(extractorMode, "email_date")
+      case "email_address" => set(extractorMode, "email_address")
+      case "ip_address" => set(extractorMode, "ip_address")
+      case "ip_address_name" => set(extractorMode, "ip_address_name")
+      case "mapi_id" => set(extractorMode, "mapi_id")
+      case "us_phone_numbers" => set(extractorMode, "us_phone_numbers")
+      case "image_urls" => set(extractorMode, "image_urls")
+      case "bullets" => set(extractorMode, "bullets")
+      case "text_after" => set(extractorMode, "text_after")
+      case "text_before" => set(extractorMode, "text_before")
+      case _ => throw new IllegalArgumentException(s"Extractor mode $value not supported.")
+    }
+    set(extractorMode, value)
+  }
+
+  setDefault(
+    emailDateTimeTzPattern -> EMAIL_DATETIMETZ_PATTERN,
+    emailAddress -> EMAIL_ADDRESS_PATTERN,
+    ipAddressPattern -> IP_ADDRESS_PATTERN,
+    ipAddressNamePattern -> IP_ADDRESS_NAME_PATTERN,
+    mapiIdPattern -> MAPI_ID_PATTERN,
+    usPhoneNumbersPattern -> US_PHONE_NUMBERS_PATTERN,
+    imageUrlPattern -> IMAGE_URL_PATTERN,
+    index -> 0,
+    extractorMode -> "undefined")
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param annotations
+    *   Annotations that correspond to inputAnnotationCols generated by previous annotators if any
+    * @return
+    *   any number of annotations processed for every input annotation. Not necessary one to one
+    *   relationship
+    */
+  override def annotate(annotations: Seq[Annotation]): Seq[Annotation] = {
+    require($(extractorMode) != "undefined", "Extractor mode must be set.")
+
+    $(extractorMode) match {
+      case "email_date" => extractRegexPattern(annotations, $(emailDateTimeTzPattern).r)
+      case "email_address" => extractRegexPattern(annotations, $(emailAddress).r)
+      case "ip_address" => extractRegexPattern(annotations, $(ipAddressPattern).r)
+      case "ip_address_name" => extractRegexPattern(annotations, $(ipAddressNamePattern).r)
+      case "mapi_id" => extractRegexPattern(annotations, $(mapiIdPattern).r)
+      case "us_phone_numbers" => extractRegexPattern(annotations, $(usPhoneNumbersPattern).r)
+      case "image_urls" => extractImageUrls(annotations, $(imageUrlPattern).r)
+      case "bullets" =>
+        annotations.map { annotation =>
+          extractOrderedBulletsAsAnnotation(annotation.result)
+        }
+      case "text_after" =>
+        annotations.map { annotation =>
+          extractTextAfter(annotation.result, $(textPattern), $(index))
+        }
+      case "text_before" =>
+        annotations.map { annotation =>
+          extractTextBefore(annotation.result, $(textPattern), $(index))
+        }
+      case _ =>
+        throw new IllegalArgumentException(s"Extractor mode ${$(extractorMode)} not supported.")
+    }
+
+  }
+
+  private def extractImageUrls(annotations: Seq[Annotation], regex: Regex): Seq[Annotation] = {
+    annotations.flatMap { annotation =>
+      regex.findAllMatchIn(annotation.result).map { matched =>
+        val start = annotation.begin + matched.start
+        val end = annotation.begin + matched.end - 1
+        Annotation(outputAnnotatorType, start, end, matched.matched, Map.empty)
+      }
+    }
+  }
+
+  private def extractRegexPattern(annotations: Seq[Annotation], regex: Regex): Seq[Annotation] = {
+    annotations.flatMap { annotation =>
+      regex.findAllMatchIn(annotation.result).map { matched =>
+        val start = annotation.begin + matched.start
+        val end = annotation.begin + matched.end - 1
+        Annotation(outputAnnotatorType, start, end, matched.matched, Map.empty)
+      }
+    }
+  }
+
+  /** Extracts the start of bulleted text sections, considering numeric and alphanumeric types,
+    * and returns the result as an Annotation.
+    *
+    * @param text
+    *   The input string.
+    * @return
+    *   An Annotation object containing extracted bullet information.
+    *
+    * Example:
+    * ------- "This is a very important point" -> Annotation("bullet", 0, 0, "None,None,None",
+    * Map.empty) "1.1 This is a very important point" -> Annotation("bullet", 0, 3, "1,1,None",
+    * Map("section" -> "1", "sub_section" -> "1")) "a.1 This is a very important point" ->
+    * Annotation("bullet", 0, 3, "a,1,None", Map("section" -> "a", "sub_section" -> "1"))
+    */
+  private def extractOrderedBulletsAsAnnotation(text: String): Annotation = {
+    var section: Option[String] = None
+    var subSection: Option[String] = None
+    var subSubSection: Option[String] = None
+
+    val textParts = text.split("\\s+", 2)
+
+    val defaultBegin = 0
+    val defaultEnd = 0
+
+    if (textParts.isEmpty || textParts.head.count(_ == '.') == 0 || textParts.head.contains(
+        "..")) {
+      return Annotation(
+        annotatorType = outputAnnotatorType,
+        begin = defaultBegin,
+        end = defaultEnd,
+        result = "(None,None,None)",
+        metadata = Map.empty)
+    }
+
+    val bulletPattern: Regex = "\\.".r
+    val bulletParts = bulletPattern.split(textParts.head).filter(_.nonEmpty)
+
+    if (bulletParts.headOption.exists(_.length > 2)) {
+      return Annotation(
+        annotatorType = outputAnnotatorType,
+        begin = defaultBegin,
+        end = defaultEnd,
+        result = "(None,None,None)",
+        metadata = Map.empty)
+    }
+
+    val begin = 0
+    val end = textParts.head.length
+
+    section = Some(bulletParts.head)
+    if (bulletParts.length > 1) {
+      subSection = Some(bulletParts(1))
+    }
+    if (bulletParts.length > 2) {
+      subSubSection = Some(bulletParts(2))
+    }
+
+    val result =
+      s"(${section.getOrElse("None")},${subSection.getOrElse("None")},${subSubSection.getOrElse("None")})"
+    val metadata = Map(
+      "section" -> section.getOrElse("None"),
+      "sub_section" -> subSection.getOrElse("None"),
+      "sub_sub_section" -> subSubSection.getOrElse("None")).filterNot(_._2 == "None")
+
+    Annotation(
+      annotatorType = outputAnnotatorType,
+      begin = begin,
+      end = end,
+      result = result,
+      metadata = metadata)
+  }
+
+  /** Extracts text that occurs after the specified pattern and returns an Annotation.
+    *
+    * @param text
+    *   The input text.
+    * @param pattern
+    *   The regex pattern to search for.
+    * @param index
+    *   The occurrence index of the pattern.
+    * @param strip
+    *   If true, removes leading whitespace from the extracted string.
+    * @return
+    *   Annotation with details of the extracted result.
+    */
+  private def extractTextAfter(
+      text: String,
+      pattern: String,
+      index: Int = 0,
+      strip: Boolean = true): Annotation = {
+    val regexMatch = getIndexedMatch(text, pattern, index)
+    val begin = regexMatch.end
+    val afterText = text.substring(begin)
+    val result = if (strip) afterText.replaceAll("^\\s+", "") else afterText
+
+    Annotation(
+      annotatorType = outputAnnotatorType,
+      begin = begin,
+      end = text.length,
+      result = result,
+      metadata = Map("index" -> index.toString))
+  }
+
+  /** Extracts text that occurs before the specified pattern and returns an Annotation.
+    *
+    * @param text
+    *   The input text.
+    * @param pattern
+    *   The regex pattern to search for.
+    * @param index
+    *   The occurrence index of the pattern.
+    * @param strip
+    *   If true, removes trailing whitespace from the extracted string.
+    * @return
+    *   Annotation with details of the extracted result.
+    */
+  private def extractTextBefore(
+      text: String,
+      pattern: String,
+      index: Int = 0,
+      strip: Boolean = true): Annotation = {
+    val regexMatch = getIndexedMatch(text, pattern, index)
+    val start = regexMatch.start
+    val beforeText = text.substring(0, start)
+    val result = if (strip) beforeText.replaceAll("\\s+$", "") else beforeText
+
+    Annotation(
+      annotatorType = outputAnnotatorType,
+      begin = 0,
+      end = start,
+      result = result,
+      metadata = Map("index" -> index.toString))
+  }
+
+  private def getIndexedMatch(text: String, pattern: String, index: Int = 0): Regex.Match = {
+    if (index < 0)
+      throw new IllegalArgumentException(
+        s"The index is $index. Index must be a non-negative integer.")
+
+    val regex = new Regex(pattern)
+    val matches = regex.findAllMatchIn(text).toSeq
+
+    if (index >= matches.length)
+      throw new IllegalArgumentException(
+        s"Result with index $index was not found. The largest index was ${matches.length - 1}.")
+
+    matches(index)
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/util/CleanerHelper.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/util/CleanerHelper.scala
new file mode 100644
index 00000000000000..1ee85db92dc945
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cleaners/util/CleanerHelper.scala
@@ -0,0 +1,239 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.cleaners.util
+
+import java.nio.charset.Charset
+import java.util.regex.Pattern
+import scala.util.matching.Regex
+
+object CleanerHelper {
+
+  val UNICODE_BULLETS: List[String] = List(
+    "\u0095",
+    "\u2022",
+    "\u2023",
+    "\u2043",
+    "\u3164",
+    "\u204C",
+    "\u204D",
+    "\u2219",
+    "\u25CB",
+    "\u25CF",
+    "\u25D8",
+    "\u25E6",
+    "\u2619",
+    "\u2765",
+    "\u2767",
+    "\u29BE",
+    "\u29BF",
+    "\u002D",
+    "",
+    "\\*", // Escaped for regex compatibility
+    "\u0095",
+    "·")
+
+  private val BULLETS_PATTERN = UNICODE_BULLETS.map(Pattern.quote).mkString("|")
+  private val UNICODE_BULLETS_RE: Regex = new Regex(s"(?:$BULLETS_PATTERN)")
+
+  private val HTML_APOSTROPHE_ENTITY: String = "'"
+  private val HEXADECIMAL_ESCAPE_SEQUENCE: Regex = """\\x([0-9A-Fa-f]{2})""".r
+  val DOUBLE_PARAGRAPH_PATTERN = """(?:\s*\n\s*){2,}"""
+
+  /** Parses a string containing escape sequences (e.g., `\x9f`) into a byte array.
+    *
+    * @param text
+    *   The input string with escape sequences.
+    * @return
+    *   A byte array representing the parsed bytes.
+    */
+  def parseEscapedBytes(text: String): Array[Byte] = {
+    val RawByteCharset: Charset = Charset.forName("ISO-8859-1")
+
+    // Replace escape sequences with their byte values
+    HEXADECIMAL_ESCAPE_SEQUENCE
+      .replaceAllIn(
+        text,
+        m => {
+          val hexValue = m.group(1)
+          Integer.parseInt(hexValue, 16).toChar.toString
+        })
+      .getBytes(RawByteCharset)
+  }
+
+  /** Formats an input encoding string (e.g., `utf-8`, `iso-8859-1`, etc).
+    *
+    * @param encoding
+    *   The encoding string to be formatted.
+    * @return
+    *   The formatted encoding string.
+    */
+  def formatEncodingStr(encoding: String): String = {
+    var formattedEncoding = encoding.toLowerCase.replace("_", "-")
+
+    // Special case for Arabic and Hebrew charsets with directional annotations
+    val annotatedEncodings = Set("iso-8859-6-i", "iso-8859-6-e", "iso-8859-8-i", "iso-8859-8-e")
+    if (annotatedEncodings.contains(formattedEncoding)) {
+      formattedEncoding = formattedEncoding.dropRight(2)
+    }
+
+    formattedEncoding
+  }
+
+  def cleanTrailingPunctuation(text: String): String = {
+    text.replaceAll("[.,:;]+$", "")
+  }
+
+  def cleanDashes(text: String): String = {
+    val dashRegex: Regex = "[-\u2013]".r
+    dashRegex.replaceAllIn(text, " ").trim
+  }
+
+  def cleanExtraWhitespace(text: String): String = {
+    // Replace all occurrences of '\xa0' (non-breaking space) with a regular space
+    val hexNbspReplaced = text.replaceAll("\\\\x[aA]0", " ")
+
+    // Normalize other whitespace characters if needed
+    val normalizedText = hexNbspReplaced.replaceAll("\\p{Zs}", " ")
+
+    // Collapse whitespace sequences into a single space
+    val whitespaceRegex: Regex = "\\s+".r
+
+    whitespaceRegex.replaceAllIn(normalizedText, " ").trim
+  }
+
+  def cleanBullets(text: String): String = {
+    // Manually create a regex that explicitly matches the bullet "\u2022"
+    val manualBulletRegex: Regex = new Regex(s"""^$UNICODE_BULLETS_RE\\s?""")
+
+    // Debug the match
+    manualBulletRegex.findPrefixOf(text) match {
+      case Some(_) =>
+        manualBulletRegex.replaceFirstIn(text, "").trim
+      case None =>
+        text
+    }
+  }
+
+  def cleanNonAsciiChars(text: String): String = {
+    val decodedText = HEXADECIMAL_ESCAPE_SEQUENCE.replaceAllIn(
+      text,
+      m => Integer.parseInt(m.group(1), 16).toChar.toString)
+
+    val entityReplacedText = decodedText.replace(HTML_APOSTROPHE_ENTITY, "'")
+    entityReplacedText.replaceAll("[^\u0020-\u007E]", "")
+  }
+
+  def cleanOrderedBullets(text: String): String = {
+    val textParts = text.split("\\s+", 2) // Splitting into two parts to avoid unnecessary joins
+    if (textParts.length < 2) return text
+
+    val firstWord = textParts(0)
+    val remainingText = textParts(1)
+
+    if (!firstWord.contains(".") || firstWord.contains("..")) return text
+
+    val bulletParts = firstWord.split("\\.")
+    val cleanedBulletParts =
+      if (bulletParts.last.isEmpty) bulletParts.dropRight(1) else bulletParts
+
+    if (cleanedBulletParts.head.length > 2) text else remainingText.trim
+
+  }
+
+  def replaceUnicodeCharacters(text: String): String = {
+    val decodedText = HEXADECIMAL_ESCAPE_SEQUENCE.replaceAllIn(
+      text,
+      m => {
+        val hexValue = m.group(1)
+        val byteValue = Integer.parseInt(hexValue, 16).toByte
+        new String(Array(byteValue), Charset.forName("ISO-8859-1"))
+      })
+
+    val fullyDecodedText = new String(
+      decodedText.getBytes(Charset.forName("ISO-8859-1")),
+      Charset.forName("Windows-1252"))
+
+    fullyDecodedText
+      .replace("\u2018", "‘")
+      .replace("\u2019", "’")
+      .replace("\u201C", "“")
+      .replace("\u201D", "”")
+      .replace(HTML_APOSTROPHE_ENTITY, "'")
+      .replace("â\u0080\u0099", "'")
+      .replace("â\u0080“", "—")
+      .replace("â\u0080”", "–")
+      .replace("â\u0080¦", "…")
+  }
+
+  /** Removes punctuation from a given string.
+    *
+    * @params
+    *   The input string.
+    * @return
+    *   The string with punctuation removed.
+    */
+  def removePunctuation(text: String): String = {
+    // \p{P} matches any kind of punctuation character in Unicode
+    val punctuationRegex = """\p{P}""".r
+    punctuationRegex.replaceAllIn(text, "")
+  }
+
+  /** Cleans a prefix from a string based on a pattern.
+    *
+    * @param text
+    *   The text to clean.
+    * @return
+    *   The cleaned string.
+    */
+  def cleanPrefix(text: String, pattern: String, ignoreCase: Boolean, strip: Boolean): String = {
+    val regexStr =
+      if (ignoreCase) s"(?i)^$pattern[\\p{Punct}\\s]*"
+      else s"^$pattern[\\p{Punct}\\s]*"
+    val regex = regexStr.r
+
+    val cleanedText = regex.replaceAllIn(text, "")
+
+    if (strip) cleanedText.replaceAll("^\\s+", "") else cleanedText
+  }
+
+  /** Cleans a postfix from a string based on a pattern.
+    *
+    * @param text
+    *   The text to clean.
+    * @return
+    *   The cleaned string.
+    */
+  def cleanPostfix(text: String, pattern: String, ignoreCase: Boolean, strip: Boolean): String = {
+    val regex = if (ignoreCase) s"(?i)$pattern$$".r else s"$pattern$$".r
+    val cleanedText = regex.replaceAllIn(text, "")
+    if (strip) cleanedText.trim else cleanedText
+  }
+
+  /** Converts a string representation of a byte string (e.g., containing escape sequences) to an
+    * Annotation structure using the specified encoding.
+    *
+    * @param text
+    *   The string representation of the byte string.
+    * @return
+    *   The String containing the decoded result
+    */
+  def bytesStringToString(text: String, encoding: String): String = {
+    val textBytes = parseEscapedBytes(text)
+    val formattedEncoding = formatEncodingStr(encoding)
+    new String(textBytes, Charset.forName(formattedEncoding))
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/JanusforMultiModal.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/JanusforMultiModal.scala
new file mode 100644
index 00000000000000..793fa7bc549cfe
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/JanusforMultiModal.scala
@@ -0,0 +1,703 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.ai.Janus
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadJsonStringAsset,
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.ml.util.Openvino
+import com.johnsnowlabs.nlp.AnnotatorType.{DOCUMENT, IMAGE}
+import com.johnsnowlabs.nlp._
+import org.json4s.{DefaultFormats, JValue}
+import org.json4s.jackson.JsonMethods.parse
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.JanusWrappers
+import com.johnsnowlabs.nlp.serialization.{MapFeature, StructFeature}
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.{IntArrayParam, IntParam, BooleanParam}
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** JanusForMultiModal can load Janus models for unified multimodal understanding and generation.
+  * The model consists of a vision encoder, a text encoder, and a text decoder. Janus decouples
+  * visual encoding for enhanced flexibility, leveraging a unified transformer architecture for
+  * both understanding and generation tasks.
+  *
+  * Janus uses SigLIP-L as the vision encoder, supporting 384 x 384 image inputs. For image
+  * generation, it utilizes a tokenizer with a downsample rate of 16. The framework is based on
+  * DeepSeek-LLM-1.3b-base, trained on approximately 500B text tokens.
+  *
+  * Pretrained models can be loaded with `pretrained` from the companion object: {{ val visualQA =
+  * JanusForMultiModal.pretrained() .setInputCols("image_assembler") .setOutputCol("answer") }}
+  * The default model is "janus_1_3b_int4" if no name is provided.
+  *
+  * For available pretrained models, please refer to the
+  * [[https://sparknlp.org/models?task=Question+Answering Models Hub]].
+  *
+  * Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. For
+  * compatibility details and import instructions, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/discussions/5669]]. For extended examples, refer
+  * to
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/JanusForMultiModalTest.scala]].
+  *
+  * ==Example==
+  * {{ import spark.implicits._
+  *
+  * import com.johnsnowlabs.nlp.base._
+  *
+  * import com.johnsnowlabs.nlp.annotator._
+  *
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val imageDF: DataFrame = ResourceHelper.spark.read .format("image") .option("dropInvalid",
+  * value = true) .load(imageFolder)
+  *
+  * val testDF: DataFrame = imageDF.withColumn("text", lit("User: Describe
+  * image in details Assistant:"))
+  *
+  * val imageAssembler: ImageAssembler = new ImageAssembler() .setInputCol("image")
+  * .setOutputCol("image_assembler")
+  *
+  * val visualQAClassifier = JanusForMultiModal.pretrained() .setInputCols("image_assembler")
+  * .setOutputCol("answer")
+  *
+  * val pipeline = new Pipeline().setStages(Array( imageAssembler, visualQAClassifier ))
+  *
+  * val result = pipeline.fit(testDF).transform(testDF)
+  *
+  * result.select("image_assembler.origin", "answer.result").show(false)
+  * | origin                                 | result                                                                                  |
+  * |:---------------------------------------|:----------------------------------------------------------------------------------------|
+  * | [file:///content/images/cat_image.jpg] | [The unusual aspect of this picture is the presence of two cats lying on a pink couch.] |
+  * }}
+  *
+  * @see
+  *   [[CLIPForZeroShotClassification]] for Zero Shot Image Classification
+  * @see
+  *   [[https://sparknlp.org/docs/en/annotators Annotators Main Page]] for a list of
+  *   transformer-based classifiers
+  * @param uid
+  *   Required UID for storing the annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+class JanusForMultiModal(override val uid: String)
+    extends AnnotatorModel[JanusForMultiModal]
+    with HasBatchedAnnotateImage[JanusForMultiModal]
+    with HasImageFeatureProperties
+    with WriteOpenvinoModel
+    with HasGeneratorProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("JanusForMultiModal"))
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(IMAGE)
+  override val outputAnnotatorType: AnnotatorType = DOCUMENT
+
+  /** A list of token ids which are ignored in the decoder's output (Default: `Array()`)
+    *
+    * @group param
+    */
+  var ignoreTokenIds = new IntArrayParam(
+    this,
+    "ignoreTokenIds",
+    "A list of token ids which are ignored in the decoder's output")
+
+  /** @group setParam */
+  def setIgnoreTokenIds(tokenIds: Array[Int]): JanusForMultiModal.this.type = {
+    set(ignoreTokenIds, tokenIds)
+  }
+
+  /** @group getParam */
+  def getIgnoreTokenIds: Array[Int] = $(ignoreTokenIds)
+
+  /** Vocabulary used to encode the words to ids with bpeTokenizer.encode
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** Holding merges.txt coming from RoBERTa model
+    *
+    * @group param
+    */
+  val merges: MapFeature[(String, String), Int] = new MapFeature(this, "merges").setProtected()
+
+  /** @group setParam */
+  def setMerges(value: Map[(String, String), Int]): this.type = set(merges, value)
+
+  /** Additional tokens to be added to the vocabulary
+    *
+    * @group param
+    */
+  val addedTokens: MapFeature[String, Int] = new MapFeature(this, "addedTokens").setProtected()
+
+  /** @group setParam */
+  def setAddedTokens(value: Map[String, Int]): this.type = set(addedTokens, value)
+
+  /** Stop tokens to terminate the generation
+    *
+    * @group param
+    */
+  override val stopTokenIds =
+    new IntArrayParam(this, "stopTokenIds", "Stop tokens to terminate the generation")
+
+  /** @group setParam */
+  override def setStopTokenIds(value: Array[Int]): this.type = {
+    set(stopTokenIds, value)
+  }
+
+  /** @group getParam */
+  override def getStopTokenIds: Array[Int] = $(stopTokenIds)
+
+  private var _model: Option[Broadcast[Janus]] = None
+  val generationConfig: StructFeature[GenerationConfig] =
+    new StructFeature(this, "generationConfig").setProtected()
+
+  def setGenerationConfig(value: GenerationConfig): this.type =
+    set(generationConfig, value)
+
+  def getGenerationConfig: GenerationConfig = $$(generationConfig)
+
+  val imageToken =
+    new IntParam(this, "imageToken", "Token id for image embeddings")
+
+  /** @group setParam */
+  def setImageToken(value: Int): this.type = set(imageToken, value)
+
+  /** @group getParam */
+  def getImageToken: Int = $(imageToken)
+
+  val imageTokenLength =
+    new IntParam(this, "imageTokenLength", "Token length for image embeddings")
+
+  /** @group setParam */
+  def setImageTokenLength(value: Int): this.type = set(imageTokenLength, value)
+
+  /** @group getParam */
+  def getImageTokenLength: Int = $(imageTokenLength)
+
+  val imageGenerateMode: BooleanParam =
+    new BooleanParam(this, "imageGenerateMode", "Image generation mode")
+
+  /** @group setParam */
+  def setImageGenerateMode(value: Boolean): this.type = set(imageGenerateMode, value)
+
+  /** @group getParam */
+  def getImageGenerateMode: Boolean = $(imageGenerateMode)
+
+  val numOfParallelImages: IntParam =
+    new IntParam(this, "numOfParallelImages", "Number of parallel images to Generate")
+
+  /** @group setParam */
+  def setNumOfParallelImages(value: Int): this.type = set(numOfParallelImages, value)
+
+  /** @group getParam */
+  def getNumOfParallelImages: Int = $(numOfParallelImages)
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      preprocessor: Preprocessor,
+      onnxWrappers: Option[DecoderWrappers],
+      openvinoWrapper: Option[JanusWrappers]): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new Janus(
+            onnxWrappers,
+            openvinoWrapper,
+            $$(merges),
+            $$(vocabulary),
+            $$(addedTokens),
+            preprocessor,
+            generationConfig = getGenerationConfig,
+            imageToken = getImageToken,
+            imageTokenLength = getImageTokenLength)))
+    }
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: Janus = _model.get.value
+
+  setDefault(
+    minOutputLength -> 0,
+    maxOutputLength -> 20,
+    doSample -> false,
+    temperature -> 0.6,
+    topK -> -1,
+    topP -> 0.9,
+    repetitionPenalty -> 1.0,
+    noRepeatNgramSize -> 3,
+    ignoreTokenIds -> Array(),
+    batchSize -> 1,
+    beamSize -> 1,
+    maxInputLength -> 4096,
+    stopTokenIds -> Array(2),
+    imageToken -> 100594,
+    imageTokenLength -> 576,
+    imageGenerateMode -> false,
+    numOfParallelImages -> 1)
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    */
+  override def batchAnnotate(
+      batchedAnnotations: Seq[Array[AnnotationImage]]): Seq[Seq[Annotation]] = {
+
+    batchedAnnotations
+      //      .filter { annotationImages =>
+      //        annotationImages.exists(_.text.nonEmpty)
+      //      }
+      .map { cleanAnnotationImages =>
+        val validImages = cleanAnnotationImages.filter(_.result.nonEmpty)
+        val questionAnnotations = extractInputAnnotation(validImages)
+
+        getModelIfNotSet.predict(
+          questionAnnotations,
+          validImages.toSeq,
+          imageGenerateMode = $(imageGenerateMode),
+          batchSize = $(batchSize),
+          minOutputLength = $(minOutputLength),
+          maxOutputLength = $(maxOutputLength),
+          doSample = $(doSample),
+          temperature = $(temperature),
+          topK = $(topK),
+          topP = $(topP),
+          repetitionPenalty = $(repetitionPenalty),
+          noRepeatNgramSize = $(noRepeatNgramSize),
+          randomSeed = this.randomSeed,
+          ignoreTokenIds = $(ignoreTokenIds),
+          beamSize = $(beamSize),
+          maxInputLength = $(maxInputLength),
+          numOfParallelImages = $(numOfParallelImages))
+      }
+  }
+
+  private def extractInputAnnotation(
+      annotationImages: Array[AnnotationImage]): Seq[Annotation] = {
+    val questions = annotationImages.map(annotationImage => {
+      val imageText =
+        if (annotationImage.text.nonEmpty) annotationImage.text
+        else
+          "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\\n\\nUser: Describe image in details\\n\\nAssistant:" // default question
+      Annotation(imageText)
+    })
+
+    questions
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getEngine match {
+      case Openvino.name =>
+        val wrappers = getModelIfNotSet.openvinoWrapper
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.languageModel, "openvino_language_model.xml")),
+          JanusForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.visionEmbeddingsModel, "openvino_vision_embeddings_model.xml")),
+          JanusForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.textEmbeddingsModel, "openvino_text_embeddings_model.xml")),
+          JanusForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.mergeModel, "openvino_multimodal_merge_model.xml")),
+          JanusForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.lmHeadModel, "openvino_lm_head_model.xml")),
+          JanusForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.genHeadModel, "openvino_gen_head_model.xml")),
+          JanusForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.genEmbeddingsModel, "openvino_gen_embeddings_model.xml")),
+          JanusForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.genDecoderModel, "openvino_gen_decoder_model.xml")),
+          JanusForMultiModal.suffix)
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+}
+
+trait ReadablePretrainedJanusForMultiModal
+    extends ParamsAndFeaturesReadable[JanusForMultiModal]
+    with HasPretrained[JanusForMultiModal] {
+
+  override val defaultModelName: Some[String] = Some("janus_1_3b_int4")
+
+  /** Java compliant-overrides */
+  override def pretrained(): JanusForMultiModal = super.pretrained()
+
+  override def pretrained(name: String): JanusForMultiModal =
+    super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): JanusForMultiModal =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): JanusForMultiModal =
+    super.pretrained(name, lang, remoteLoc)
+
+}
+
+trait ReadJanusForMultiModalDLModel extends ReadOpenvinoModel {
+  this: ParamsAndFeaturesReadable[JanusForMultiModal] =>
+  val suffix: String = "_Janus"
+  override val openvinoFile: String = "Janus_openvino"
+  def readModel(instance: JanusForMultiModal, path: String, spark: SparkSession): Unit = {
+    instance.getEngine match {
+      case Openvino.name =>
+        val languageModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_language_model.xml"), suffix)
+
+        val visionEmbeddingsModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_vision_embeddings_model.xml"), suffix)
+
+        val textEmbeddingsModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_text_embeddings_model.xml"), suffix)
+
+        val mergeModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_multimodal_merge_model.xml"), suffix)
+
+        val lmHeadModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_lm_head_model.xml"), suffix)
+
+        val genHeadModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_gen_head_model.xml"), suffix)
+
+        val genEmbeddingsModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_gen_embeddings_model.xml"), suffix)
+
+        val genDecoderModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_gen_decoder_model.xml"), suffix)
+
+        val ovWrapper = JanusWrappers(
+          languageModel = languageModelWrappers("openvino_language_model.xml"),
+          visionEmbeddingsModel =
+            visionEmbeddingsModelWrappers("openvino_vision_embeddings_model.xml"),
+          textEmbeddingsModel = textEmbeddingsModelWrappers("openvino_text_embeddings_model.xml"),
+          mergeModel = mergeModelWrappers("openvino_multimodal_merge_model.xml"),
+          lmHeadModel = lmHeadModelWrappers("openvino_lm_head_model.xml"),
+          genHeadModel = genHeadModelWrappers("openvino_gen_head_model.xml"),
+          genEmbeddingsModel = genEmbeddingsModelWrappers("openvino_gen_embeddings_model.xml"),
+          genDecoderModel = genDecoderModelWrappers("openvino_gen_decoder_model.xml"))
+        val preprocessor = Preprocessor(
+          do_normalize = true,
+          do_resize = true,
+          "JanusFeatureExtractor",
+          instance.getImageMean,
+          instance.getImageStd,
+          instance.getResample,
+          instance.getSize)
+        instance.setModelIfNotSet(spark, preprocessor, None, Some(ovWrapper))
+      case _ => {
+        throw new Exception(notSupportedEngineError)
+      }
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(
+      modelPath: String,
+      spark: SparkSession,
+      useOpenvino: Boolean = false): JanusForMultiModal = {
+    implicit val formats: DefaultFormats.type = DefaultFormats // for json4
+    val (localModelPath, detectedEngine) =
+      modelSanityCheck(
+        modelPath,
+        isDecoder = false,
+        custom = Some(
+          List(
+            "openvino_language_model",
+            "openvino_vision_embeddings_model",
+            "openvino_text_embeddings_model",
+            "openvino_multimodal_merge_model",
+            "openvino_lm_head_model",
+            "openvino_gen_head_model",
+            "openvino_gen_embeddings_model",
+            "openvino_gen_decoder_model")))
+    val modelConfig: JValue =
+      parse(loadJsonStringAsset(localModelPath, "config.json"))
+    val preprocessorConfigJsonContent =
+      loadJsonStringAsset(localModelPath, "preprocessor_config.json")
+    val preprocessorConfig = Preprocessor.loadPreprocessorConfig(preprocessorConfigJsonContent)
+    val beginSuppressTokens: Array[Int] =
+      (modelConfig \ "begin_suppress_tokens").extract[Array[Int]]
+
+    val suppressTokenIds: Array[Int] =
+      (modelConfig \ "suppress_tokens").extract[Array[Int]]
+
+    val forcedDecoderIds: Array[(Int, Int)] =
+      (modelConfig \ "forced_decoder_ids").extract[Array[Array[Int]]].map {
+        case idxWithTokenId: Array[Int] if idxWithTokenId.length == 2 =>
+          (idxWithTokenId(0), idxWithTokenId(1))
+        case _ =>
+          throw new Exception(
+            "Could not extract forced_decoder_ids. Should be a list of tuples with 2 entries.")
+      }
+
+    def arrayOrNone[T](array: Array[T]): Option[Array[T]] =
+      if (array.nonEmpty) Some(array) else None
+
+    val vocabSize = (modelConfig \ "language_config" \ "vocab_size").extract[Int]
+
+    val imageTokenLength = 576
+
+    // Check if tokenizer.json exists
+    val tokenizerPath = s"$localModelPath/assets/tokenizer.json"
+    val tokenizerExists = new java.io.File(tokenizerPath).exists()
+    val (vocabs, addedTokens, bytePairs) = if (tokenizerExists) {
+      val tokenizerConfig: JValue = parse(loadJsonStringAsset(localModelPath, "tokenizer.json"))
+      // extract vocab from tokenizer.json ( model -> vocab)
+      var vocabs: Map[String, Int] =
+        (tokenizerConfig \ "model" \ "vocab").extract[Map[String, Int]]
+
+      // extract merges from tokenizer.json ( model -> merges)
+      val bytePairs = (tokenizerConfig \ "model" \ "merges")
+        .extract[List[Array[String]]]
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+
+      // extract added_tokens from tokenizer.json (added_tokens)
+      // "added_tokens": [
+      //    {
+      //      "id": 128000,
+      //      "content": "<|begin_of_text|>",
+      //      "single_word": false,
+      //      "lstrip": false,
+      //      "rstrip": false,
+      //      "normalized": false,
+      //      "special": true
+      //    }, ...
+      //  ]
+      val addedTokens = (tokenizerConfig \ "added_tokens")
+        .extract[List[Map[String, Any]]]
+        .map { token =>
+          val id = token("id").asInstanceOf[BigInt].intValue()
+          val content = token("content").asInstanceOf[String]
+          (content, id)
+        }
+        .toMap
+
+      // update vocab with added tokens
+      addedTokens.foreach { case (content, id) =>
+        vocabs += (content -> id)
+      }
+      (vocabs, addedTokens, bytePairs)
+    } else {
+      val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+      val addedTokens = loadTextAsset(localModelPath, "added_tokens.txt").zipWithIndex.toMap
+      val bytePairs = loadTextAsset(localModelPath, "merges.txt")
+        .map(_.split(" "))
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+      (vocabs, addedTokens, bytePairs)
+    }
+
+    val tokenizerConfigFile: JValue =
+      parse(loadJsonStringAsset(localModelPath, "tokenizer_config.json"))
+
+    val bosToken = (tokenizerConfigFile \ "bos_token").extract[String]
+    val eosToken = (tokenizerConfigFile \ "eos_token").extract[String]
+    val padToken = (tokenizerConfigFile \ "pad_token").extract[String]
+
+    val bosTokenId = vocabs.getOrElse(bosToken, 100000)
+    val eosTokenId = vocabs.getOrElse(eosToken, 100001)
+    val padTokenId = vocabs.getOrElse(padToken, 100015)
+    val imageToken = vocabs.getOrElse("", 100594)
+
+    val annotatorModel = new JanusForMultiModal()
+      .setGenerationConfig(
+        GenerationConfig(
+          bosTokenId,
+          padTokenId,
+          eosTokenId,
+          vocabSize,
+          arrayOrNone(beginSuppressTokens),
+          arrayOrNone(suppressTokenIds),
+          arrayOrNone(forcedDecoderIds)))
+      .setVocabulary(vocabs)
+      .setMerges(bytePairs)
+      .setAddedTokens(addedTokens)
+      .setImageToken(imageToken)
+      .setImageTokenLength(imageTokenLength)
+      .setSize(preprocessorConfig.size)
+      .setImageMean(preprocessorConfig.image_mean)
+      .setImageStd(preprocessorConfig.image_std)
+      .setResample(preprocessorConfig.resample)
+
+    val modelEngine =
+      if (useOpenvino)
+        Openvino.name
+      else
+        detectedEngine
+    annotatorModel.set(annotatorModel.engine, modelEngine)
+    detectedEngine match {
+      case Openvino.name =>
+        val visionWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_vision_embeddings_model")
+        val textWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_text_embeddings_model")
+        val mergeWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_multimodal_merge_model")
+        val languageModelWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_language_model")
+        val lmHeadWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_lm_head_model")
+        val genHeadWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_gen_head_model")
+        val genEmbeddingsWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_gen_embeddings_model")
+        val genDecoderWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_gen_decoder_model")
+        val openvinoWrapper = JanusWrappers(
+          languageModel = languageModelWrapper,
+          visionEmbeddingsModel = visionWrapper,
+          textEmbeddingsModel = textWrapper,
+          mergeModel = mergeWrapper,
+          lmHeadModel = lmHeadWrapper,
+          genHeadModel = genHeadWrapper,
+          genEmbeddingsModel = genEmbeddingsWrapper,
+          genDecoderModel = genDecoderWrapper)
+        annotatorModel.setModelIfNotSet(spark, preprocessorConfig, None, Some(openvinoWrapper))
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+}
+
+object JanusForMultiModal
+    extends ReadablePretrainedJanusForMultiModal
+    with ReadJanusForMultiModalDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModal.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModal.scala
new file mode 100644
index 00000000000000..0e4784f0ce204b
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModal.scala
@@ -0,0 +1,615 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.ai.LLaVA
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadJsonStringAsset,
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.ml.util.Openvino
+import com.johnsnowlabs.nlp.AnnotatorType.{DOCUMENT, IMAGE}
+import com.johnsnowlabs.nlp._
+import org.json4s.{DefaultFormats, JValue}
+import org.json4s.jackson.JsonMethods.parse
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.LLAVAWrappers
+import com.johnsnowlabs.nlp.serialization.{MapFeature, StructFeature}
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.{IntArrayParam, IntParam}
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** LLAVAForMultiModal can load LLAVA Vision models for visual question answering. The model
+  * consists of a vision encoder, a text encoder as well as a text decoder. The vision encoder
+  * will encode the input image, the text encoder will encode the input question together with the
+  * encoding of the image, and the text decoder will output the answer to the question.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val visualQA = LLAVAForMultiModal.pretrained()
+  *   .setInputCols("image_assembler")
+  *   .setOutputCol("answer")
+  * }}}
+  * The default model is `"llava_1_5_7b_hf"`, if no name is provided.
+  *
+  * For available pretrained models please see the
+  * [[https://sparknlp.org/models?task=Question+Answering Models Hub]].
+  *
+  * Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. To
+  * see which models are compatible and how to import them see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/discussions/5669]] and to see more extended
+  * examples, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModalTest.scala]].
+  *
+  * ==Example==
+  * {{{
+  * import spark.implicits._
+  * import com.johnsnowlabs.nlp.base._
+  * import com.johnsnowlabs.nlp.annotator._
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val imageDF: DataFrame = ResourceHelper.spark.read
+  *  .format("image")
+  *  .option("dropInvalid", value = true)
+  *  .load(imageFolder)
+  *
+  * val testDF: DataFrame = imageDF.withColumn("text", lit("USER: \n <|image|> \nWhat is unusual on this picture? \n ASSISTANT:\n"))
+  *
+  * val imageAssembler: ImageAssembler = new ImageAssembler()
+  *   .setInputCol("image")
+  *   .setOutputCol("image_assembler")
+  *
+  * val visualQAClassifier = LLAVAForMultiModal.pretrained()
+  *   .setInputCols("image_assembler")
+  *   .setOutputCol("answer")
+  *
+  * val pipeline = new Pipeline().setStages(Array(
+  *   imageAssembler,
+  *   visualQAClassifier
+  * ))
+  *
+  * val result = pipeline.fit(testDF).transform(testDF)
+  *
+  * result.select("image_assembler.origin", "answer.result").show(false)
+  * +--------------------------------------+------+
+  * |origin                                |result|
+  * +--------------------------------------+------+
+  * |[file:///content/images/cat_image.jpg]|[The unusual aspect of this picture is the presence of two cats lying on a pink couch]|
+  * +--------------------------------------+------+
+  * }}}
+  *
+  * @see
+  *   [[CLIPForZeroShotClassification]] for Zero Shot Image Classifier
+  * @see
+  *   [[https://sparknlp.org/docs/en/annotators Annotators Main Page]] for a list of transformer
+  *   based classifiers
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+
+class LLAVAForMultiModal(override val uid: String)
+    extends AnnotatorModel[LLAVAForMultiModal]
+    with HasBatchedAnnotateImage[LLAVAForMultiModal]
+    with HasImageFeatureProperties
+    with WriteOpenvinoModel
+    with HasGeneratorProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("LLAVAForMultiModal"))
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(IMAGE)
+  override val outputAnnotatorType: AnnotatorType = DOCUMENT
+
+  /** @group setParam */
+  def setRandomSeed(value: Int): LLAVAForMultiModal.this.type = {
+    if (randomSeed.isEmpty) {
+      this.randomSeed = Some(value)
+    }
+    this
+  }
+
+  /** A list of token ids which are ignored in the decoder's output (Default: `Array()`)
+    *
+    * @group param
+    */
+  var ignoreTokenIds = new IntArrayParam(
+    this,
+    "ignoreTokenIds",
+    "A list of token ids which are ignored in the decoder's output")
+
+  /** @group setParam */
+  def setIgnoreTokenIds(tokenIds: Array[Int]): LLAVAForMultiModal.this.type = {
+    set(ignoreTokenIds, tokenIds)
+  }
+
+  /** @group getParam */
+  def getIgnoreTokenIds: Array[Int] = $(ignoreTokenIds)
+
+  /** Vocabulary used to encode the words to ids with bpeTokenizer.encode
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** Holding merges.txt coming from RoBERTa model
+    *
+    * @group param
+    */
+  val merges: MapFeature[(String, String), Int] = new MapFeature(this, "merges").setProtected()
+
+  /** @group setParam */
+  def setMerges(value: Map[(String, String), Int]): this.type = set(merges, value)
+
+  /** Additional tokens to be added to the vocabulary
+    *
+    * @group param
+    */
+  val addedTokens: MapFeature[String, Int] = new MapFeature(this, "addedTokens").setProtected()
+
+  /** @group setParam */
+  def setAddedTokens(value: Map[String, Int]): this.type = set(addedTokens, value)
+
+  /** Stop tokens to terminate the generation
+    *
+    * @group param
+    */
+  override val stopTokenIds =
+    new IntArrayParam(this, "stopTokenIds", "Stop tokens to terminate the generation")
+
+  /** @group setParam */
+  override def setStopTokenIds(value: Array[Int]): this.type = {
+    set(stopTokenIds, value)
+  }
+
+  /** @group getParam */
+  override def getStopTokenIds: Array[Int] = $(stopTokenIds)
+
+  private var _model: Option[Broadcast[LLaVA]] = None
+  val generationConfig: StructFeature[GenerationConfig] =
+    new StructFeature(this, "generationConfig").setProtected()
+
+  def setGenerationConfig(value: GenerationConfig): this.type =
+    set(generationConfig, value)
+
+  def getGenerationConfig: GenerationConfig = $$(generationConfig)
+
+  val imageToken =
+    new IntParam(this, "imageToken", "Token id for image embeddings")
+
+  /** @group setParam */
+  def setImageToken(value: Int): this.type = set(imageToken, value)
+
+  /** @group getParam */
+  def getImageToken: Int = $(imageToken)
+
+  val imageTokenLength =
+    new IntParam(this, "imageTokenLength", "Token length for image embeddings")
+
+  /** @group setParam */
+  def setImageTokenLength(value: Int): this.type = set(imageTokenLength, value)
+
+  /** @group getParam */
+  def getImageTokenLength: Int = $(imageTokenLength)
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      preprocessor: Preprocessor,
+      onnxWrappers: Option[DecoderWrappers],
+      openvinoWrapper: Option[LLAVAWrappers]): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new LLaVA(
+            onnxWrappers,
+            openvinoWrapper,
+            $$(merges),
+            $$(vocabulary),
+            $$(addedTokens),
+            preprocessor,
+            generationConfig = getGenerationConfig,
+            imageToken = getImageToken,
+            imageTokenLength = getImageTokenLength)))
+    }
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: LLaVA = _model.get.value
+
+  setDefault(
+    minOutputLength -> 0,
+    maxOutputLength -> 20,
+    doSample -> false,
+    temperature -> 0.6,
+    topK -> -1,
+    topP -> 0.9,
+    repetitionPenalty -> 1.0,
+    noRepeatNgramSize -> 3,
+    ignoreTokenIds -> Array(),
+    batchSize -> 1,
+    beamSize -> 1,
+    maxInputLength -> 4096,
+    stopTokenIds -> Array(2),
+    imageToken -> 32000,
+    imageTokenLength -> 576)
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    */
+  override def batchAnnotate(
+      batchedAnnotations: Seq[Array[AnnotationImage]]): Seq[Seq[Annotation]] = {
+
+    batchedAnnotations
+      //      .filter { annotationImages =>
+      //        annotationImages.exists(_.text.nonEmpty)
+      //      }
+      .map { cleanAnnotationImages =>
+        val validImages = cleanAnnotationImages.filter(_.result.nonEmpty)
+        val questionAnnotations = extractInputAnnotation(validImages)
+
+        getModelIfNotSet.predict(
+          questionAnnotations,
+          validImages.toSeq,
+          batchSize = $(batchSize),
+          minOutputLength = $(minOutputLength),
+          maxOutputLength = $(maxOutputLength),
+          doSample = $(doSample),
+          temperature = $(temperature),
+          topK = $(topK),
+          topP = $(topP),
+          repetitionPenalty = $(repetitionPenalty),
+          noRepeatNgramSize = $(noRepeatNgramSize),
+          randomSeed = this.randomSeed,
+          ignoreTokenIds = $(ignoreTokenIds),
+          beamSize = $(beamSize),
+          maxInputLength = $(maxInputLength))
+      }
+  }
+
+  private def extractInputAnnotation(
+      annotationImages: Array[AnnotationImage]): Seq[Annotation] = {
+    val questions = annotationImages.map(annotationImage => {
+      val imageText =
+        if (annotationImage.text.nonEmpty) annotationImage.text
+        else
+          "<|user|> \n <|image|> This is an image\n <|end|>\n <|assistant|>\n" // default question
+      Annotation(imageText)
+    })
+
+    questions
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getEngine match {
+      case Openvino.name =>
+        val wrappers = getModelIfNotSet.openvinoWrapper
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.languageModel, "openvino_language_model.xml")),
+          LLAVAForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.visionEmbeddingsModel, "openvino_vision_embeddings_model.xml")),
+          LLAVAForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.textEmbeddingsModel, "openvino_text_embeddings_model.xml")),
+          LLAVAForMultiModal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.mergeModel, "openvino_merge_model.xml")),
+          LLAVAForMultiModal.suffix)
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+}
+
+trait ReadablePretrainedLLAVAForMultiModal
+    extends ParamsAndFeaturesReadable[LLAVAForMultiModal]
+    with HasPretrained[LLAVAForMultiModal] {
+
+  override val defaultModelName: Some[String] = Some("llava_1_5_7b_hf")
+
+  /** Java compliant-overrides */
+  override def pretrained(): LLAVAForMultiModal = super.pretrained()
+
+  override def pretrained(name: String): LLAVAForMultiModal =
+    super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): LLAVAForMultiModal =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): LLAVAForMultiModal =
+    super.pretrained(name, lang, remoteLoc)
+
+}
+
+trait ReadLLAVAForMultiModalDLModel extends ReadOpenvinoModel {
+  this: ParamsAndFeaturesReadable[LLAVAForMultiModal] =>
+  val suffix: String = "_llava"
+  override val openvinoFile: String = "llava_openvino"
+  def readModel(instance: LLAVAForMultiModal, path: String, spark: SparkSession): Unit = {
+    instance.getEngine match {
+      case Openvino.name =>
+        val languageModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_language_model.xml"), suffix)
+
+        val visionEmbeddingsModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_vision_embeddings_model.xml"), suffix)
+
+        val textEmbeddingsModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_text_embeddings_model.xml"), suffix)
+
+        val mergeModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_merge_model.xml"), suffix)
+
+        val ovWrapper = LLAVAWrappers(
+          languageModel = languageModelWrappers("openvino_language_model.xml"),
+          visionEmbeddingsModel =
+            visionEmbeddingsModelWrappers("openvino_vision_embeddings_model.xml"),
+          textEmbeddingsModel = textEmbeddingsModelWrappers("openvino_text_embeddings_model.xml"),
+          mergeModel = mergeModelWrappers("openvino_merge_model.xml"))
+        val preprocessor = Preprocessor(
+          do_normalize = true,
+          do_resize = true,
+          "LLAVAFeatureExtractor",
+          instance.getImageMean,
+          instance.getImageStd,
+          instance.getResample,
+          instance.getSize)
+        instance.setModelIfNotSet(spark, preprocessor, None, Some(ovWrapper))
+      case _ => {
+        throw new Exception(notSupportedEngineError)
+      }
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(
+      modelPath: String,
+      spark: SparkSession,
+      useOpenvino: Boolean = false): LLAVAForMultiModal = {
+    implicit val formats: DefaultFormats.type = DefaultFormats // for json4
+    val (localModelPath, detectedEngine) =
+      modelSanityCheck(
+        modelPath,
+        isDecoder = false,
+        custom = Some(
+          List(
+            "openvino_language_model",
+            "openvino_vision_embeddings_model",
+            "openvino_text_embeddings_model",
+            "openvino_merge_model")))
+    val modelConfig: JValue =
+      parse(loadJsonStringAsset(localModelPath, "config.json"))
+
+    val generationConfigJson: JValue = parse(
+      loadJsonStringAsset(localModelPath, "generation_config.json"))
+
+    val preprocessorConfigJsonContent =
+      loadJsonStringAsset(localModelPath, "preprocessor_config.json")
+    val preprocessorConfig = Preprocessor.loadPreprocessorConfig(preprocessorConfigJsonContent)
+    val beginSuppressTokens: Array[Int] =
+      (modelConfig \ "begin_suppress_tokens").extract[Array[Int]]
+
+    val suppressTokenIds: Array[Int] =
+      (modelConfig \ "suppress_tokens").extract[Array[Int]]
+
+    val forcedDecoderIds: Array[(Int, Int)] =
+      (modelConfig \ "forced_decoder_ids").extract[Array[Array[Int]]].map {
+        case idxWithTokenId: Array[Int] if idxWithTokenId.length == 2 =>
+          (idxWithTokenId(0), idxWithTokenId(1))
+        case _ =>
+          throw new Exception(
+            "Could not extract forced_decoder_ids. Should be a list of tuples with 2 entries.")
+      }
+
+    def arrayOrNone[T](array: Array[T]): Option[Array[T]] =
+      if (array.nonEmpty) Some(array) else None
+
+    val bosTokenId = (generationConfigJson \ "bos_token_id").extract[Int]
+    val eosTokenId = (generationConfigJson \ "eos_token_id").extract[Int]
+    val padTokenId = (generationConfigJson \ "pad_token_id").extract[Int]
+    val vocabSize = (modelConfig \ "text_config" \ "vocab_size").extract[Int]
+
+    val imageToken = (modelConfig \ "image_token_index").extract[Int]
+    val imageTokenLength = (modelConfig \ "image_seq_length").extract[Int]
+
+    // Check if tokenizer.json exists
+    val tokenizerPath = s"$localModelPath/assets/tokenizer.json"
+    val tokenizerExists = new java.io.File(tokenizerPath).exists()
+    val (vocabs, addedTokens, bytePairs) = if (tokenizerExists) {
+      val tokenizerConfig: JValue = parse(loadJsonStringAsset(localModelPath, "tokenizer.json"))
+      // extract vocab from tokenizer.json ( model -> vocab)
+      var vocabs: Map[String, Int] =
+        (tokenizerConfig \ "model" \ "vocab").extract[Map[String, Int]]
+
+      // extract merges from tokenizer.json ( model -> merges)
+      val bytePairs = (tokenizerConfig \ "model" \ "merges")
+        .extract[List[Array[String]]]
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+
+      // extract added_tokens from tokenizer.json (added_tokens)
+      // "added_tokens": [
+      //    {
+      //      "id": 128000,
+      //      "content": "<|begin_of_text|>",
+      //      "single_word": false,
+      //      "lstrip": false,
+      //      "rstrip": false,
+      //      "normalized": false,
+      //      "special": true
+      //    }, ...
+      //  ]
+      val addedTokens = (tokenizerConfig \ "added_tokens")
+        .extract[List[Map[String, Any]]]
+        .map { token =>
+          val id = token("id").asInstanceOf[BigInt].intValue()
+          val content = token("content").asInstanceOf[String]
+          (content, id)
+        }
+        .toMap
+
+      // update vocab with added tokens
+      addedTokens.foreach { case (content, id) =>
+        vocabs += (content -> id)
+      }
+      (vocabs, addedTokens, bytePairs)
+    } else {
+      val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+      val addedTokens = loadTextAsset(localModelPath, "added_tokens.txt").zipWithIndex.toMap
+      val bytePairs = loadTextAsset(localModelPath, "merges.txt")
+        .map(_.split(" "))
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+      (vocabs, addedTokens, bytePairs)
+    }
+
+    val annotatorModel = new LLAVAForMultiModal()
+      .setGenerationConfig(
+        GenerationConfig(
+          bosTokenId,
+          padTokenId,
+          eosTokenId,
+          vocabSize,
+          arrayOrNone(beginSuppressTokens),
+          arrayOrNone(suppressTokenIds),
+          arrayOrNone(forcedDecoderIds)))
+      .setVocabulary(vocabs)
+      .setMerges(bytePairs)
+      .setAddedTokens(addedTokens)
+      .setImageToken(imageToken)
+      .setImageTokenLength(imageTokenLength)
+      .setSize(preprocessorConfig.size)
+      .setImageMean(preprocessorConfig.image_mean)
+      .setImageStd(preprocessorConfig.image_std)
+      .setResample(preprocessorConfig.resample)
+
+    val modelEngine =
+      if (useOpenvino)
+        Openvino.name
+      else
+        detectedEngine
+    annotatorModel.set(annotatorModel.engine, modelEngine)
+
+    detectedEngine match {
+      case Openvino.name =>
+        val visionWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_vision_embeddings_model")
+        val textWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_text_embeddings_model")
+        val mergeWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_merge_model")
+        val languageModelWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_language_model")
+
+        val openvinoWrapper = LLAVAWrappers(
+          languageModel = languageModelWrapper,
+          visionEmbeddingsModel = visionWrapper,
+          textEmbeddingsModel = textWrapper,
+          mergeModel = mergeWrapper)
+        annotatorModel.setModelIfNotSet(spark, preprocessorConfig, None, Some(openvinoWrapper))
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+}
+
+object LLAVAForMultiModal
+    extends ReadablePretrainedLLAVAForMultiModal
+    with ReadLLAVAForMultiModalDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodal.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodal.scala
new file mode 100644
index 00000000000000..b3ba4cee841098
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodal.scala
@@ -0,0 +1,648 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.ai.MLLama
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadJsonStringAsset,
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.ml.util.Openvino
+import com.johnsnowlabs.nlp.AnnotatorType.{DOCUMENT, IMAGE}
+import com.johnsnowlabs.nlp._
+import org.json4s.{DefaultFormats, JValue}
+import org.json4s.jackson.JsonMethods.parse
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.MLLamaWrappers
+import com.johnsnowlabs.nlp.serialization.{MapFeature, StructFeature}
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.{IntArrayParam, IntParam}
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** MLLamaForMultimodal can load LLAMA 3.2 Vision models for visual question answering. The model
+  * consists of a vision encoder, a text encoder as well as a text decoder. The vision encoder
+  * will encode the input image, the text encoder will encode the input question together with the
+  * encoding of the image, and the text decoder will output the answer to the question.
+  *
+  * The Llama 3.2-Vision collection of multimodal large language models (LLMs) is a collection of
+  * pretrained and instruction-tuned image reasoning generative models in 11B and 90B sizes (text
+  * + images in / text out). The Llama 3.2-Vision instruction-tuned models are optimized for
+  * visual recognition, image reasoning, captioning, and answering general questions about an
+  * image. The models outperform many of the available open source and closed multimodal models on
+  * common industry benchmarks.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val visualQA = MLLamaForMultimodal.pretrained()
+  *   .setInputCols("image_assembler")
+  *   .setOutputCol("answer")
+  * }}}
+  * The default model is `"llama_3_2_11b_vision_instruct_int4"`, if no name is provided.
+  *
+  * For available pretrained models please see the
+  * [[https://sparknlp.org/models?task=Question+Answering Models Hub]].
+  *
+  * Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. To
+  * see which models are compatible and how to import them see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/discussions/5669]] and to see more extended
+  * examples, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodalTest.scala]].
+  *
+  * ==Example==
+  * {{{
+  * import spark.implicits._
+  * import com.johnsnowlabs.nlp.base._
+  * import com.johnsnowlabs.nlp.annotator._
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val imageDF: DataFrame = ResourceHelper.spark.read
+  *  .format("image")
+  *  .option("dropInvalid", value = true)
+  *  .load(imageFolder)
+  *
+  * val testDF: DataFrame = imageDF.withColumn("text", lit("<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"))
+  *
+  * val imageAssembler: ImageAssembler = new ImageAssembler()
+  *   .setInputCol("image")
+  *   .setOutputCol("image_assembler")
+  *
+  * val visualQAClassifier = MLLamaForMultimodal.pretrained()
+  *   .setInputCols("image_assembler")
+  *   .setOutputCol("answer")
+  *
+  * val pipeline = new Pipeline().setStages(Array(
+  *   imageAssembler,
+  *   visualQAClassifier
+  * ))
+  *
+  * val result = pipeline.fit(testDF).transform(testDF)
+  *
+  * result.select("image_assembler.origin", "answer.result").show(false)
+  * +--------------------------------------+------+
+  * |origin                                |result|
+  * +--------------------------------------+------+
+  * |[file:///content/images/cat_image.jpg]|[The unusual aspect of this picture is the presence of two cats lying on a pink couch]|
+  * +--------------------------------------+------+
+  * }}}
+  *
+  * @see
+  *   [[CLIPForZeroShotClassification]] for Zero Shot Image Classifier
+  * @see
+  *   [[https://sparknlp.org/docs/en/annotators Annotators Main Page]] for a list of transformer
+  *   based classifiers
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+
+class MLLamaForMultimodal(override val uid: String)
+    extends AnnotatorModel[MLLamaForMultimodal]
+    with HasBatchedAnnotateImage[MLLamaForMultimodal]
+    with HasImageFeatureProperties
+    with WriteOpenvinoModel
+    with HasGeneratorProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("MLLamaForMultimodal"))
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(IMAGE)
+  override val outputAnnotatorType: AnnotatorType = DOCUMENT
+
+  /** @group setParam */
+  def setRandomSeed(value: Int): MLLamaForMultimodal.this.type = {
+    if (randomSeed.isEmpty) {
+      this.randomSeed = Some(value)
+    }
+    this
+  }
+
+  /** A list of token ids which are ignored in the decoder's output (Default: `Array()`)
+    *
+    * @group param
+    */
+  var ignoreTokenIds = new IntArrayParam(
+    this,
+    "ignoreTokenIds",
+    "A list of token ids which are ignored in the decoder's output")
+
+  /** @group setParam */
+  def setIgnoreTokenIds(tokenIds: Array[Int]): MLLamaForMultimodal.this.type = {
+    set(ignoreTokenIds, tokenIds)
+  }
+
+  /** @group getParam */
+  def getIgnoreTokenIds: Array[Int] = $(ignoreTokenIds)
+
+  /** Vocabulary used to encode the words to ids with bpeTokenizer.encode
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** Holding merges.txt coming from RoBERTa model
+    *
+    * @group param
+    */
+  val merges: MapFeature[(String, String), Int] = new MapFeature(this, "merges").setProtected()
+
+  /** @group setParam */
+  def setMerges(value: Map[(String, String), Int]): this.type = set(merges, value)
+
+  /** Additional tokens to be added to the vocabulary
+    *
+    * @group param
+    */
+  val addedTokens: MapFeature[String, Int] = new MapFeature(this, "addedTokens").setProtected()
+
+  /** @group setParam */
+  def setAddedTokens(value: Map[String, Int]): this.type = set(addedTokens, value)
+
+  /** Stop tokens to terminate the generation
+    *
+    * @group param
+    */
+  override val stopTokenIds =
+    new IntArrayParam(this, "stopTokenIds", "Stop tokens to terminate the generation")
+
+  /** @group setParam */
+  override def setStopTokenIds(value: Array[Int]): this.type = {
+    set(stopTokenIds, value)
+  }
+
+  /** @group getParam */
+  override def getStopTokenIds: Array[Int] = $(stopTokenIds)
+
+  private var _model: Option[Broadcast[MLLama]] = None
+  val generationConfig: StructFeature[GenerationConfig] =
+    new StructFeature(this, "generationConfig").setProtected()
+
+  def setGenerationConfig(value: GenerationConfig): this.type =
+    set(generationConfig, value)
+
+  def getGenerationConfig: GenerationConfig = $$(generationConfig)
+
+  val imageToken =
+    new IntParam(this, "imageToken", "Token id for image embeddings")
+
+  /** @group setParam */
+  def setImageToken(value: Int): this.type = set(imageToken, value)
+
+  /** @group getParam */
+  def getImageToken: Int = $(imageToken)
+
+  val maxImageTiles =
+    new IntParam(this, "maxImageTiles", "Maximum number of image tiles")
+
+  /** @group setParam */
+  def setMaxImageTiles(value: Int): this.type = set(maxImageTiles, value)
+
+  /** @group getParam */
+  def getMaxImageTiles: Int = $(maxImageTiles)
+
+  val numVisionTokens =
+    new IntParam(this, "numVisionTokens", "Number of vision tokens")
+
+  /** @group setParam */
+  def setNumVisionTokens(value: Int): this.type = set(numVisionTokens, value)
+
+  /** @group getParam */
+  def getNumVisionTokens: Int = $(numVisionTokens)
+
+  val paddingConstant =
+    new IntParam(this, "paddingConstant", "Padding constant for the model. Default is 0")
+
+  /** @group setParam */
+  def setPaddingConstant(value: Int): this.type = set(paddingConstant, value)
+
+  /** @group getParam */
+  def getPaddingConstant: Int = $(paddingConstant)
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      preprocessor: Preprocessor,
+      onnxWrappers: Option[DecoderWrappers],
+      openvinoWrapper: Option[MLLamaWrappers]): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new MLLama(
+            onnxWrappers,
+            openvinoWrapper,
+            $$(merges),
+            $$(vocabulary),
+            $$(addedTokens),
+            preprocessor,
+            generationConfig = getGenerationConfig,
+            imageToken = getImageToken,
+            maxImageTiles = getMaxImageTiles,
+            numVisionTokens = getNumVisionTokens,
+            paddingConstant = getPaddingConstant)))
+    }
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: MLLama = _model.get.value
+
+  setDefault(
+    minOutputLength -> 0,
+    maxOutputLength -> 20,
+    doSample -> false,
+    temperature -> 0.6,
+    topK -> -1,
+    topP -> 0.9,
+    repetitionPenalty -> 1.0,
+    noRepeatNgramSize -> 3,
+    ignoreTokenIds -> Array(),
+    batchSize -> 1,
+    beamSize -> 1,
+    maxInputLength -> 4096,
+    stopTokenIds -> Array(128001, 128008, 128009),
+    imageToken -> 128256,
+    maxImageTiles -> 576,
+    numVisionTokens -> 1601,
+    paddingConstant -> 0)
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    */
+  override def batchAnnotate(
+      batchedAnnotations: Seq[Array[AnnotationImage]]): Seq[Seq[Annotation]] = {
+
+    batchedAnnotations
+      //      .filter { annotationImages =>
+      //        annotationImages.exists(_.text.nonEmpty)
+      //      }
+      .map { cleanAnnotationImages =>
+        val validImages = cleanAnnotationImages.filter(_.result.nonEmpty)
+        val questionAnnotations = extractInputAnnotation(validImages)
+
+        getModelIfNotSet.predict(
+          questionAnnotations,
+          validImages.toSeq,
+          batchSize = $(batchSize),
+          minOutputLength = $(minOutputLength),
+          maxOutputLength = $(maxOutputLength),
+          doSample = $(doSample),
+          temperature = $(temperature),
+          topK = $(topK),
+          topP = $(topP),
+          repetitionPenalty = $(repetitionPenalty),
+          noRepeatNgramSize = $(noRepeatNgramSize),
+          randomSeed = this.randomSeed,
+          ignoreTokenIds = $(ignoreTokenIds),
+          beamSize = $(beamSize),
+          maxInputLength = $(maxInputLength))
+      }
+  }
+
+  private def extractInputAnnotation(
+      annotationImages: Array[AnnotationImage]): Seq[Annotation] = {
+    val questions = annotationImages.map(annotationImage => {
+      val imageText =
+        if (annotationImage.text.nonEmpty) annotationImage.text
+        else
+          """<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n""" +
+            """\n<|image|>This is an image<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n""".stripMargin // default question
+      Annotation(imageText)
+    })
+
+    questions
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getEngine match {
+      case Openvino.name =>
+        val wrappers = getModelIfNotSet.openvinoWrapper
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq(
+            (
+              wrappers.get.languageModel,
+              "llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers.xml")),
+          MLLamaForMultimodal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.visionEmbeddingsModel, "openvino_vision_encoder.xml")),
+          MLLamaForMultimodal.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.reshapeModel, "openvino_reshape_model.xml")),
+          MLLamaForMultimodal.suffix)
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+}
+
+trait ReadablePretrainedMLLamaForMultimodal
+    extends ParamsAndFeaturesReadable[MLLamaForMultimodal]
+    with HasPretrained[MLLamaForMultimodal] {
+
+  override val defaultModelName: Some[String] = Some("llama_3_2_11b_vision_instruct_int4")
+
+  /** Java compliant-overrides */
+  override def pretrained(): MLLamaForMultimodal = super.pretrained()
+
+  override def pretrained(name: String): MLLamaForMultimodal =
+    super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): MLLamaForMultimodal =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): MLLamaForMultimodal =
+    super.pretrained(name, lang, remoteLoc)
+
+}
+
+trait ReadMLLamaForMultimodalDLModel extends ReadOpenvinoModel {
+  this: ParamsAndFeaturesReadable[MLLamaForMultimodal] =>
+  val suffix: String = "_mllama"
+  override val openvinoFile: String = "mllama_openvino"
+  def readModel(instance: MLLamaForMultimodal, path: String, spark: SparkSession): Unit = {
+    instance.getEngine match {
+      case Openvino.name =>
+        val languageModelWrappers =
+          readOpenvinoModels(
+            path,
+            spark,
+            Seq("llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers.xml"),
+            suffix)
+
+        val visionEmbeddingsModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_vision_encoder.xml"), suffix)
+
+        val reshapeModelWrapper =
+          readOpenvinoModels(path, spark, Seq("openvino_reshape_model.xml"), suffix)
+
+        val ovWrapper = MLLamaWrappers(
+          languageModel = languageModelWrappers(
+            "llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers.xml"),
+          visionEmbeddingsModel = visionEmbeddingsModelWrappers("openvino_vision_encoder.xml"),
+          reshapeModel = reshapeModelWrapper("openvino_reshape_model.xml"))
+        val preprocessor = Preprocessor(
+          do_normalize = true,
+          do_resize = true,
+          "LLAVAFeatureExtractor",
+          instance.getImageMean,
+          instance.getImageStd,
+          instance.getResample,
+          instance.getSize)
+        instance.setModelIfNotSet(spark, preprocessor, None, Some(ovWrapper))
+      case _ => {
+        throw new Exception(notSupportedEngineError)
+      }
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(
+      modelPath: String,
+      spark: SparkSession,
+      useOpenvino: Boolean = false): MLLamaForMultimodal = {
+    implicit val formats: DefaultFormats.type = DefaultFormats // for json4
+    val (localModelPath, detectedEngine) =
+      modelSanityCheck(
+        modelPath,
+        isDecoder = false,
+        custom = Some(
+          List(
+            "llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers",
+            "openvino_vision_encoder",
+            "openvino_reshape_model")))
+    val modelConfig: JValue =
+      parse(loadJsonStringAsset(localModelPath, "config.json"))
+    val preprocessorConfigJsonContent =
+      loadJsonStringAsset(localModelPath, "preprocessor_config.json")
+    val preprocessorConfig = Preprocessor.loadPreprocessorConfig(preprocessorConfigJsonContent)
+
+    val parsedPreprocessorConfig: JValue = parse(preprocessorConfigJsonContent)
+    val beginSuppressTokens: Array[Int] =
+      (modelConfig \ "begin_suppress_tokens").extract[Array[Int]]
+
+    val suppressTokenIds: Array[Int] =
+      (modelConfig \ "suppress_tokens").extract[Array[Int]]
+
+    val forcedDecoderIds: Array[(Int, Int)] =
+      (modelConfig \ "forced_decoder_ids").extract[Array[Array[Int]]].map {
+        case idxWithTokenId: Array[Int] if idxWithTokenId.length == 2 =>
+          (idxWithTokenId(0), idxWithTokenId(1))
+        case _ =>
+          throw new Exception(
+            "Could not extract forced_decoder_ids. Should be a list of tuples with 2 entries.")
+      }
+
+    val maxImageTiles = (parsedPreprocessorConfig \ "max_image_tiles").extract[Int]
+
+    def arrayOrNone[T](array: Array[T]): Option[Array[T]] =
+      if (array.nonEmpty) Some(array) else None
+
+    val generationConfig: JValue =
+      parse(loadJsonStringAsset(localModelPath, "generation_config.json"))
+    val bosTokenId = (generationConfig \ "bos_token_id").extract[Int]
+    val eosTokenIdArray = (generationConfig \ "eos_token_id").extract[Array[Int]]
+    val eosTokenId = eosTokenIdArray.head
+    val padTokenId = (generationConfig \ "pad_token_id").extract[Int]
+    val vocabSize = (modelConfig \ "text_config" \ "vocab_size").extract[Int]
+
+    val imageToken = (modelConfig \ "image_token_index").extract[Int]
+    val imageSize = (modelConfig \ "vision_config" \ "image_size").extract[Int]
+    val patchSize = (modelConfig \ "vision_config" \ "patch_size").extract[Int]
+
+    val numVisionTokens = Math
+      .pow(imageSize / patchSize, 2)
+      .toInt + 1
+
+//    val numVisionTokens = Math
+//      .pow(
+//        ((modelConfig \ "vision_config" \ "image_size")
+//          .extract[Int] / (modelConfig \ "vision_config" \ "patch_size").extract[Int]).toInt,
+//        2)
+//      .toInt + 1
+
+    // Check if tokenizer.json exists
+    val tokenizerPath = s"$localModelPath/assets/tokenizer.json"
+    val tokenizerExists = new java.io.File(tokenizerPath).exists()
+    val (vocabs, addedTokens, bytePairs) = if (tokenizerExists) {
+      val tokenizerConfig: JValue = parse(loadJsonStringAsset(localModelPath, "tokenizer.json"))
+      // extract vocab from tokenizer.json ( model -> vocab)
+      var vocabs: Map[String, Int] =
+        (tokenizerConfig \ "model" \ "vocab").extract[Map[String, Int]]
+
+      // extract merges from tokenizer.json ( model -> merges)
+      val bytePairs = (tokenizerConfig \ "model" \ "merges")
+        .extract[List[Array[String]]]
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+
+      // extract added_tokens from tokenizer.json (added_tokens)
+      // "added_tokens": [
+      //    {
+      //      "id": 128000,
+      //      "content": "<|begin_of_text|>",
+      //      "single_word": false,
+      //      "lstrip": false,
+      //      "rstrip": false,
+      //      "normalized": false,
+      //      "special": true
+      //    }, ...
+      //  ]
+      val addedTokens = (tokenizerConfig \ "added_tokens")
+        .extract[List[Map[String, Any]]]
+        .map { token =>
+          val id = token("id").asInstanceOf[BigInt].intValue()
+          val content = token("content").asInstanceOf[String]
+          (content, id)
+        }
+        .toMap
+
+      // update vocab with added tokens
+      addedTokens.foreach { case (content, id) =>
+        vocabs += (content -> id)
+      }
+      (vocabs, addedTokens, bytePairs)
+    } else {
+      val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+      val addedTokens = loadTextAsset(localModelPath, "added_tokens.txt").zipWithIndex.toMap
+      val bytePairs = loadTextAsset(localModelPath, "merges.txt")
+        .map(_.split(" "))
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+      (vocabs, addedTokens, bytePairs)
+    }
+//    val vocabSize = vocabs.size
+    val annotatorModel = new MLLamaForMultimodal()
+      .setGenerationConfig(
+        GenerationConfig(
+          bosTokenId,
+          padTokenId,
+          eosTokenId,
+          vocabSize,
+          arrayOrNone(beginSuppressTokens),
+          arrayOrNone(suppressTokenIds),
+          arrayOrNone(forcedDecoderIds)))
+      .setVocabulary(vocabs)
+      .setMerges(bytePairs)
+      .setAddedTokens(addedTokens)
+      .setImageToken(imageToken)
+      .setMaxImageTiles(maxImageTiles)
+      .setNumVisionTokens(numVisionTokens)
+      .setSize(preprocessorConfig.size)
+      .setImageMean(preprocessorConfig.image_mean)
+      .setImageStd(preprocessorConfig.image_std)
+      .setResample(preprocessorConfig.resample)
+
+    val modelEngine =
+      if (useOpenvino)
+        Openvino.name
+      else
+        detectedEngine
+    annotatorModel.set(annotatorModel.engine, modelEngine)
+
+    detectedEngine match {
+      case Openvino.name =>
+        val visionWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_vision_encoder")
+        val reshapeWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_reshape_model")
+        val languageModelWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "llm_int4_asym_r10_gs64_max_activation_variance_awq_scale_all_layers")
+
+        val openvinoWrapper = MLLamaWrappers(
+          languageModel = languageModelWrapper,
+          visionEmbeddingsModel = visionWrapper,
+          reshapeModel = reshapeWrapper)
+        annotatorModel.setModelIfNotSet(spark, preprocessorConfig, None, Some(openvinoWrapper))
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+}
+
+object MLLamaForMultimodal
+    extends ReadablePretrainedMLLamaForMultimodal
+    with ReadMLLamaForMultimodalDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3Vision.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3Vision.scala
new file mode 100644
index 00000000000000..eeb7cc0b0fb8c0
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3Vision.scala
@@ -0,0 +1,539 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.ai.Phi3V
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadJsonStringAsset,
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.ml.util.Openvino
+import com.johnsnowlabs.nlp.AnnotatorType.{DOCUMENT, IMAGE}
+import com.johnsnowlabs.nlp._
+import org.json4s.{DefaultFormats, JValue}
+import org.json4s.jackson.JsonMethods.parse
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.Phi3VWrappers
+import com.johnsnowlabs.nlp.serialization.{MapFeature, StructFeature}
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.IntArrayParam
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** Phi3Vision can load Phi3 Vision models for visual question answering. The model consists of a
+  * vision encoder, a text encoder as well as a text decoder. The vision encoder will encode the
+  * input image, the text encoder will encode the input question together with the encoding of the
+  * image, and the text decoder will output the answer to the question.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val visualQA = Phi3Vision.pretrained()
+  *   .setInputCols("image_assembler")
+  *   .setOutputCol("answer")
+  * }}}
+  * The default model is `"phi_3_vision_128k_instruct"`, if no name is provided.
+  *
+  * For available pretrained models please see the
+  * [[https://sparknlp.org/models?task=Question+Answering Models Hub]].
+  *
+  * Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. To
+  * see which models are compatible and how to import them see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/discussions/5669]] and to see more extended
+  * examples, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3VisionTest.scala]].
+  *
+  * ==Example==
+  * {{{
+  * import spark.implicits._
+  * import com.johnsnowlabs.nlp.base._
+  * import com.johnsnowlabs.nlp.annotator._
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val imageDF: DataFrame = ResourceHelper.spark.read
+  *  .format("image")
+  *  .option("dropInvalid", value = true)
+  *  .load(imageFolder)
+  *
+  * val testDF: DataFrame = imageDF.withColumn("text", lit("<|user|> \n <|image_1|> \nWhat is unusual on this picture? <|end|>\n <|assistant|>\n"))
+  *
+  * val imageAssembler: ImageAssembler = new ImageAssembler()
+  *   .setInputCol("image")
+  *   .setOutputCol("image_assembler")
+  *
+  * val visualQAClassifier = Phi3Vision.pretrained("phi_3_vision_128k_instruct","en")
+  *   .setInputCols("image_assembler")
+  *   .setOutputCol("answer")
+  *
+  * val pipeline = new Pipeline().setStages(Array(
+  *   imageAssembler,
+  *   visualQAClassifier
+  * ))
+  *
+  * val result = pipeline.fit(testDF).transform(testDF)
+  *
+  * result.select("image_assembler.origin", "answer.result").show(false)
+  * +--------------------------------------+------+
+  * |origin                                |result|
+  * +--------------------------------------+------+
+  * |[file:///content/images/cat_image.jpg]|[The unusual aspect of this picture is the presence of two cats lying on a pink couch]|
+  * +--------------------------------------+------+
+  * }}}
+  *
+  * @see
+  *   [[CLIPForZeroShotClassification]] for Zero Shot Image Classifier
+  * @see
+  *   [[https://sparknlp.org/docs/en/annotators Annotators Main Page]] for a list of transformer
+  *   based classifiers
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+
+class Phi3Vision(override val uid: String)
+    extends AnnotatorModel[Phi3Vision]
+    with HasBatchedAnnotateImage[Phi3Vision]
+    with HasImageFeatureProperties
+    with WriteOpenvinoModel
+    with HasGeneratorProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("Phi3Vision"))
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(IMAGE)
+  override val outputAnnotatorType: AnnotatorType = DOCUMENT
+
+  /** @group setParam */
+  def setRandomSeed(value: Int): Phi3Vision.this.type = {
+    if (randomSeed.isEmpty) {
+      this.randomSeed = Some(value)
+    }
+    this
+  }
+
+  /** A list of token ids which are ignored in the decoder's output (Default: `Array()`)
+    *
+    * @group param
+    */
+  var ignoreTokenIds = new IntArrayParam(
+    this,
+    "ignoreTokenIds",
+    "A list of token ids which are ignored in the decoder's output")
+
+  /** @group setParam */
+  def setIgnoreTokenIds(tokenIds: Array[Int]): Phi3Vision.this.type = {
+    set(ignoreTokenIds, tokenIds)
+  }
+
+  /** @group getParam */
+  def getIgnoreTokenIds: Array[Int] = $(ignoreTokenIds)
+
+  /** Vocabulary used to encode the words to ids with bpeTokenizer.encode
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** Holding merges.txt coming from RoBERTa model
+    *
+    * @group param
+    */
+  val merges: MapFeature[(String, String), Int] = new MapFeature(this, "merges").setProtected()
+
+  /** @group setParam */
+  def setMerges(value: Map[(String, String), Int]): this.type = set(merges, value)
+
+  /** Additional tokens to be added to the vocabulary
+    *
+    * @group param
+    */
+  val addedTokens: MapFeature[String, Int] = new MapFeature(this, "addedTokens").setProtected()
+
+  /** @group setParam */
+  def setAddedTokens(value: Map[String, Int]): this.type = set(addedTokens, value)
+
+  /** Stop tokens to terminate the generation
+    *
+    * @group param
+    */
+  override val stopTokenIds =
+    new IntArrayParam(this, "stopTokenIds", "Stop tokens to terminate the generation")
+
+  /** @group setParam */
+  override def setStopTokenIds(value: Array[Int]): this.type = {
+    set(stopTokenIds, value)
+  }
+
+  /** @group getParam */
+  override def getStopTokenIds: Array[Int] = $(stopTokenIds)
+
+  private var _model: Option[Broadcast[Phi3V]] = None
+  val generationConfig: StructFeature[GenerationConfig] =
+    new StructFeature(this, "generationConfig").setProtected()
+
+  def setGenerationConfig(value: GenerationConfig): this.type =
+    set(generationConfig, value)
+
+  def getGenerationConfig: GenerationConfig = $$(generationConfig)
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      onnxWrappers: Option[DecoderWrappers],
+      openvinoWrapper: Option[Phi3VWrappers]): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new Phi3V(
+            onnxWrappers,
+            openvinoWrapper,
+            $$(merges),
+            $$(vocabulary),
+            $$(addedTokens),
+            generationConfig = getGenerationConfig)))
+    }
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: Phi3V = _model.get.value
+
+  setDefault(
+    minOutputLength -> 0,
+    maxOutputLength -> 20,
+    doSample -> false,
+    temperature -> 0.6,
+    topK -> -1,
+    topP -> 0.9,
+    repetitionPenalty -> 1.0,
+    noRepeatNgramSize -> 3,
+    ignoreTokenIds -> Array(),
+    batchSize -> 1,
+    beamSize -> 1,
+    maxInputLength -> 4096,
+    stopTokenIds -> Array(128001))
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    */
+  override def batchAnnotate(
+      batchedAnnotations: Seq[Array[AnnotationImage]]): Seq[Seq[Annotation]] = {
+
+    batchedAnnotations
+//      .filter { annotationImages =>
+//        annotationImages.exists(_.text.nonEmpty)
+//      }
+      .map { cleanAnnotationImages =>
+        val validImages = cleanAnnotationImages.filter(_.result.nonEmpty)
+        val questionAnnotations = extractInputAnnotation(validImages)
+
+        getModelIfNotSet.predict(
+          questionAnnotations,
+          validImages.toSeq,
+          batchSize = $(batchSize),
+          minOutputLength = $(minOutputLength),
+          maxOutputLength = $(maxOutputLength),
+          doSample = $(doSample),
+          temperature = $(temperature),
+          topK = $(topK),
+          topP = $(topP),
+          repetitionPenalty = $(repetitionPenalty),
+          noRepeatNgramSize = $(noRepeatNgramSize),
+          randomSeed = this.randomSeed,
+          ignoreTokenIds = $(ignoreTokenIds),
+          beamSize = $(beamSize),
+          maxInputLength = $(maxInputLength))
+      }
+  }
+
+  private def extractInputAnnotation(
+      annotationImages: Array[AnnotationImage]): Seq[Annotation] = {
+    val questions = annotationImages.map(annotationImage => {
+      val imageText =
+        if (annotationImage.text.nonEmpty) annotationImage.text
+        else
+          "<|user|> \n <|image_1|> This is an image\n <|end|>\n <|assistant|>\n" // default question
+      Annotation(imageText)
+    })
+
+    questions
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getEngine match {
+      case Openvino.name =>
+        val wrappers = getModelIfNotSet.openvinoWrapper
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.reshape, "reshape_model.xml")),
+          Phi3Vision.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.wte, "wte_model.xml")),
+          Phi3Vision.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.languageModel, "language_model.xml")),
+          Phi3Vision.suffix)
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+}
+
+trait ReadablePretrainedPhi3Vision
+    extends ParamsAndFeaturesReadable[Phi3Vision]
+    with HasPretrained[Phi3Vision] {
+
+  override val defaultModelName: Some[String] = Some("phi_3_vision_128k_instruct")
+
+  /** Java compliant-overrides */
+  override def pretrained(): Phi3Vision = super.pretrained()
+
+  override def pretrained(name: String): Phi3Vision =
+    super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): Phi3Vision =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): Phi3Vision =
+    super.pretrained(name, lang, remoteLoc)
+
+}
+
+trait ReadPhi3VisionDLModel extends ReadOpenvinoModel {
+  this: ParamsAndFeaturesReadable[Phi3Vision] =>
+  val suffix: String = "_phi3v"
+  override val openvinoFile: String = "phi3v_openvino"
+  def readModel(instance: Phi3Vision, path: String, spark: SparkSession): Unit = {
+    instance.getEngine match {
+      case Openvino.name =>
+        val reshapeWrappers =
+          readOpenvinoModels(path, spark, Seq("reshape_model.xml"), suffix)
+        val wteWrappers =
+          readOpenvinoModels(path, spark, Seq("wte_model.xml"), suffix)
+
+        val languageModelWrappers =
+          readOpenvinoModels(path, spark, Seq("language_model.xml"), suffix)
+
+        val ovWrapper = Phi3VWrappers(
+          wte = wteWrappers("wte_model.xml"),
+          languageModel = languageModelWrappers("language_model.xml"),
+          reshape = reshapeWrappers("reshape_model.xml"))
+        instance.setModelIfNotSet(spark, None, Some(ovWrapper))
+      case _ => {
+        throw new Exception(notSupportedEngineError)
+      }
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(
+      modelPath: String,
+      spark: SparkSession,
+      useOpenvino: Boolean = false): Phi3Vision = {
+    implicit val formats: DefaultFormats.type = DefaultFormats // for json4
+    val (localModelPath, detectedEngine) =
+      modelSanityCheck(
+        modelPath,
+        isDecoder = false,
+        custom = Some(List("reshape_model", "wte_model", "language_model")))
+    val modelConfig: JValue =
+      parse(loadJsonStringAsset(localModelPath, "config.json"))
+
+    val beginSuppressTokens: Array[Int] =
+      (modelConfig \ "begin_suppress_tokens").extract[Array[Int]]
+
+    val suppressTokenIds: Array[Int] =
+      (modelConfig \ "suppress_tokens").extract[Array[Int]]
+
+    val forcedDecoderIds: Array[(Int, Int)] =
+      (modelConfig \ "forced_decoder_ids").extract[Array[Array[Int]]].map {
+        case idxWithTokenId: Array[Int] if idxWithTokenId.length == 2 =>
+          (idxWithTokenId(0), idxWithTokenId(1))
+        case _ =>
+          throw new Exception(
+            "Could not extract forced_decoder_ids. Should be a list of tuples with 2 entries.")
+      }
+
+    def arrayOrNone[T](array: Array[T]): Option[Array[T]] =
+      if (array.nonEmpty) Some(array) else None
+
+    val bosTokenId = (modelConfig \ "bos_token_id").extract[Int]
+    val eosTokenId = (modelConfig \ "eos_token_id").extract[Int]
+    val padTokenId = (modelConfig \ "eos_token_id").extract[Int]
+    val vocabSize = (modelConfig \ "vocab_size").extract[Int]
+
+    // Check if tokenizer.json exists
+    val tokenizerPath = s"$localModelPath/assets/tokenizer.json"
+    val tokenizerExists = new java.io.File(tokenizerPath).exists()
+    val (vocabs, addedTokens, bytePairs) = if (tokenizerExists) {
+      val tokenizerConfig: JValue = parse(loadJsonStringAsset(localModelPath, "tokenizer.json"))
+      // extract vocab from tokenizer.json ( model -> vocab)
+      var vocabs: Map[String, Int] =
+        (tokenizerConfig \ "model" \ "vocab").extract[Map[String, Int]]
+
+      // extract merges from tokenizer.json ( model -> merges)
+      val bytePairs = (tokenizerConfig \ "model" \ "merges")
+        .extract[List[String]]
+        .map(_.split(" "))
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+
+      // extract added_tokens from tokenizer.json (added_tokens)
+      // "added_tokens": [
+      //    {
+      //      "id": 128000,
+      //      "content": "<|begin_of_text|>",
+      //      "single_word": false,
+      //      "lstrip": false,
+      //      "rstrip": false,
+      //      "normalized": false,
+      //      "special": true
+      //    }, ...
+      //  ]
+      val addedTokens = (tokenizerConfig \ "added_tokens")
+        .extract[List[Map[String, Any]]]
+        .map { token =>
+          val id = token("id").asInstanceOf[BigInt].intValue()
+          val content = token("content").asInstanceOf[String]
+          (content, id)
+        }
+        .toMap
+
+      // update vocab with added tokens
+      addedTokens.foreach { case (content, id) =>
+        vocabs += (content -> id)
+      }
+      (vocabs, addedTokens, bytePairs)
+    } else {
+      val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+      val addedTokens = loadTextAsset(localModelPath, "added_tokens.txt").zipWithIndex.toMap
+      val bytePairs = loadTextAsset(localModelPath, "merges.txt")
+        .map(_.split(" "))
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+      (vocabs, addedTokens, bytePairs)
+    }
+
+    val annotatorModel = new Phi3Vision()
+      .setGenerationConfig(
+        GenerationConfig(
+          bosTokenId,
+          padTokenId,
+          eosTokenId,
+          vocabSize,
+          arrayOrNone(beginSuppressTokens),
+          arrayOrNone(suppressTokenIds),
+          arrayOrNone(forcedDecoderIds)))
+      .setVocabulary(vocabs)
+      .setMerges(bytePairs)
+      .setAddedTokens(addedTokens)
+
+    val modelEngine =
+      if (useOpenvino)
+        Openvino.name
+      else
+        detectedEngine
+    annotatorModel.set(annotatorModel.engine, modelEngine)
+
+    detectedEngine match {
+      case Openvino.name =>
+        val reshapeWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "reshape_model")
+        val wteWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "wte_model")
+        val languageModelWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "language_model")
+        val openvinoWrapper = Phi3VWrappers(
+          wte = wteWrappers,
+          languageModel = languageModelWrappers,
+          reshape = reshapeWrappers)
+        annotatorModel.setModelIfNotSet(spark, None, Some(openvinoWrapper))
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+}
+
+object Phi3Vision extends ReadablePretrainedPhi3Vision with ReadPhi3VisionDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformer.scala
new file mode 100644
index 00000000000000..32c820ac684996
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformer.scala
@@ -0,0 +1,686 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.ai.Qwen2VL
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadJsonStringAsset,
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.ml.util.Openvino
+import com.johnsnowlabs.nlp.annotators.cv.feature_extractor.Preprocessor
+import com.johnsnowlabs.nlp.AnnotatorType.{DOCUMENT, IMAGE}
+import com.johnsnowlabs.nlp._
+import org.json4s.{DefaultFormats, JValue}
+import org.json4s.jackson.JsonMethods.parse
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.openvino.OpenvinoWrapper.Qwen2VLWrappers
+import com.johnsnowlabs.nlp.serialization.{MapFeature, StructFeature}
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param.{IntArrayParam, IntParam}
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** Qwen2VLTransformer can load Qwen2 Vision-Language models for visual question answering and
+  * multimodal instruction following. The model consists of a vision encoder, a text encoder, and
+  * a text decoder. The vision encoder processes the input image, the text encoder integrates the
+  * encoding of the image with the input text, and the text decoder outputs the response to the
+  * query or instruction.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val visualQA = Qwen2VLTransformer.pretrained()
+  *   .setInputCols("image_assembler")
+  *   .setOutputCol("answer")
+  * }}}
+  * The default model is `"qwen2_vl_2b_instruct_int4"`, if no name is provided.
+  *
+  * For available pretrained models, please see the
+  * [[https://sparknlp.org/models?task=Question+Answering Models Hub]].
+  *
+  * Models from the HuggingFace 🤗 Transformers library are also compatible with Spark NLP 🚀. To
+  * see which models are compatible and how to import them, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/discussions/5669]]. To explore more extended
+  * examples, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformerTest.scala]].
+  *
+  * ==Example==
+  * {{{
+  * import spark.implicits._
+  * import com.johnsnowlabs.nlp.base._
+  * import com.johnsnowlabs.nlp.annotator._
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val imageDF: DataFrame = ResourceHelper.spark.read
+  *   .format("image")
+  *   .option("dropInvalid", value = true)
+  *   .load(imageFolder)
+  *
+  * val testDF: DataFrame = imageDF.withColumn("text", lit("<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n"))
+  *
+  * val imageAssembler: ImageAssembler = new ImageAssembler()
+  *   .setInputCol("image")
+  *   .setOutputCol("image_assembler")
+  *
+  * val visualQAClassifier = Qwen2VLTransformer.pretrained()
+  *   .setInputCols("image_assembler")
+  *   .setOutputCol("answer")
+  *
+  * val pipeline = new Pipeline().setStages(Array(
+  *   imageAssembler,
+  *   visualQAClassifier
+  * ))
+  *
+  * val result = pipeline.fit(testDF).transform(testDF)
+  *
+  * result.select("image_assembler.origin", "answer.result").show(false)
+  * +--------------------------------------+------+
+  * |origin                                |result|
+  * +--------------------------------------+------+
+  * |[file:///content/images/cat_image.jpg]|[This image is unusual because it features two cats lying on a pink couch.]|
+  * +--------------------------------------+------+
+  * }}}
+  *
+  * @see
+  *   [[https://sparknlp.org/docs/en/annotators Annotators Main Page]] for a list of transformer-
+  *   based classifiers
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+class Qwen2VLTransformer(override val uid: String)
+    extends AnnotatorModel[Qwen2VLTransformer]
+    with HasBatchedAnnotateImage[Qwen2VLTransformer]
+    with HasImageFeatureProperties
+    with WriteOpenvinoModel
+    with HasGeneratorProperties
+    with HasEngine {
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("Qwen2VLTransformer"))
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(IMAGE)
+  override val outputAnnotatorType: AnnotatorType = DOCUMENT
+
+  /** @group setParam */
+  def setRandomSeed(value: Int): Qwen2VLTransformer.this.type = {
+    if (randomSeed.isEmpty) {
+      this.randomSeed = Some(value)
+    }
+    this
+  }
+
+  /** A list of token ids which are ignored in the decoder's output (Default: `Array()`)
+    *
+    * @group param
+    */
+  var ignoreTokenIds = new IntArrayParam(
+    this,
+    "ignoreTokenIds",
+    "A list of token ids which are ignored in the decoder's output")
+
+  /** @group setParam */
+  def setIgnoreTokenIds(tokenIds: Array[Int]): Qwen2VLTransformer.this.type = {
+    set(ignoreTokenIds, tokenIds)
+  }
+
+  /** @group getParam */
+  def getIgnoreTokenIds: Array[Int] = $(ignoreTokenIds)
+
+  /** Vocabulary used to encode the words to ids with bpeTokenizer.encode
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** Holding merges.txt coming from RoBERTa model
+    *
+    * @group param
+    */
+  val merges: MapFeature[(String, String), Int] = new MapFeature(this, "merges").setProtected()
+
+  /** @group setParam */
+  def setMerges(value: Map[(String, String), Int]): this.type = set(merges, value)
+
+  /** Additional tokens to be added to the vocabulary
+    *
+    * @group param
+    */
+  val addedTokens: MapFeature[String, Int] = new MapFeature(this, "addedTokens").setProtected()
+
+  /** @group setParam */
+  def setAddedTokens(value: Map[String, Int]): this.type = set(addedTokens, value)
+
+  /** Stop tokens to terminate the generation
+    *
+    * @group param
+    */
+  override val stopTokenIds =
+    new IntArrayParam(this, "stopTokenIds", "Stop tokens to terminate the generation")
+
+  /** @group setParam */
+  override def setStopTokenIds(value: Array[Int]): this.type = {
+    set(stopTokenIds, value)
+  }
+
+  /** @group getParam */
+  override def getStopTokenIds: Array[Int] = $(stopTokenIds)
+
+  /** max pixel values for image normalization
+    *
+    * @group param
+    */
+  val maxPixelValue =
+    new IntParam(this, "maxPixelValue", "max pixel values for image normalization")
+
+  /** @group setParam */
+  def setMaxPixelValue(value: Int): this.type = {
+    set(maxPixelValue, value)
+  }
+
+  /** @group getParam */
+  def getMaxPixelValue: Int = $(maxPixelValue)
+
+  /** min pixel values for image normalization
+    *
+    * @group param
+    */
+  val minPixelValue =
+    new IntParam(this, "minPixelValue", "min pixel values for image normalization")
+
+  /** @group setParam */
+  def setMinPixelValue(value: Int): this.type = {
+    set(minPixelValue, value)
+  }
+
+  /** @group getParam */
+  def getMinPixelValue: Int = $(minPixelValue)
+
+  private var _model: Option[Broadcast[Qwen2VL]] = None
+  val generationConfig: StructFeature[GenerationConfig] =
+    new StructFeature(this, "generationConfig").setProtected()
+
+  def setGenerationConfig(value: GenerationConfig): this.type =
+    set(generationConfig, value)
+
+  def getGenerationConfig: GenerationConfig = $$(generationConfig)
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      preprocessor: Preprocessor,
+      onnxWrappers: Option[DecoderWrappers],
+      openvinoWrapper: Option[Qwen2VLWrappers]): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new Qwen2VL(
+            onnxWrappers,
+            openvinoWrapper,
+            $$(merges),
+            $$(vocabulary),
+            $$(addedTokens),
+            preprocessor = preprocessor,
+            generationConfig = getGenerationConfig,
+            minPixels = $(minPixelValue),
+            maxPixels = $(maxPixelValue))))
+    }
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: Qwen2VL = _model.get.value
+
+  setDefault(
+    minOutputLength -> 0,
+    maxOutputLength -> 20,
+    doSample -> false,
+    temperature -> 0.6,
+    topK -> -1,
+    topP -> 0.9,
+    repetitionPenalty -> 1.0,
+    noRepeatNgramSize -> 3,
+    ignoreTokenIds -> Array(),
+    batchSize -> 1,
+    beamSize -> 1,
+    maxInputLength -> 4096,
+    stopTokenIds -> Array(128001),
+    maxPixelValue -> 16384 * 28 * 28,
+    minPixelValue -> 256 * 28 * 28)
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    */
+  override def batchAnnotate(
+      batchedAnnotations: Seq[Array[AnnotationImage]]): Seq[Seq[Annotation]] = {
+
+    batchedAnnotations
+//      .filter { annotationImages =>
+//        annotationImages.exists(_.text.nonEmpty)
+//      }
+      .map { cleanAnnotationImages =>
+        val validImages = cleanAnnotationImages.filter(_.result.nonEmpty)
+        val questionAnnotations = extractInputAnnotation(validImages)
+
+        getModelIfNotSet.predict(
+          questionAnnotations,
+          validImages.toSeq,
+          batchSize = $(batchSize),
+          minOutputLength = $(minOutputLength),
+          maxOutputLength = $(maxOutputLength),
+          doSample = $(doSample),
+          temperature = $(temperature),
+          topK = $(topK),
+          topP = $(topP),
+          repetitionPenalty = $(repetitionPenalty),
+          noRepeatNgramSize = $(noRepeatNgramSize),
+          randomSeed = this.randomSeed,
+          ignoreTokenIds = $(ignoreTokenIds),
+          beamSize = $(beamSize),
+          maxInputLength = $(maxInputLength))
+      }
+  }
+
+  private def extractInputAnnotation(
+      annotationImages: Array[AnnotationImage]): Seq[Annotation] = {
+    val questions = annotationImages.map(annotationImage => {
+      val imageText =
+        if (annotationImage.text.nonEmpty) annotationImage.text
+        else
+          "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n" // default question
+      Annotation(imageText)
+    })
+
+    questions
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getEngine match {
+      case Openvino.name =>
+        val wrappers = getModelIfNotSet.openvinoWrapper
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.patchReshapeModel, "openvino_patch_reshape_model.xml")),
+          Qwen2VLTransformer.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.languageModel, "openvino_language_model.xml")),
+          Qwen2VLTransformer.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.imageEmbedding, "openvino_vision_embeddings_model.xml")),
+          Qwen2VLTransformer.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.imageEmbeddingMerger, "openvino_vision_embeddings_merger_model.xml")),
+          Qwen2VLTransformer.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.textEmbedding, "openvino_text_embeddings_model.xml")),
+          Qwen2VLTransformer.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.multimodalMergeModel, "openvino_multimodal_merge_model.xml")),
+          Qwen2VLTransformer.suffix)
+
+        writeOpenvinoModels(
+          path,
+          spark,
+          Seq((wrappers.get.rotaryEmbedding, "openvino_rotary_embeddings_model.xml")),
+          Qwen2VLTransformer.suffix)
+
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+}
+
+trait ReadablePretrainedQwen2VLTransformer
+    extends ParamsAndFeaturesReadable[Qwen2VLTransformer]
+    with HasPretrained[Qwen2VLTransformer] {
+
+  override val defaultModelName: Some[String] = Some("qwen2_vl_2b_instruct_int4")
+
+  /** Java compliant-overrides */
+  override def pretrained(): Qwen2VLTransformer = super.pretrained()
+
+  override def pretrained(name: String): Qwen2VLTransformer =
+    super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): Qwen2VLTransformer =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): Qwen2VLTransformer =
+    super.pretrained(name, lang, remoteLoc)
+
+}
+
+trait ReadQwen2VLTransformerDLModel extends ReadOpenvinoModel {
+  this: ParamsAndFeaturesReadable[Qwen2VLTransformer] =>
+  val suffix: String = "_qwen2vl"
+  override val openvinoFile: String = "qwen2vl_openvino"
+  def readModel(instance: Qwen2VLTransformer, path: String, spark: SparkSession): Unit = {
+    instance.getEngine match {
+      // LANGUAGE_MODEL_NAME = "openvino_language_model.xml"
+      // IMAGE_EMBEDDING_NAME = "openvino_vision_embeddings_model.xml"
+      // IMAGE_EMBEDDING_MERGER_NAME = "openvino_vision_embeddings_merger_model.xml"
+      // TEXT_EMBEDDING_NAME = "openvino_text_embeddings_model.xml"
+      // ROTARY_EMBEDDING_NAME = "openvino_rotary_embeddings_model.xml"
+      // PATCH_RESHAPE_NAME = "openvino_patch_reshape_model.xml"
+      case Openvino.name =>
+        val languageModelWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_language_model.xml"), suffix)
+        val imageEmbeddingWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_vision_embeddings_model.xml"), suffix)
+        val imageEmbeddingMergerWrappers =
+          readOpenvinoModels(
+            path,
+            spark,
+            Seq("openvino_vision_embeddings_merger_model.xml"),
+            suffix)
+        val textEmbeddingWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_text_embeddings_model.xml"), suffix)
+        val rotaryEmbeddingWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_rotary_embeddings_model.xml"), suffix)
+        val patchReshapeWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_patch_reshape_model.xml"), suffix)
+        val multiModalMergeWrappers =
+          readOpenvinoModels(path, spark, Seq("openvino_multimodal_merge_model.xml"), suffix)
+        val ovWrapper = Qwen2VLWrappers(
+          imageEmbedding = imageEmbeddingWrappers("openvino_vision_embeddings_model.xml"),
+          imageEmbeddingMerger =
+            imageEmbeddingMergerWrappers("openvino_vision_embeddings_merger_model.xml"),
+          languageModel = languageModelWrappers("openvino_language_model.xml"),
+          textEmbedding = textEmbeddingWrappers("openvino_text_embeddings_model.xml"),
+          rotaryEmbedding = rotaryEmbeddingWrappers("openvino_rotary_embeddings_model.xml"),
+          patchReshapeModel = patchReshapeWrappers("openvino_patch_reshape_model.xml"),
+          multimodalMergeModel = multiModalMergeWrappers("openvino_multimodal_merge_model.xml"))
+        val preprocessor = Preprocessor(
+          do_normalize = true,
+          do_resize = true,
+          "Qwen2VLFeatureExtractor",
+          instance.getImageMean,
+          instance.getImageStd,
+          instance.getResample,
+          instance.getSize)
+        instance.setModelIfNotSet(spark, preprocessor, None, Some(ovWrapper))
+      case _ => {
+        throw new Exception(notSupportedEngineError)
+      }
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(
+      modelPath: String,
+      spark: SparkSession,
+      useOpenvino: Boolean = false): Qwen2VLTransformer = {
+    implicit val formats: DefaultFormats.type = DefaultFormats // for json4
+    val (localModelPath, detectedEngine) =
+      modelSanityCheck(
+        modelPath,
+        isDecoder = false,
+        custom = Some(
+          List(
+            "openvino_text_embeddings_model",
+            "openvino_language_model",
+            "openvino_vision_embeddings_model",
+            "openvino_vision_embeddings_merger_model",
+            "openvino_rotary_embeddings_model",
+            "openvino_patch_reshape_model",
+            "openvino_multimodal_merge_model")))
+    val modelConfig: JValue =
+      parse(loadJsonStringAsset(localModelPath, "config.json"))
+    val preprocessorConfigJsonContent =
+      loadJsonStringAsset(localModelPath, "preprocessor_config.json")
+    val preprocessorConfig = Preprocessor.loadPreprocessorConfig(preprocessorConfigJsonContent)
+    val beginSuppressTokens: Array[Int] =
+      (modelConfig \ "begin_suppress_tokens").extract[Array[Int]]
+
+    val suppressTokenIds: Array[Int] =
+      (modelConfig \ "suppress_tokens").extract[Array[Int]]
+
+    val forcedDecoderIds: Array[(Int, Int)] =
+      (modelConfig \ "forced_decoder_ids").extract[Array[Array[Int]]].map {
+        case idxWithTokenId: Array[Int] if idxWithTokenId.length == 2 =>
+          (idxWithTokenId(0), idxWithTokenId(1))
+        case _ =>
+          throw new Exception(
+            "Could not extract forced_decoder_ids. Should be a list of tuples with 2 entries.")
+      }
+
+    def arrayOrNone[T](array: Array[T]): Option[Array[T]] =
+      if (array.nonEmpty) Some(array) else None
+
+    val bosTokenId = (modelConfig \ "bos_token_id").extract[Int]
+    val eosTokenId = (modelConfig \ "eos_token_id").extract[Int]
+    val padTokenId = (modelConfig \ "eos_token_id").extract[Int]
+    val vocabSize = (modelConfig \ "vocab_size").extract[Int]
+
+    // Check if tokenizer.json exists
+    val tokenizerPath = s"$localModelPath/assets/tokenizer.json"
+    val tokenizerExists = new java.io.File(tokenizerPath).exists()
+    val (vocabs, addedTokens, bytePairs) = if (tokenizerExists) {
+      val tokenizerConfig: JValue = parse(loadJsonStringAsset(localModelPath, "tokenizer.json"))
+      // extract vocab from tokenizer.json ( model -> vocab)
+      var vocabs: Map[String, Int] =
+        (tokenizerConfig \ "model" \ "vocab").extract[Map[String, Int]]
+
+      // extract merges from tokenizer.json ( model -> merges)
+      val bytePairs = (tokenizerConfig \ "model" \ "merges")
+        .extract[List[Array[String]]]
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+
+      // extract added_tokens from tokenizer.json (added_tokens)
+      // "added_tokens": [
+      //    {
+      //      "id": 128000,
+      //      "content": "<|begin_of_text|>",
+      //      "single_word": false,
+      //      "lstrip": false,
+      //      "rstrip": false,
+      //      "normalized": false,
+      //      "special": true
+      //    }, ...
+      //  ]
+      val addedTokens = (tokenizerConfig \ "added_tokens")
+        .extract[List[Map[String, Any]]]
+        .map { token =>
+          val id = token("id").asInstanceOf[BigInt].intValue()
+          val content = token("content").asInstanceOf[String]
+          (content, id)
+        }
+        .toMap
+
+      // update vocab with added tokens
+      addedTokens.foreach { case (content, id) =>
+        vocabs += (content -> id)
+      }
+      (vocabs, addedTokens, bytePairs)
+    } else {
+      val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+      val addedTokens = loadTextAsset(localModelPath, "added_tokens.txt").zipWithIndex.toMap
+      val bytePairs = loadTextAsset(localModelPath, "merges.txt")
+        .map(_.split(" "))
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+      (vocabs, addedTokens, bytePairs)
+    }
+
+    val annotatorModel = new Qwen2VLTransformer()
+      .setGenerationConfig(
+        GenerationConfig(
+          bosTokenId,
+          padTokenId,
+          eosTokenId,
+          vocabSize,
+          arrayOrNone(beginSuppressTokens),
+          arrayOrNone(suppressTokenIds),
+          arrayOrNone(forcedDecoderIds)))
+      .setVocabulary(vocabs)
+      .setMerges(bytePairs)
+      .setAddedTokens(addedTokens)
+      .setSize(preprocessorConfig.size)
+      .setImageMean(preprocessorConfig.image_mean)
+      .setImageStd(preprocessorConfig.image_std)
+      .setResample(preprocessorConfig.resample)
+
+    val modelEngine =
+      if (useOpenvino)
+        Openvino.name
+      else
+        detectedEngine
+    annotatorModel.set(annotatorModel.engine, modelEngine)
+
+    detectedEngine match {
+      case Openvino.name =>
+        val patchReshapeWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_patch_reshape_model")
+
+        val languageModelWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_language_model")
+
+        val imageEmbeddingWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_vision_embeddings_model")
+
+        val imageEmbeddingMergerWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_vision_embeddings_merger_model")
+
+        val textEmbeddingWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_text_embeddings_model")
+
+        val rotaryEmbeddingWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_rotary_embeddings_model")
+
+        val multimodalMergerWrappers =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine,
+            modelName = "openvino_multimodal_merge_model")
+
+        val openvinoWrapper = Qwen2VLWrappers(
+          languageModel = languageModelWrappers,
+          imageEmbedding = imageEmbeddingWrappers,
+          imageEmbeddingMerger = imageEmbeddingMergerWrappers,
+          textEmbedding = textEmbeddingWrappers,
+          rotaryEmbedding = rotaryEmbeddingWrappers,
+          patchReshapeModel = patchReshapeWrappers,
+          multimodalMergeModel = multimodalMergerWrappers)
+        annotatorModel.setModelIfNotSet(spark, preprocessorConfig, None, Some(openvinoWrapper))
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+}
+
+object Qwen2VLTransformer
+    extends ReadablePretrainedQwen2VLTransformer
+    with ReadQwen2VLTransformerDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/feature_extractor/Preprocessor.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/feature_extractor/Preprocessor.scala
index f043f8450d1e69..41b448632d7807 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/feature_extractor/Preprocessor.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/feature_extractor/Preprocessor.scala
@@ -135,6 +135,9 @@ private[johnsnowlabs] object Preprocessor {
           // ConvNext case: Size of the output image after `resize` has been applied
           sizeMap("shortest_edge").toInt
         case sizeInt: BigInt => sizeInt.toInt
+        case sizeMap: Map[String, BigInt] if sizeMap.contains("max_pixels") =>
+          val max_pixels = sizeMap("max_pixels")
+          max_pixels.toInt
         case _ =>
           throw new IllegalArgumentException(
             "Unsupported format for size. Should either be int or dict with entries \'width\' and \'height\' or \'shortest_edge\'")
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/io/ImageIOUtils.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/io/ImageIOUtils.scala
index ca5be6ba37dfdb..2381147f07a4ce 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/io/ImageIOUtils.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/io/ImageIOUtils.scala
@@ -67,20 +67,18 @@ private[johnsnowlabs] object ImageIOUtils {
   def readImage(file: File): Option[BufferedImage] = {
     Try(ImageIO.read(file)) match {
       case Success(bufferedImage) => Some(bufferedImage)
-      case Failure(_) => {
+      case Failure(_) =>
         logger.warn(s"Error in ImageIOUtils.readImage while reading file: ${file.getPath}")
         None
-      }
     }
   }
 
   def readImage(inputStream: InputStream): Option[BufferedImage] = {
     Try(ImageIO.read(inputStream)) match {
       case Success(bufferedImage) => Some(bufferedImage)
-      case Failure(_) => {
+      case Failure(_) =>
         logger.warn(s"Error in ImageIOUtils.readImage while reading inputStream")
         None
-      }
     }
   }
 
@@ -203,4 +201,23 @@ private[johnsnowlabs] object ImageIOUtils {
 
   }
 
+  def arrayToBufferedImage(pixelArray: Array[Array[Array[Int]]]): BufferedImage = {
+    val height = pixelArray.length
+    val width = pixelArray.head.length
+    val image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
+
+    for (y <- pixelArray.indices; x <- pixelArray(y).indices) {
+      val rgb = pixelArray(y)(x) match {
+        case Array(r, g, b) => new Color(r, g, b).getRGB
+        case _ =>
+          throw new IllegalArgumentException(
+            "Each pixel must have exactly 3 color channels (RGB)")
+      }
+      image.setRGB(x, y, rgb)
+    }
+    image
+  }
+  def encodeImageBase64(image: Array[Byte]): String =
+    java.util.Base64.getEncoder.encodeToString(image)
+
 }
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/MllamaUtils.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/MllamaUtils.scala
new file mode 100644
index 00000000000000..f9e6710aa6d2d1
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/MllamaUtils.scala
@@ -0,0 +1,513 @@
+package com.johnsnowlabs.nlp.annotators.cv.util.transform
+
+import scala.collection.mutable.ListBuffer
+import java.awt.image.BufferedImage
+import scala.collection.mutable.ArrayBuffer
+import ImageResizeUtils.resizeBufferedImage
+
+object MllamaUtils {
+
+  /** Get all supported aspect ratios for a given max number of image tiles
+    *
+    * @param maxImageTiles
+    * @return
+    */
+  def getAllSupportedAspectRatios(maxImageTiles: Int): List[(Int, Int)] = {
+    val aspectRatios = ListBuffer[(Int, Int)]()
+    for (width <- 1 to maxImageTiles) {
+      for (height <- 1 to maxImageTiles) {
+        if (width * height <= maxImageTiles) {
+          aspectRatios += ((width, height))
+        }
+      }
+    }
+
+    aspectRatios.toList
+  }
+
+  /** Get the size of the image that fits the canvas
+    *
+    * @param imageHeight
+    * @param imageWidth
+    * @param canvasHeight
+    * @param canvasWidth
+    * @param tileSize
+    * @return
+    */
+  def getImageSizeFitToCanvas(
+      imageHeight: Int,
+      imageWidth: Int,
+      canvasHeight: Int,
+      canvasWidth: Int,
+      tileSize: Int): (Int, Int) = {
+    val targetWidth = math.max(math.min(imageWidth, canvasWidth), tileSize)
+    val targetHeight = math.max(math.min(imageHeight, canvasHeight), tileSize)
+
+    val scaleH = targetHeight.toDouble / imageHeight.toDouble
+    val scaleW = targetWidth.toDouble / imageWidth.toDouble
+
+    if (scaleW < scaleH) {
+      (math.min(math.floor(imageHeight * scaleW).toInt, targetHeight), targetWidth)
+    } else {
+      (targetHeight, math.min(math.floor(imageWidth * scaleH).toInt, targetWidth))
+    }
+  }
+
+  /** Get the optimal tiled canvas size for the image
+    *
+    * @param imageHeight
+    * @param imageWidth
+    * @param maxImageTiles
+    * @param tileSize
+    * @return
+    */
+  def getOptimalTiledCanvas(
+      imageHeight: Int,
+      imageWidth: Int,
+      maxImageTiles: Int,
+      tileSize: Int): (Int, Int) = {
+    val possibleTileArrangements = getAllSupportedAspectRatios(maxImageTiles)
+    val possibleCanvasSizes = possibleTileArrangements.map { case (w, h) =>
+      (w * tileSize, h * tileSize)
+    }
+
+    val targetHeights = possibleCanvasSizes.map(_._2)
+    val targetWidths = possibleCanvasSizes.map(_._1)
+
+    val scaleH = targetHeights.map(_.toDouble / imageHeight.toDouble)
+    val scaleW = targetWidths.map(_.toDouble / imageWidth.toDouble)
+
+    val scales = scaleH.zip(scaleW).map { case (h, w) => if (w > h) h else w }
+
+    val upScalingOptions = scales.filter(_ >= 1.0)
+    val selectedScale = if (upScalingOptions.nonEmpty) {
+      upScalingOptions.min
+    } else {
+      scales.filter(_ < 1.0).max
+    }
+
+    val chosenCanvas =
+      possibleCanvasSizes.zip(scales).filter { case (_, s) => s == selectedScale }.map {
+        case (size, _) => size
+      }
+
+    if (chosenCanvas.size > 1) {
+      chosenCanvas.minBy { case (w, h) => w * h }
+    } else {
+      chosenCanvas.head
+    }
+  }
+
+  /** Convert a crop of an image to a 3D array
+    *
+    * @param imgCrop
+    * @return
+    */
+  def imageCropToArray(imgCrop: BufferedImage): Array[Array[Array[Int]]] = {
+    val height = imgCrop.getHeight
+    val width = imgCrop.getWidth
+
+    // Create a 3D array for RGB channels
+    val channels = 3
+    val cropArray = Array.ofDim[Int](channels, height, width)
+
+    for (y <- 0 until height; x <- 0 until width) {
+      val color = new java.awt.Color(imgCrop.getRGB(x, y))
+      cropArray(0)(y)(x) = color.getRed // Red channel
+      cropArray(1)(y)(x) = color.getGreen // Green channel
+      cropArray(2)(y)(x) = color.getBlue // Blue channel
+    }
+
+    cropArray
+  }
+
+  /** Split an image into tiles
+    *
+    * @param image
+    * @param numTilesHeight
+    * @param numTilesWidth
+    * @return
+    */
+  def splitToTiles(
+      image: BufferedImage,
+      numTilesHeight: Int,
+      numTilesWidth: Int,
+      mean: Array[Double],
+      std: Array[Double],
+      doNormalize: Boolean,
+      doRescale: Boolean,
+      rescaleFactor: Double): Array[Array[Array[Array[Float]]]] = {
+    val cropHeight = image.getHeight / numTilesHeight
+    val cropWidth = image.getWidth / numTilesWidth
+
+    val cropsBuffer = ArrayBuffer[Array[Array[Array[Float]]]]()
+
+    for (i <- 0 until numTilesHeight) {
+      for (j <- 0 until numTilesWidth) {
+        // Extract a crop of the image
+        val imgCrop = image.getSubimage(j * cropHeight, i * cropWidth, cropHeight, cropWidth)
+        // Convert the crop to a 3D array (3, height, width)
+        val normalizedCrop = ImageResizeUtils.normalizeAndConvertBufferedImage(
+          img = imgCrop,
+          mean = mean,
+          std = std,
+          doNormalize = doNormalize,
+          doRescale = doRescale,
+          rescaleFactor = rescaleFactor)
+
+        cropsBuffer.append(normalizedCrop)
+      }
+    }
+    cropsBuffer.toArray
+  }
+
+  /** Convert a 3D array to a BufferedImage
+    *
+    * @param imageArray
+    * @return
+    */
+  def arrayToBufferedImage(imageArray: Array[Array[Array[Int]]]): BufferedImage = {
+    val height = imageArray(0).length
+    val width = imageArray(0)(0).length
+
+    val image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
+
+    for (y <- 0 until height; x <- 0 until width) {
+      val rgb = imageArray.map(_(y)(x)).map(_.toByte)
+      val color = new java.awt.Color(rgb(0), rgb(1), rgb(2))
+      image.setRGB(x, y, color.getRGB)
+    }
+
+    image
+  }
+
+  /** Convert a 3D array of floats to a BufferedImage
+    *
+    * @param imageArray
+    * @return
+    */
+  def floatArrayToBufferedImage(
+      imageArray: Array[Array[Array[Float]]],
+      rescaleFactor: Double): BufferedImage = {
+    val height = imageArray(0).length
+    val width = imageArray(0)(0).length
+
+    val image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
+
+    for (y <- 0 until height; x <- 0 until width) {
+      val rgb = imageArray.map(_(y)(x)).map { x => (x * (1 / rescaleFactor)).toInt }
+      val color = new java.awt.Color(rgb(0), rgb(1), rgb(2))
+      image.setRGB(x, y, color.getRGB)
+    }
+
+    image
+  }
+
+  /** Pack images into a 6D array
+    *
+    * @param batchImages
+    * @param maxImageTiles
+    * @return
+    */
+  def packImages(
+      batchImages: List[Array[Array[Array[Array[Array[Float]]]]]],
+      maxImageTiles: Int): (Array[Array[Array[Array[Array[Array[Float]]]]]], List[List[Int]]) = {
+    val batchSize = batchImages.size
+    val maxNumImages = batchImages.map(_.length).max
+    val channels = batchImages.head.head.head.length
+    val tileHeight = batchImages.head.head.head.head.length
+    val tileWidth = batchImages.head.head.head.head.head.length
+
+    // (batch_size, max_num_images, max_image_tiles, channels, tile_height, tile_width).
+    val stackedImages = ArrayBuffer[Array[Array[Array[Array[Array[Float]]]]]]()
+
+    val allNumTiles = ListBuffer.empty[List[Int]]
+
+    // go over each sample in the batch
+    for ((images, i) <- batchImages.zipWithIndex) {
+      val numSampleTiles = ListBuffer.empty[Int]
+      val tempStackedImages = ArrayBuffer[Array[Array[Array[Array[Float]]]]]()
+      // go over each image in the sample
+
+      for ((image, j) <- images.zipWithIndex) {
+        val tempStackedTiles = ArrayBuffer[Array[Array[Array[Float]]]]()
+        val numTiles = image.length
+        numSampleTiles += numTiles
+        for {
+          k <- 0 until numTiles
+        } {
+          tempStackedTiles.append(image(k))
+        }
+        // add padded images to the sample
+        for (_ <- 0 until maxImageTiles - image.length) {
+          tempStackedTiles.append(Array.ofDim[Float](channels, tileHeight, tileWidth))
+        }
+        tempStackedImages.append(tempStackedTiles.toArray)
+      }
+
+      // add padded images to the sample.
+      for (_ <- 0 until maxNumImages - images.length) {
+        val tempStackedTiles = ArrayBuffer[Array[Array[Array[Float]]]]()
+        for (_ <- 0 until maxImageTiles) {
+          tempStackedTiles.append(Array.ofDim[Float](channels, tileHeight, tileWidth))
+        }
+        tempStackedImages.append(tempStackedTiles.toArray)
+
+      }
+      stackedImages.append(tempStackedImages.toArray)
+      allNumTiles += numSampleTiles.toList
+    }
+
+    (stackedImages.toArray, allNumTiles.toList)
+  }
+
+  /** build aspect ratio mask
+    *
+    * @param aspectRatios
+    * @param maxImageTiles
+    * @return
+    */
+  def buildAspectRatioMask(
+      aspectRatios: List[List[(Int, Int)]],
+      maxImageTiles: Int): Array[Array[Array[Int]]] = {
+    val batchSize = aspectRatios.size
+    val maxNumImages = aspectRatios.map(_.size).max
+
+    // Initialize the 3D array with zeros
+    val aspectRatioMask = Array.ofDim[Int](batchSize, maxNumImages, maxImageTiles)
+
+    // Set the first tile to 1 for all aspect ratios
+    for {
+      i <- 0 until batchSize
+      j <- 0 until maxNumImages
+    } {
+      aspectRatioMask(i)(j)(0) = 1
+    }
+
+    // Set the aspect ratio mask for the rest of the tiles
+    for ((sampleAspectRatios, i) <- aspectRatios.zipWithIndex) {
+      for ((aspectRatio, j) <- sampleAspectRatios.zipWithIndex) {
+        val (numTilesW, numTilesH) = aspectRatio
+        val numTiles = numTilesW * numTilesH
+
+        for (k <- 0 until math.min(numTiles, maxImageTiles)) {
+          aspectRatioMask(i)(j)(k) = 1
+        }
+      }
+    }
+
+    aspectRatioMask
+  }
+
+  /** Pack aspect ratios into a 3D array
+    *
+    * @param aspectRatios
+    * @param padValue
+    * @return
+    */
+  def packAspectRatios(
+      aspectRatios: List[List[(Int, Int)]],
+      padValue: Int = 1): Array[Array[Array[Int]]] = {
+    val batchSize = aspectRatios.size
+    val maxNumImages = aspectRatios.map(_.size).max
+
+    val aspectRatiosStacked = Array.fill(batchSize, maxNumImages, 2)(padValue)
+
+    for ((row, i) <- aspectRatios.zipWithIndex) {
+      if (row.nonEmpty) {
+        for ((aspectRatio, j) <- row.zipWithIndex) {
+          aspectRatiosStacked(i)(j) = Array(aspectRatio._1, aspectRatio._2)
+        }
+      }
+    }
+
+    aspectRatiosStacked
+  }
+
+  /** Convert aspect ratios to IDs
+    *
+    * @param aspectRatios
+    * @param maxImageTiles
+    * @return
+    */
+  def convertAspectRatiosToIds(
+      aspectRatios: List[List[(Int, Int)]],
+      maxImageTiles: Int): Array[Array[Int]] = {
+    val batchSize = aspectRatios.size
+    val maxNumImages = aspectRatios.map(_.size).max
+    val supportedAspectRatios = getAllSupportedAspectRatios(maxImageTiles)
+
+    val aspectRatiosIds = Array.fill(batchSize, maxNumImages)(0) // Initialize with 0 for padding
+
+    for ((sampleAspectRatios, i) <- aspectRatios.zipWithIndex) {
+      for ((aspectRatio, j) <- sampleAspectRatios.zipWithIndex) {
+        aspectRatiosIds(i)(j) = supportedAspectRatios.indexOf(aspectRatio) + 1
+      }
+    }
+
+    aspectRatiosIds
+  }
+
+  /** Resize an image to fit the canvas
+    *
+    * @param width
+    * @param height
+    * @param resample
+    * @param maxImageTiles
+    * @param image
+    * @return
+    */
+  def resizeImage(width: Int, height: Int, resample: Int, maxImageTiles: Int)(
+      image: BufferedImage): (BufferedImage, (Int, Int)) = {
+    val imageHeight = image.getHeight
+    val imageWidth = image.getWidth
+
+    val (canvasHeight, canvasWidth) =
+      getOptimalTiledCanvas(imageHeight, imageWidth, maxImageTiles, height)
+
+    val numTilesHeight = canvasHeight / height
+    val numTilesWidth = canvasWidth / width
+
+    val (newHeight, newWidth) =
+      getImageSizeFitToCanvas(imageHeight, imageWidth, canvasHeight, canvasWidth, height)
+    (resizeBufferedImage(newWidth, newHeight, resample)(image), (numTilesHeight, numTilesWidth))
+  }
+
+  def padConstant(
+      image: Array[Array[Float]],
+      padding: Int,
+      constantValue: Float): Array[Array[Float]] = {
+    val rows = image.length
+    val cols = image(0).length
+
+    val paddedRows = rows + 2 * padding
+    val paddedCols = cols + 2 * padding
+
+    val paddedImage = Array.ofDim[Float](paddedRows, paddedCols)
+
+    for (i <- 0 until paddedRows) {
+      for (j <- 0 until paddedCols) {
+        if (i >= padding && i < rows + padding && j >= padding && j < cols + padding) {
+          paddedImage(i)(j) = image(i - padding)(j - padding)
+        } else {
+          paddedImage(i)(j) = constantValue
+        }
+      }
+    }
+
+    paddedImage
+  }
+
+  def padBufferedImage(
+      image: BufferedImage,
+      totalPadding: (Int, Int),
+      constantColor: Int): BufferedImage = {
+    val originalWidth = image.getWidth
+    val originalHeight = image.getHeight
+
+    val (totalPaddingHeight, totalPaddingWidth) = totalPadding
+
+    // Calculate padding on each side
+    val paddingWidthLeft = totalPaddingWidth
+    val paddingHeightTop = totalPaddingHeight
+
+    val paddedWidth = originalWidth + totalPaddingWidth
+    val paddedHeight = originalHeight + totalPaddingHeight
+
+    val paddedImage = new BufferedImage(paddedWidth, paddedHeight, image.getType)
+
+    val colorRGB = new java.awt.Color(0, 0, 0)
+
+    for (x <- 0 until paddedWidth; y <- 0 until paddedHeight) {
+      if (x < originalWidth
+        &&
+        y < originalHeight) {
+        paddedImage.setRGB(x, y, image.getRGB(x, y))
+      } else {
+        paddedImage.setRGB(x, y, colorRGB.getRGB)
+      }
+    }
+
+    paddedImage
+  }
+
+  def pad(
+      image: BufferedImage,
+      paddingConstant: Int,
+      aspectRatio: (Int, Int),
+      tileHeight: Int,
+      tileWidth: Int): BufferedImage = {
+    val originalWidth = image.getWidth
+    val originalHeight = image.getHeight
+
+    val numTilesHeight = aspectRatio._1
+    val numTilesWidth = aspectRatio._2
+
+    val paddedWidth = numTilesWidth * tileWidth
+    val paddedHeight = numTilesHeight * tileHeight
+
+    val paddingHeight = paddedHeight - originalHeight
+    val paddingWidth = paddedWidth - originalWidth
+
+    val paddedImage = padBufferedImage(image, (paddingHeight, paddingWidth), paddingConstant)
+    paddedImage
+  }
+
+  def getCrossAttentionTokenMask(inputIds: Array[Int], imageTokenId: Int): Array[Array[Int]] = {
+    val imageTokenLocations = inputIds.zipWithIndex.filter(_._1 == imageTokenId).map(_._2)
+
+    if (imageTokenLocations.isEmpty) {
+      Array.empty
+    } else if (imageTokenLocations.length == 1) {
+      Array(Array(imageTokenLocations(0), -1))
+    } else {
+      val visionMasks =
+        imageTokenLocations.sliding(2).map(pair => Array(pair(0), pair(1))).toArray
+      visionMasks.init.zip(visionMasks.tail).foreach { case (prev, curr) =>
+        if (prev(0) + 1 == curr(0)) {
+          prev(1) = curr(1)
+        }
+      }
+      visionMasks.last(0) = visionMasks.last(0)
+      visionMasks.last(1) = inputIds.length
+      visionMasks
+    }
+  }
+
+  def convertSparseCrossAttentionMaskToDense(
+      crossAttentionTokenMask: Array[Array[Array[Int]]],
+      numTiles: Array[Array[Int]],
+      maxNumTiles: Int,
+      length: Int): Array[Array[Array[Array[Int]]]] = {
+    val batchSize = crossAttentionTokenMask.length
+    val maxNumImages = crossAttentionTokenMask.map(_.length).max
+
+    // Initialize the 4D array with zeros
+    val crossAttentionMask = Array.ofDim[Int](batchSize, length, maxNumImages, maxNumTiles)
+
+    for (sampleIdx <- crossAttentionTokenMask.indices) {
+      val sampleMasks = crossAttentionTokenMask(sampleIdx)
+      val sampleNumTiles = numTiles(sampleIdx)
+
+      for (maskIdx <- sampleMasks.indices) {
+        val locations = sampleMasks(maskIdx)
+        val maskNumTiles = sampleNumTiles(maskIdx)
+
+        if (locations.length == 2) {
+          val start = locations(0)
+          var end = locations(1)
+
+          // Handle the case where `end == -1`
+          if (end == -1) end = length
+          end = math.min(end, length)
+
+          for (i <- start until end; j <- 0 until maskNumTiles) {
+            crossAttentionMask(sampleIdx)(i)(maskIdx)(j) = 1
+          }
+        }
+      }
+    }
+
+    crossAttentionMask
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/Phi3vUtils.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/Phi3vUtils.scala
new file mode 100644
index 00000000000000..4f1afac53d8119
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/Phi3vUtils.scala
@@ -0,0 +1,362 @@
+package com.johnsnowlabs.nlp.annotators.cv.util.transform
+import java.awt.image.BufferedImage
+import java.awt.{Color, Graphics2D}
+import scala.collection.mutable.ListBuffer
+import scala.collection.mutable.ArrayBuffer
+
+import ImageResizeUtils.resizeBufferedImage
+
+private[johnsnowlabs] object Phi3vUtils {
+  // padding image
+
+  def padding_336(image: BufferedImage): BufferedImage = {
+    // Get the current width and height of the image
+    val width = image.getWidth
+    val height = image.getHeight
+
+    // Calculate the target height (multiple of 336)
+    val targetHeight = Math.ceil(height.toDouble / 336).toInt * 336
+
+    // Calculate the padding for top and bottom
+    val topPadding = (targetHeight - height) / 2
+    val bottomPadding = targetHeight - height - topPadding
+
+    // No padding for left and right
+    val leftPadding = 0
+    val rightPadding = 0
+
+    // Create a new BufferedImage with the padded dimensions
+    val paddedImage = new BufferedImage(width, targetHeight, BufferedImage.TYPE_INT_RGB)
+
+    // Create Graphics2D object to draw the padded image
+    val g2d: Graphics2D = paddedImage.createGraphics()
+
+    // Set white background for the padding (fill)
+    g2d.setColor(Color.WHITE)
+    g2d.fillRect(0, 0, width, targetHeight)
+
+    // Draw the original image onto the center of the new padded image
+    g2d.drawImage(image, leftPadding, topPadding, null)
+
+    // Dispose of the Graphics2D context
+    g2d.dispose()
+
+    // Return the new padded image
+    paddedImage
+  }
+
+  def transposeImage(img: BufferedImage): BufferedImage = {
+    val transposedImage = new BufferedImage(img.getHeight, img.getWidth, img.getType)
+    val g2d = transposedImage.createGraphics()
+
+    g2d.rotate(Math.PI / 2)
+    g2d.translate(0, -img.getHeight)
+    g2d.drawImage(img, 0, 0, null)
+    g2d.dispose()
+
+    transposedImage
+  }
+
+  def calc_padded_size(width: Int, height: Int, padding_unit: Int = 336): (Int, Int) = {
+    val target_height = Math.ceil(height / padding_unit).intValue * padding_unit
+    val top_padding = Math.ceil((target_height - height) / 2).intValue
+    val bottom_padding = target_height - height - top_padding
+    val left_padding = 0
+    val right_padding = 0
+    val padded_width = width + left_padding + right_padding
+    val padded_height = height + top_padding + bottom_padding
+    (padded_width, padded_height)
+  }
+
+  def HDTransform(img: BufferedImage, hdNum: Int = 16): BufferedImage = {
+    var width = img.getWidth
+    var height = img.getHeight
+    var transposed = false
+
+    // Transpose the image if width is smaller than height
+    var transformedImg = img
+    if (width < height) {
+      transformedImg = transposeImage(transformedImg)
+      transposed = true
+      width = transformedImg.getWidth
+      height = transformedImg.getHeight
+    }
+
+    val ratio = width.toDouble / height.toDouble
+    var scale = 1
+
+    // Calculate the scaling factor
+    while (scale * math.ceil(scale / ratio) <= hdNum) {
+      scale += 1
+    }
+    scale -= 1
+
+    // New dimensions
+    val newWidth = (scale * 336).toInt
+    val newHeight = (newWidth / ratio).toInt
+
+    // Resize the image
+    transformedImg = resizeBufferedImage(newWidth, newHeight, 2)(transformedImg)
+
+    // Apply padding to make the image 336x336
+    transformedImg = padding_336(transformedImg)
+
+    // Transpose back if needed
+    if (transposed) {
+      transformedImg = transposeImage(transformedImg)
+    }
+
+    transformedImg
+  }
+
+  // Function to extract a subimage and reset position information
+  def getNewSubimage(
+      image: BufferedImage,
+      x: Int,
+      y: Int,
+      width: Int,
+      height: Int): BufferedImage = {
+    // Create a new BufferedImage to store the subimage
+    val subImage = new BufferedImage(width, height, image.getType)
+
+    // Create a Graphics2D object to draw the subimage
+    val g2d: Graphics2D = subImage.createGraphics()
+
+    // Draw the original image's subimage into the new BufferedImage
+    g2d.drawImage(image, 0, 0, width, height, x, y, x + width, y + height, null)
+
+    // Dispose the graphics context to free up resources
+    g2d.dispose()
+
+    // Return the new subimage with reset position information
+    subImage
+  }
+
+  // Function to calculate the shapes (height and width of the image)
+  def calculateShapes(images: List[BufferedImage]): Array[Array[Int]] = {
+    images.map(img => Array(img.getHeight, img.getWidth)).toArray
+  }
+
+  // Function to calculate the number of image tokens
+//  def calculateImageTokens(shapes: List[(Int, Int)]): List[Int] = {
+//    shapes.map { case (h, w) =>
+//      ((h / 336) * (w / 336) + 1) * 144 + 1 + ((h / 336 + 1) * 12)
+//    }
+//  }
+
+  def calculateImageTokens(shapes: Array[Array[Int]]): List[Int] = {
+    shapes.map { case Array(h, w) =>
+      ((h / 336) * (w / 336) + 1) * 144 + 1 + ((h / 336 + 1) * 12)
+    }.toList
+  }
+
+  // Function to reshape the images (assuming each image is already HD transformed)
+//  def reshapeImages(
+//      images: List[BufferedImage],
+//      shapes: List[(Int, Int)]): List[List[BufferedImage]] = {
+//    images.zip(shapes).map { case (img, (h, w)) =>
+//      val numH = h / 336
+//      val numW = w / 336
+//      val reshapedImages = new ListBuffer[BufferedImage]
+//
+//      // Splitting the image into 336x336 crops
+//      for (i <- 0 until numH; j <- 0 until numW) {
+//        val crop = getNewSubimage(img, j * 336, i * 336, 336, 336)
+//        reshapedImages += crop
+//      }
+//      reshapedImages.toList
+//    }
+//  }
+
+  def reshapeImages(
+      images: List[BufferedImage],
+      shapes: Array[Array[Int]]): List[List[BufferedImage]] = {
+    images.zip(shapes).map { case (img, Array(h, w)) =>
+      val numH = h / 336
+      val numW = w / 336
+      val reshapedImages = new ListBuffer[BufferedImage]
+
+      // Splitting the image into 336x336 crops
+      for (i <- 0 until numH; j <- 0 until numW) {
+        val crop = getNewSubimage(img, j * 336, i * 336, 336, 336)
+        reshapedImages += crop
+      }
+      reshapedImages.toList
+    }
+  }
+
+  // Function to concatenate global and local images (manually)
+  def concatenateImages(
+      globalImage: BufferedImage,
+      localImages: List[BufferedImage]): BufferedImage = {
+    val totalWidth = 336 * localImages.size + 336
+    val totalHeight = 336
+    val concatenatedImage = new BufferedImage(totalWidth, totalHeight, BufferedImage.TYPE_INT_RGB)
+    val g2d: Graphics2D = concatenatedImage.createGraphics()
+
+    // Draw global image first
+    g2d.drawImage(globalImage, 0, 0, null)
+
+    // Draw each local image next to the global image
+    localImages.zipWithIndex.foreach { case (localImage, index) =>
+      g2d.drawImage(localImage, (index + 1) * 336, 0, null)
+    }
+
+    g2d.dispose()
+    concatenatedImage
+  }
+
+  // Function to pad the images to a specified number of crops (maxNumCrops)
+  def padToMaxNumCrops(image: BufferedImage, maxNumCrops: Int): BufferedImage = {
+    val width = image.getWidth
+    val height = image.getHeight
+
+    // If the number of crops is less than maxNumCrops, pad with white
+    val targetWidth = 336 * maxNumCrops
+    val paddedImage = new BufferedImage(targetWidth, height, BufferedImage.TYPE_INT_RGB)
+    val g2d: Graphics2D = paddedImage.createGraphics()
+
+    // Fill with white background
+    g2d.setColor(Color.WHITE)
+    g2d.fillRect(0, 0, targetWidth, height)
+
+    // Draw the original image onto the white background
+    g2d.drawImage(image, 0, 0, null)
+    g2d.dispose()
+
+    paddedImage
+  }
+
+  // Main function that processes the HD transformed images
+  def processHdImages(
+      hdImages: List[BufferedImage],
+      numCrops: Int): (List[BufferedImage], Array[Array[Int]], List[Int]) = {
+    // Step 1: Create global images (resize to 336x336)
+    // val resizeGlobal =
+    val globalImages = hdImages.map(resizeBufferedImage(336, 336, 3))
+
+    // Step 2: Calculate shapes [(h, w)] where h, w are multiples of 336
+    val shapes = calculateShapes(hdImages)
+
+    // Step 3: Calculate number of image tokens
+    val numImgTokens = calculateImageTokens(shapes)
+
+    // Step 4: Reshape the HD images into 336x336 crops
+    val reshapedHdImages = reshapeImages(hdImages, shapes)
+
+    // Step 5: Concatenate global and local images
+    val concatenatedImages =
+      globalImages.zip(reshapedHdImages).map { case (globalImage, localImages) =>
+        concatenateImages(globalImage, localImages)
+      }
+
+    // Step 6: Pad to max_num_crops if necessary
+    val paddedImages = concatenatedImages.map(padToMaxNumCrops(_, numCrops + 1))
+    (paddedImages, shapes, numImgTokens)
+  }
+
+  // Function to normalize pixel values of an image crop
+  def normalizeImageCrop(
+      imgCrop: Array[Array[Array[Int]]],
+      mean: Array[Double],
+      std: Array[Double]): Array[Array[Array[Float]]] = {
+    val channels = imgCrop.length
+    val height = imgCrop(0).length
+    val width = imgCrop(0)(0).length
+
+    // Create a 3D array for normalized values
+    val normalizedCrop = Array.ofDim[Float](channels, height, width)
+
+    for (c <- 0 until channels) {
+      for (y <- 0 until height) {
+        for (x <- 0 until width) {
+          // Normalize the pixel value: (value - mean) / std
+          normalizedCrop(c)(y)(x) = (imgCrop(c)(y)(x) / 255.0 - mean(c)).toFloat / std(c).toFloat
+        }
+      }
+    }
+
+    normalizedCrop
+  }
+
+  // Helper function to convert a BufferedImage crop to a 3D array (3, 336, 336) for RGB channels
+  def imageCropToArray(imgCrop: BufferedImage): Array[Array[Array[Int]]] = {
+    val height = imgCrop.getHeight
+    val width = imgCrop.getWidth
+
+    // Create a 3D array for RGB channels
+    val channels = 3
+    val cropArray = Array.ofDim[Int](channels, height, width)
+
+    for (y <- 0 until height; x <- 0 until width) {
+      val color = new java.awt.Color(imgCrop.getRGB(x, y))
+      cropArray(0)(y)(x) = color.getRed // Red channel
+      cropArray(1)(y)(x) = color.getGreen // Green channel
+      cropArray(2)(y)(x) = color.getBlue // Blue channel
+    }
+
+    cropArray
+  }
+
+  // Function to split an image into 336x336 crops, convert to a 3D array, and normalize if required
+  def splitImageToCrops(
+      image: BufferedImage,
+      cropSize: Int = 336,
+      normalize: Boolean = false,
+      mean: Array[Double] = Array(0.48145466, 0.4578275, 0.40821073),
+      std: Array[Double] = Array(0.26862954, 0.26130258, 0.27577711))
+      : (Array[Array[Array[Array[Float]]]], Int) = {
+    val height = image.getHeight
+    val width = image.getWidth
+
+    // Number of crops along height and width
+    val numHCrops = height / cropSize
+    val numWCrops = width / cropSize
+
+    // Store the crops in a 4D array (numCrops, 3, 336, 336)
+    val cropsBuffer = ArrayBuffer[Array[Array[Array[Float]]]]()
+
+    for (i <- 0 until numHCrops) {
+      for (j <- 0 until numWCrops) {
+        // Extract a crop of 336x336
+        val imgCrop = image.getSubimage(j * cropSize, i * cropSize, cropSize, cropSize)
+        // Convert the crop to a 3D array (3, 336, 336)
+        val cropArray = imageCropToArray(imgCrop)
+
+        // Normalize the crop if the option is enabled
+        val normalizedCrop = if (normalize) {
+          normalizeImageCrop(cropArray, mean, std)
+        } else {
+          // Convert Int array to Double array if normalization is off
+          cropArray.map(_.map(_.map(_.toFloat / 255.0.toFloat)))
+        }
+
+        cropsBuffer.append(normalizedCrop)
+      }
+    }
+
+    // Convert ArrayBuffer to an array
+    (cropsBuffer.toArray, numHCrops * numWCrops)
+  }
+
+  // Function to convert processedImages (BufferedImages) into a 5D array (b, h//336 * w//336, 3, 336, 336)
+  def processedImagesTo5DArray(
+      processedImages: List[BufferedImage],
+      normalize: Boolean = false,
+      mean: Array[Double] = Array(0.48145466, 0.4578275, 0.40821073),
+      std: Array[Double] = Array(0.26862954, 0.26130258, 0.27577711))
+      : (Array[Array[Array[Array[Array[Float]]]]]) = {
+    // Store the 5D array (b, h//336 * w//336, 3, 336, 336)
+    val batchBuffer = ArrayBuffer[Array[Array[Array[Array[Float]]]]]()
+    // Process each image in the batch
+    processedImages.foreach { img =>
+      // Split the image into crops, convert each crop into a 3D array, and normalize if required
+      val (imageCropsArray, numCrops) =
+        splitImageToCrops(img, normalize = normalize, mean = mean, std = std)
+      batchBuffer.append(imageCropsArray)
+    }
+
+    // Convert ArrayBuffer to array (b, numCrops, 3, 336, 336)
+    batchBuffer.toArray
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/Qwen2VLUtils.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/Qwen2VLUtils.scala
new file mode 100644
index 00000000000000..a20b1a3ef032cf
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/transform/Qwen2VLUtils.scala
@@ -0,0 +1,63 @@
+package com.johnsnowlabs.nlp.annotators.cv.util.transform
+import java.awt.image.BufferedImage
+
+private[johnsnowlabs] object Qwen2VLUtils {
+
+  val IMAGE_FACTOR: Int = 28
+  val MIN_PIXELS: Int = 4 * 28 * 28
+  val MAX_PIXELS: Int = 16384 * 28 * 28
+  val MAX_RATIO: Int = 200
+
+  def roundByFactor(number: Int, factor: Int): Int =
+    Math.round(number.toDouble / factor).toInt * factor
+
+  def ceilByFactor(number: Int, factor: Int): Int =
+    Math.ceil(number.toDouble / factor).toInt * factor
+
+  def floorByFactor(number: Int, factor: Int): Int =
+    Math.floor(number.toDouble / factor).toInt * factor
+
+  def smartResize(
+      height: Int,
+      width: Int,
+      factor: Int = IMAGE_FACTOR,
+      minPixels: Int = MIN_PIXELS,
+      maxPixels: Int = MAX_PIXELS): (Int, Int) = {
+    if (Math.max(height, width).toDouble / Math.min(height, width) > MAX_RATIO) {
+      throw new IllegalArgumentException(s"absolute aspect ratio must be smaller than $MAX_RATIO")
+    }
+
+    var hBar = Math.max(factor, roundByFactor(height, factor))
+    var wBar = Math.max(factor, roundByFactor(width, factor))
+
+    if (hBar * wBar > maxPixels) {
+      val beta = Math.sqrt(height.toDouble * width / maxPixels)
+      hBar = floorByFactor((height / beta).toInt, factor)
+      wBar = floorByFactor((width / beta).toInt, factor)
+    } else if (hBar * wBar < minPixels) {
+      val beta = Math.sqrt(minPixels.toDouble / (height * width))
+      hBar = ceilByFactor((height * beta).toInt, factor)
+      wBar = ceilByFactor((width * beta).toInt, factor)
+    }
+
+    (hBar, wBar)
+  }
+
+  def imageBufferToArray(imgCrop: BufferedImage): Array[Array[Array[Int]]] = {
+    val height = imgCrop.getHeight
+    val width = imgCrop.getWidth
+
+    // Create a 3D array for RGB channels
+    val channels = 3
+    val cropArray = Array.ofDim[Int](channels, height, width)
+
+    for (y <- 0 until height; x <- 0 until width) {
+      val color = new java.awt.Color(imgCrop.getRGB(x, y))
+      cropArray(0)(y)(x) = color.getRed // Red channel
+      cropArray(1)(y)(x) = color.getGreen // Green channel
+      cropArray(2)(y)(x) = color.getBlue // Blue channel
+    }
+
+    cropArray
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFModel.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFModel.scala
index 3caf4bdc0e8be2..4be4c98039058f 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFModel.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFModel.scala
@@ -153,6 +153,16 @@ class AutoGGUFModel(override val uid: String)
     embedding -> false,
     nPredict -> 100)
 
+  /** Sets the number of parallel processes for decoding. This is an alias for `setBatchSize`.
+    *
+    * @group setParam
+    * @param nParallel
+    *   The number of parallel processes for decoding
+    */
+  def setNParallel(nParallel: Int): this.type = {
+    setBatchSize(nParallel)
+  }
+
   override def onWrite(path: String, spark: SparkSession): Unit = {
     super.onWrite(path, spark)
     getModelIfNotSet.saveToFile(path)
@@ -184,7 +194,9 @@ class AutoGGUFModel(override val uid: String)
           } catch {
             case e: Exception =>
               logger.error("Error in llama.cpp embeddings", e)
-              (Array.empty[Array[Float]], Map("llamacpp_exception" -> e.getMessage))
+              (
+                Array.fill[Array[Float]](annotationsText.length)(Array.empty),
+                Map("llamacpp_exception" -> e.getMessage))
           }
         // Choose empty text for result annotations
         annotations.zip(embeddings).map { case (annotation, embedding) =>
@@ -204,7 +216,7 @@ class AutoGGUFModel(override val uid: String)
           } catch {
             case e: Exception =>
               logger.error("Error in llama.cpp batch completion", e)
-              (Array[String](), Map("llamacpp_exception" -> e.getMessage))
+              (Array.fill(annotationsText.length)(""), Map("llamacpp_exception" -> e.getMessage))
           }
         annotations.zip(completedTexts).map { case (annotation, text) =>
           Seq(
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel.scala
new file mode 100644
index 00000000000000..62b4d4903ec97b
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel.scala
@@ -0,0 +1,336 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.seq2seq
+
+import com.johnsnowlabs.ml.gguf.GGUFWrapperMultiModal
+import com.johnsnowlabs.ml.util.LlamaCPP
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.nlp.annotators.cv.util.io.ImageIOUtils
+import com.johnsnowlabs.nlp.llama.{LlamaException, LlamaModel}
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** Multimodal annotator that uses the llama.cpp library to generate text completions with large
+  * language models. It supports ingesting images for captioning.
+  *
+  * At the moment only CLIP based models are supported.
+  *
+  * For settable parameters, and their explanations, see [[HasLlamaCppInferenceProperties]],
+  * [[HasLlamaCppModelProperties]] and refer to the llama.cpp documentation of
+  * [[https://github.com/ggerganov/llama.cpp/tree/7d5e8777ae1d21af99d4f95be10db4870720da91/examples/server server.cpp]]
+  * for more information.
+  *
+  * If the parameters are not set, the annotator will default to use the parameters provided by
+  * the model.
+  *
+  * This annotator expects a column of annotator type [[AnnotationImage]] for the image and
+  * [[Annotation]] for the caption. Note that the image bytes in the image annotation need to be
+  * raw image bytes without preprocessing. We provide the helper function
+  * [[ImageAssembler.loadImagesAsBytes]] to load the image bytes from a directory.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val autoGGUFVisionModel = AutoGGUFVisionModel.pretrained()
+  *   .setInputCols("image', "document")
+  *   .setOutputCol("completions")
+  * }}}
+  * The default model is `"llava_v1.5_7b_Q4_0_gguf"`, if no name is provided.
+  *
+  * For available pretrained models please see the [[https://sparknlp.org/models Models Hub]].
+  *
+  * For extended examples of usage, see the
+  * [[https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTest.scala AutoGGUFVisionModelTest]]
+  * and the
+  * [[https://github.com/JohnSnowLabs/spark-nlp/tree/master/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb example notebook]].
+  *
+  * ==Note==
+  * To use GPU inference with this annotator, make sure to use the Spark NLP GPU package and set
+  * the number of GPU layers with the `setNGpuLayers` method.
+  *
+  * When using larger models, we recommend adjusting GPU usage with `setNCtx` and `setNGpuLayers`
+  * according to your hardware to avoid out-of-memory errors.
+  *
+  * ==Example==
+  *
+  * {{{
+  * import com.johnsnowlabs.nlp.ImageAssembler
+  * import com.johnsnowlabs.nlp.annotator._
+  * import com.johnsnowlabs.nlp.base._
+  * import org.apache.spark.ml.Pipeline
+  * import org.apache.spark.sql.DataFrame
+  * import org.apache.spark.sql.functions.lit
+  *
+  * val documentAssembler = new DocumentAssembler()
+  *   .setInputCol("caption")
+  *   .setOutputCol("caption_document")
+  *
+  * val imageAssembler = new ImageAssembler()
+  *   .setInputCol("image")
+  *   .setOutputCol("image_assembler")
+  *
+  * val imagesPath = "src/test/resources/image/"
+  * val data: DataFrame = ImageAssembler
+  *   .loadImagesAsBytes(ResourceHelper.spark, imagesPath)
+  *   .withColumn("caption", lit("Caption this image.")) // Add a caption to each image.
+  *
+  * val nPredict = 40
+  * val model = AutoGGUFVisionModel.pretrained()
+  *   .setInputCols("caption_document", "image_assembler")
+  *   .setOutputCol("completions")
+  *   .setBatchSize(4)
+  *   .setNGpuLayers(99)
+  *   .setNCtx(4096)
+  *   .setMinKeep(0)
+  *   .setMinP(0.05f)
+  *   .setNPredict(nPredict)
+  *   .setNProbs(0)
+  *   .setPenalizeNl(false)
+  *   .setRepeatLastN(256)
+  *   .setRepeatPenalty(1.18f)
+  *   .setStopStrings(Array("", "Llama:", "User:"))
+  *   .setTemperature(0.05f)
+  *   .setTfsZ(1)
+  *   .setTypicalP(1)
+  *   .setTopK(40)
+  *   .setTopP(0.95f)
+  *
+  * val pipeline = new Pipeline().setStages(Array(documentAssembler, imageAssembler, model))
+  * pipeline
+  *   .fit(data)
+  *   .transform(data)
+  *   .selectExpr("reverse(split(image.origin, '/'))[0] as image_name", "completions.result")
+  *   .show(truncate = false)
+  * +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * |image_name       |result                                                                                                                                                                                        |
+  * +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * |palace.JPEG      |[ The image depicts a large, ornate room with high ceilings and beautifully decorated walls. There are several chairs placed throughout the space, some of which have cushions]               |
+  * |egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the scene and appears to be sleeping while holding]             |
+  * |hippopotamus.JPEG|[ A large brown hippo is swimming in a body of water, possibly an aquarium. The hippo appears to be enjoying its time in the water and seems relaxed as it floats]                            |
+  * |hen.JPEG         |[ The image features a large chicken standing next to several baby chickens. In total, there are five birds in the scene: one adult and four young ones. They appear to be gathered together] |
+  * |ostrich.JPEG     |[ The image features a large, long-necked bird standing in the grass. It appears to be an ostrich or similar species with its head held high and looking around. In addition to]              |
+  * |junco.JPEG       |[ A small bird with a black head and white chest is standing on the snow. It appears to be looking at something, possibly food or another animal in its vicinity. The scene takes place out]  |
+  * |bluetick.jpg     |[ A dog with a red collar is sitting on the floor, looking at something. The dog appears to be staring into the distance or focusing its attention on an object in front of it.]              |
+  * |chihuahua.jpg    |[ A small brown dog wearing a sweater is sitting on the floor. The dog appears to be looking at something, possibly its owner or another animal in the room. It seems comfortable and relaxed]|
+  * |tractor.JPEG     |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels and tires. The tractor appears to be parked on top of an empty field with]                                |
+  * |ox.JPEG          |[ A large bull with horns is standing in a grassy field.]                                                                                                                                     |
+  * +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * }}}
+  *
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+class AutoGGUFVisionModel(override val uid: String)
+    extends AnnotatorModel[AutoGGUFVisionModel]
+    with HasBatchedAnnotateTextImage[AutoGGUFVisionModel]
+    with HasEngine
+    with HasLlamaCppModelProperties
+    with HasLlamaCppInferenceProperties
+    with HasProtectedParams {
+
+  override val inputAnnotatorTypes: Array[AnnotatorType] =
+    Array(AnnotatorType.IMAGE, AnnotatorType.DOCUMENT)
+  override val outputAnnotatorType: AnnotatorType = AnnotatorType.DOCUMENT
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("AutoGGUFVisionModel"))
+
+  private var _model: Option[Broadcast[GGUFWrapperMultiModal]] = None
+
+  /** @group getParam */
+  def getModelIfNotSet: GGUFWrapperMultiModal = _model.get.value
+
+  /** @group setParam */
+  def setModelIfNotSet(spark: SparkSession, wrapper: GGUFWrapperMultiModal): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(spark.sparkContext.broadcast(wrapper))
+    }
+
+    // Entrypoint for models. Automatically set GPU support if detected.
+    setGpuSupportIfAvailable(spark)
+    this
+  }
+
+  private[johnsnowlabs] def setEngine(engineName: String): this.type = set(engine, engineName)
+
+  /** Sets the number of parallel processes for decoding. This is an alias for `setBatchSize`.
+    *
+    * @group setParam
+    * @param nParallel
+    *   The number of parallel processes for decoding
+    */
+  def setNParallel(nParallel: Int): this.type = {
+    setBatchSize(nParallel)
+  }
+
+  setDefault(
+    engine -> LlamaCPP.name,
+    useChatTemplate -> true,
+    nCtx -> 4096,
+    nBatch -> 512,
+    embedding -> false,
+    nPredict -> 100)
+
+//  val mmproj = new Param[String](
+//    this,
+//    "mmproj",
+//    "Name of the file for the multi-modal projection (mmproj) model, that encodes the images.")
+//
+//  /** Sets the path to the multi-modal projection (mmproj) model, that encodes the images.
+//    *
+//    * Should only be used by this class and not by the user.
+//    *
+//    * @param value
+//    *   Name of the file for the multi-modal projection (mmproj) model
+//    * @return
+//    */
+//  private def setMmproj(value: String): this.type = set(mmproj, value)
+//
+//  private def getMmproj: String = $(mmproj)
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getModelIfNotSet.saveToFile(path)
+  }
+
+  /** Completes the batch of annotations.
+    *
+    * @param batchedAnnotations
+    *   The single batch of annotations
+    * @return
+    *   Completed text sequences
+    *
+    * sentences that belong to the same original row !! (challenging)
+    */
+  override def batchAnnotate(
+      batchedAnnotations: Seq[(Annotation, AnnotationImage)]): Seq[Seq[Annotation]] = {
+    if (batchedAnnotations.nonEmpty) {
+
+      // set parallel decoding to batch size
+      val modelParams = getModelParameters.setNParallel(getBatchSize)
+      val model: LlamaModel = getModelIfNotSet.getSession(modelParams)
+
+      val (prompts, base64EncodedImages) = batchedAnnotations.unzip match {
+        case (promptAnnotations, imageAnnotations) =>
+          (
+            promptAnnotations.map(_.result).toArray,
+            imageAnnotations
+              .map(imgAnno => ImageIOUtils.encodeImageBase64(imgAnno.result))
+              .toArray)
+      }
+
+      val (completedTexts: Array[String], metadata: Map[String, String]) =
+        try {
+          (
+            model.requestBatchImageCompletion(
+              prompts,
+              base64EncodedImages,
+              getInferenceParameters),
+            Map.empty)
+        } catch {
+          case e: LlamaException =>
+            logger.error("Error in llama.cpp image batch completion", e)
+            (Array.fill(prompts.length)(""), Map("llamacpp_exception" -> e.getMessage))
+        }
+
+      val result: Seq[Seq[Annotation]] =
+        batchedAnnotations.zip(completedTexts).map {
+          case ((textAnnotation: Annotation, imageAnnotation: AnnotationImage), text) =>
+            val totalMetadata =
+              textAnnotation.metadata ++ imageAnnotation.metadata ++ metadata
+            Seq(new Annotation(outputAnnotatorType, 0, text.length - 1, text, totalMetadata))
+        }
+      result
+    } else Seq(Seq.empty[Annotation])
+  }
+}
+
+trait ReadablePretrainedAutoGGUFVisionModel
+    extends ParamsAndFeaturesReadable[AutoGGUFVisionModel]
+    with HasPretrained[AutoGGUFVisionModel] {
+  override val defaultModelName: Some[String] = Some("llava_v1.5_7b_Q4_0_gguf")
+  override val defaultLang: String = "en"
+
+  /** Java compliant-overrides */
+  override def pretrained(): AutoGGUFVisionModel = super.pretrained()
+
+  override def pretrained(name: String): AutoGGUFVisionModel = super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): AutoGGUFVisionModel =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): AutoGGUFVisionModel =
+    super.pretrained(name, lang, remoteLoc)
+}
+
+trait ReadAutoGGUFVisionModel {
+  this: ParamsAndFeaturesReadable[AutoGGUFVisionModel] =>
+
+  def readModel(instance: AutoGGUFVisionModel, path: String, spark: SparkSession): Unit = {
+    val model: GGUFWrapperMultiModal = GGUFWrapperMultiModal.readModel(path, spark)
+
+    instance.setModelIfNotSet(spark, model)
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(
+      modelPath: String,
+      mmprojPath: String,
+      spark: SparkSession): AutoGGUFVisionModel = {
+    // TODO potentially enable download from HF-URLS
+    val localPathModel: String = ResourceHelper.copyToLocal(modelPath)
+    val localPathMmproj: String = ResourceHelper.copyToLocal(mmprojPath)
+
+    val annotatorModel = new AutoGGUFVisionModel()
+    val wrapper = GGUFWrapperMultiModal.read(spark, localPathModel, localPathMmproj)
+
+    annotatorModel
+      .setModelIfNotSet(spark, wrapper)
+      .setEngine(LlamaCPP.name)
+
+    // TODO mmproj metadata necessary?
+    val metadata = LlamaModel.getMetadataFromFile(localPathModel)
+    if (metadata.nonEmpty) annotatorModel.setMetadata(metadata)
+    annotatorModel
+  }
+}
+
+/** This is the companion object of [[AutoGGUFVisionModel]]. Please refer to that class for the
+  * documentation.
+  */
+object AutoGGUFVisionModel
+    extends ReadablePretrainedAutoGGUFVisionModel
+    with ReadAutoGGUFVisionModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTransformer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTransformer.scala
new file mode 100644
index 00000000000000..4e755139c05379
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTransformer.scala
@@ -0,0 +1,520 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.seq2seq
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.ai.CoHere
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.onnx.{OnnxWrapper, ReadOnnxModel, WriteOnnxModel}
+import com.johnsnowlabs.ml.openvino.{OpenvinoWrapper, ReadOpenvinoModel, WriteOpenvinoModel}
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadJsonStringAsset,
+  loadSentencePieceAsset,
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.ml.util.{ONNX, Openvino}
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.ml.tensorflow.sentencepiece.{
+  ReadSentencePieceModel,
+  SentencePieceWrapper,
+  WriteSentencePieceModel
+}
+import com.johnsnowlabs.nlp.serialization.MapFeature
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param._
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+import com.johnsnowlabs.nlp.serialization.{MapFeature, StructFeature}
+import org.json4s._
+import org.json4s.jackson.JsonMethods._
+
+/** Cohere: Command-R Transformer
+  *
+  * C4AI Command-R is a research release of a 35 billion parameter highly performant generative
+  * model. Command-R is a large language model with open weights optimized for a variety of use
+  * cases including reasoning, summarization, and question answering. Command-R has the capability
+  * for multilingual generation evaluated in 10 languages and highly performant RAG capabilities.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val CoHere = CoHereTransformer.pretrained()
+  *   .setInputCols("document")
+  *   .setOutputCol("generation")
+  * }}}
+  * The default model is `"c4ai_command_r_v01_int4"`, if no name is provided. For available
+  * pretrained models please see the [[https://sparknlp.org/models?q=CoHere Models Hub]].
+  *
+  * For extended examples of usage, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTestSpec.scala CoHereTestSpec]].
+  *
+  * '''References:'''
+  *   - [[https://cohere.for.ai CoHere]]
+  *
+  * '''Note:'''
+  *
+  * This is a resource-intensive module, especially with larger models and sequences. Use of
+  * accelerators such as GPUs is strongly recommended.
+  *
+  * ==Example==
+  * {{{
+  * import spark.implicits._
+  * import com.johnsnowlabs.nlp.base.DocumentAssembler
+  * import com.johnsnowlabs.nlp.annotators.seq2seq.CoHereTransformer
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val documentAssembler = new DocumentAssembler()
+  *   .setInputCol("text")
+  *   .setOutputCol("documents")
+  *
+  * val CoHere = CoHereTransformer.pretrained("c4ai_command_r_v01_int4","en")
+  *   .setInputCols(Array("documents"))
+  *   .setMinOutputLength(15)
+  *   .setMaxOutputLength(60)
+  *   .setDoSample(false)
+  *   .setTopK(40)
+  *   .setNoRepeatNgramSize(3)
+  *   .setOutputCol("generation")
+  *
+  * val pipeline = new Pipeline().setStages(Array(documentAssembler, CoHere))
+  *
+  * val data = Seq(
+  *   (
+  *     1,
+  *     """
+  *     <|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>
+  *     """.stripMargin)
+  * ).toDF("id", "text")
+  *
+  * val result = pipeline.fit(data).transform(data)
+  *
+  * result.select("generation.result").show(truncate = false)
+  * +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * |result                                                                                                                                                                                                  |
+  * +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * |[Hello! I'm doing well, thank you for asking! I'm excited to help you with whatever questions you have today. How can I assist you?]                                                                         |
+  * +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * }}}
+  *
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+
+class CoHereTransformer(override val uid: String)
+    extends AnnotatorModel[CoHereTransformer]
+    with HasBatchedAnnotate[CoHereTransformer]
+    with ParamsAndFeaturesWritable
+    with WriteOnnxModel
+    with WriteOpenvinoModel
+    with HasGeneratorProperties
+    with HasEngine {
+
+  def this() = this(Identifiable.randomUID("CoHereTRANSFORMER"))
+
+  /** Input annotator type : DOCUMENT
+    *
+    * @group param
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(DOCUMENT)
+
+  /** Output annotator type : DOCUMENT
+    *
+    * @group param
+    */
+  override val outputAnnotatorType: String = DOCUMENT
+
+  /** @group setParam */
+  def setRandomSeed(value: Int): CoHereTransformer.this.type = {
+    if (randomSeed.isEmpty) {
+      this.randomSeed = Some(value)
+    }
+    this
+  }
+
+  /** A list of token ids which are ignored in the decoder's output (Default: `Array()`)
+    *
+    * @group param
+    */
+  var ignoreTokenIds = new IntArrayParam(
+    this,
+    "ignoreTokenIds",
+    "A list of token ids which are ignored in the decoder's output")
+
+  /** @group setParam */
+  def setIgnoreTokenIds(tokenIds: Array[Int]): CoHereTransformer.this.type = {
+    set(ignoreTokenIds, tokenIds)
+  }
+
+  /** @group getParam */
+  def getIgnoreTokenIds: Array[Int] = $(ignoreTokenIds)
+
+  /** Vocabulary used to encode the words to ids with bpeTokenizer.encode
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** Holding merges.txt coming from RoBERTa model
+    *
+    * @group param
+    */
+  val merges: MapFeature[(String, String), Int] = new MapFeature(this, "merges").setProtected()
+
+  /** @group setParam */
+  def setMerges(value: Map[(String, String), Int]): this.type = set(merges, value)
+
+  /** Additional tokens to be added to the vocabulary
+    *
+    * @group param
+    */
+  val addedTokens: MapFeature[String, Int] = new MapFeature(this, "addedTokens").setProtected()
+
+  /** @group setParam */
+  def setAddedTokens(value: Map[String, Int]): this.type = set(addedTokens, value)
+
+  /** Stop tokens to terminate the generation
+    *
+    * @group param
+    */
+  override val stopTokenIds =
+    new IntArrayParam(this, "stopTokenIds", "Stop tokens to terminate the generation")
+
+  /** @group setParam */
+  override def setStopTokenIds(value: Array[Int]): this.type = {
+    set(stopTokenIds, value)
+  }
+
+  /** @group getParam */
+  override def getStopTokenIds: Array[Int] = $(stopTokenIds)
+
+  private var _model: Option[Broadcast[CoHere]] = None
+
+  val generationConfig: StructFeature[GenerationConfig] =
+    new StructFeature(this, "generationConfig").setProtected()
+
+  def setGenerationConfig(value: GenerationConfig): this.type =
+    set(generationConfig, value)
+
+  def getGenerationConfig: GenerationConfig = $$(generationConfig)
+
+  /** @group setParam */
+  def setModelIfNotSet(
+      spark: SparkSession,
+      onnxWrappers: Option[DecoderWrappers],
+      openvinoWrapper: Option[OpenvinoWrapper]): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new CoHere(
+            onnxWrappers,
+            openvinoWrapper,
+            $$(merges),
+            $$(vocabulary),
+            $$(addedTokens),
+            generationConfig = getGenerationConfig)))
+    }
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: CoHere = _model.get.value
+
+  setDefault(
+    minOutputLength -> 0,
+    maxOutputLength -> 20,
+    doSample -> false,
+    temperature -> 0.6,
+    topK -> -1,
+    topP -> 0.9,
+    repetitionPenalty -> 1.0,
+    noRepeatNgramSize -> 3,
+    ignoreTokenIds -> Array(),
+    batchSize -> 1,
+    beamSize -> 1,
+    maxInputLength -> 4096,
+    stopTokenIds -> Array(128001))
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations that correspond to inputAnnotationCols generated by previous annotators if any
+    * @return
+    *   any number of annotations processed for every input annotation. Not necessary one to one
+    *   relationship
+    */
+  override def batchAnnotate(batchedAnnotations: Seq[Array[Annotation]]): Seq[Seq[Annotation]] = {
+
+    val allAnnotations = batchedAnnotations
+      .filter(_.nonEmpty)
+      .zipWithIndex
+      .flatMap { case (annotations, i) =>
+        annotations.filter(_.result.nonEmpty).map(x => (x, i))
+      }
+    val processedAnnotations = if (allAnnotations.nonEmpty) {
+      this.getModelIfNotSet.predict(
+        sentences = allAnnotations.map(_._1),
+        batchSize = $(batchSize),
+        minOutputLength = $(minOutputLength),
+        maxOutputLength = $(maxOutputLength),
+        doSample = $(doSample),
+        temperature = $(temperature),
+        topK = $(topK),
+        topP = $(topP),
+        repetitionPenalty = $(repetitionPenalty),
+        noRepeatNgramSize = $(noRepeatNgramSize),
+        randomSeed = this.randomSeed,
+        ignoreTokenIds = $(ignoreTokenIds),
+        beamSize = $(beamSize),
+        maxInputLength = $(maxInputLength),
+        stopTokenIds = $(stopTokenIds))
+    } else {
+      Seq()
+    }
+    Seq(processedAnnotations)
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getEngine match {
+      case ONNX.name =>
+        val wrappers = getModelIfNotSet.onnxWrappers
+        writeOnnxModels(
+          path,
+          spark,
+          Seq((wrappers.get.decoder, "decoder_model.onnx")),
+          CoHereTransformer.suffix)
+      case Openvino.name =>
+        val wrappers = getModelIfNotSet.openvinoWrapper
+        writeOpenvinoModel(
+          path,
+          spark,
+          wrappers.get,
+          CoHereTransformer.suffix,
+          CoHereTransformer.openvinoFile)
+    }
+  }
+}
+
+trait ReadablePretrainedCoHereTransformerModel
+    extends ParamsAndFeaturesReadable[CoHereTransformer]
+    with HasPretrained[CoHereTransformer] {
+  override val defaultModelName: Some[String] = Some("c4ai_command_r_v01_int4")
+
+  /** Java compliant-overrides */
+  override def pretrained(): CoHereTransformer = super.pretrained()
+
+  override def pretrained(name: String): CoHereTransformer = super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): CoHereTransformer =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): CoHereTransformer =
+    super.pretrained(name, lang, remoteLoc)
+}
+
+trait ReadCoHereTransformerDLModel extends ReadOnnxModel with ReadOpenvinoModel {
+  this: ParamsAndFeaturesReadable[CoHereTransformer] =>
+
+  override val onnxFile: String = "CoHere_onnx"
+  val suffix: String = "_CoHere"
+  override val openvinoFile: String = "CoHere_openvino"
+
+  def readModel(instance: CoHereTransformer, path: String, spark: SparkSession): Unit = {
+    instance.getEngine match {
+      case ONNX.name =>
+        val wrappers =
+          readOnnxModels(path, spark, Seq("decoder_model.onnx"), suffix)
+        val onnxWrappers =
+          DecoderWrappers(decoder = wrappers("decoder_model.onnx"))
+        instance.setModelIfNotSet(spark, Some(onnxWrappers), None)
+      case Openvino.name =>
+        val ovWrapper =
+          readOpenvinoModel(path, spark, "_CoHere_ov")
+        instance.setModelIfNotSet(spark, None, Some(ovWrapper))
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(
+      modelPath: String,
+      spark: SparkSession,
+      useOpenvino: Boolean = false): CoHereTransformer = {
+    implicit val formats: DefaultFormats.type = DefaultFormats // for json4
+    val (localModelPath, detectedEngine) =
+      modelSanityCheck(modelPath, isDecoder = true)
+    val modelConfig: JValue =
+      parse(loadJsonStringAsset(localModelPath, "config.json"))
+
+    val beginSuppressTokens: Array[Int] =
+      (modelConfig \ "begin_suppress_tokens").extract[Array[Int]]
+
+    val suppressTokenIds: Array[Int] =
+      (modelConfig \ "suppress_tokens").extract[Array[Int]]
+
+    val forcedDecoderIds: Array[(Int, Int)] =
+      (modelConfig \ "forced_decoder_ids").extract[Array[Array[Int]]].map {
+        case idxWithTokenId: Array[Int] if idxWithTokenId.length == 2 =>
+          (idxWithTokenId(0), idxWithTokenId(1))
+        case _ =>
+          throw new Exception(
+            "Could not extract forced_decoder_ids. Should be a list of tuples with 2 entries.")
+      }
+
+    def arrayOrNone[T](array: Array[T]): Option[Array[T]] =
+      if (array.nonEmpty) Some(array) else None
+
+    val bosTokenId = (modelConfig \ "bos_token_id").extract[Int]
+    val eosTokenId = (modelConfig \ "eos_token_id").extract[Int]
+    val padTokenId = (modelConfig \ "eos_token_id").extract[Int]
+    val vocabSize = (modelConfig \ "vocab_size").extract[Int]
+
+    // Check if tokenizer.json exists
+    val tokenizerPath = s"$localModelPath/assets/tokenizer.json"
+    val tokenizerExists = new java.io.File(tokenizerPath).exists()
+    val (vocabs, addedTokens, bytePairs) = if (tokenizerExists) {
+      val tokenizerConfig: JValue = parse(loadJsonStringAsset(localModelPath, "tokenizer.json"))
+      // extract vocab from tokenizer.json ( model -> vocab)
+      var vocabs: Map[String, Int] =
+        (tokenizerConfig \ "model" \ "vocab").extract[Map[String, Int]]
+
+      // extract merges from tokenizer.json ( model -> merges)
+      val bytePairs = (tokenizerConfig \ "model" \ "merges")
+        .extract[List[Array[String]]]
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+
+      // extract added_tokens from tokenizer.json (added_tokens)
+      // "added_tokens": [
+      //    {
+      //      "id": 128000,
+      //      "content": "<|begin_of_text|>",
+      //      "single_word": false,
+      //      "lstrip": false,
+      //      "rstrip": false,
+      //      "normalized": false,
+      //      "special": true
+      //    }, ...
+      //  ]
+      val addedTokens = (tokenizerConfig \ "added_tokens")
+        .extract[List[Map[String, Any]]]
+        .map { token =>
+          val id = token("id").asInstanceOf[BigInt].intValue()
+          val content = token("content").asInstanceOf[String]
+          (content, id)
+        }
+        .toMap
+
+      // update vocab with added tokens
+      addedTokens.foreach { case (content, id) =>
+        vocabs += (content -> id)
+      }
+      (vocabs, addedTokens, bytePairs)
+    } else {
+      val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+      val addedTokens = loadTextAsset(localModelPath, "added_tokens.txt").zipWithIndex.toMap
+      val bytePairs = loadTextAsset(localModelPath, "merges.txt")
+        .map(_.split(" "))
+        .filter(w => w.length == 2)
+        .map { case Array(c1, c2) => (c1, c2) }
+        .zipWithIndex
+        .toMap
+      (vocabs, addedTokens, bytePairs)
+    }
+    val annotatorModel = new CoHereTransformer()
+      .setGenerationConfig(
+        GenerationConfig(
+          bosTokenId,
+          padTokenId,
+          eosTokenId,
+          vocabSize,
+          arrayOrNone(beginSuppressTokens),
+          arrayOrNone(suppressTokenIds),
+          arrayOrNone(forcedDecoderIds)))
+      .setVocabulary(vocabs)
+      .setMerges(bytePairs)
+      .setAddedTokens(addedTokens)
+
+    val modelEngine =
+      if (useOpenvino)
+        Openvino.name
+      else
+        detectedEngine
+    annotatorModel.set(annotatorModel.engine, modelEngine)
+
+    detectedEngine match {
+      case ONNX.name =>
+        val onnxWrapperDecoder =
+          OnnxWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            modelName = "decoder_model")
+
+        val onnxWrappers = DecoderWrappers(onnxWrapperDecoder)
+
+        annotatorModel
+          .setModelIfNotSet(spark, Some(onnxWrappers), None)
+      case Openvino.name =>
+        val openvinoWrapper =
+          OpenvinoWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            detectedEngine = detectedEngine)
+        annotatorModel.setModelIfNotSet(spark, None, Some(openvinoWrapper))
+
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+
+}
+
+object CoHereTransformer
+    extends ReadablePretrainedCoHereTransformerModel
+    with ReadCoHereTransformerDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/LLAMA3Transformer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/LLAMA3Transformer.scala
index 1eecc75c557e26..6651fc57b41cf7 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/LLAMA3Transformer.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/LLAMA3Transformer.scala
@@ -65,7 +65,7 @@ import org.json4s.jackson.JsonMethods._
   *   .setInputCols("document")
   *   .setOutputCol("generation")
   * }}}
-  * The default model is `"llama_3_7b_chat_hf_int8"`, if no name is provided. For available
+  * The default model is `"llama_3_7b_chat_hf_int4"`, if no name is provided. For available
   * pretrained models please see the [[https://sparknlp.org/models?q=llama3 Models Hub]].
   *
   * For extended examples of usage, see
@@ -101,7 +101,7 @@ import org.json4s.jackson.JsonMethods._
   *   .setInputCol("text")
   *   .setOutputCol("documents")
   *
-  * val llama3 = LLAMA3Transformer.pretrained("llama_3_7b_chat_hf_int8")
+  * val llama3 = LLAMA3Transformer.pretrained("llama_3_7b_chat_hf_int4")
   *   .setInputCols(Array("documents"))
   *   .setMinOutputLength(15)
   *   .setMaxOutputLength(60)
@@ -359,7 +359,7 @@ class LLAMA3Transformer(override val uid: String)
 trait ReadablePretrainedLLAMA3TransformerModel
     extends ParamsAndFeaturesReadable[LLAMA3Transformer]
     with HasPretrained[LLAMA3Transformer] {
-  override val defaultModelName: Some[String] = Some("llama3")
+  override val defaultModelName: Some[String] = Some("llama_3_7b_chat_hf_int4")
 
   /** Java compliant-overrides */
   override def pretrained(): LLAMA3Transformer = super.pretrained()
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/OLMoTransformer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/OLMoTransformer.scala
new file mode 100644
index 00000000000000..a5afd467478eaf
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/OLMoTransformer.scala
@@ -0,0 +1,436 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.seq2seq
+
+import com.johnsnowlabs.ml.ai.util.Generation.GenerationConfig
+import com.johnsnowlabs.ml.ai.OLMo
+import com.johnsnowlabs.ml.onnx.OnnxWrapper.DecoderWrappers
+import com.johnsnowlabs.ml.onnx.{OnnxWrapper, ReadOnnxModel, WriteOnnxModel}
+import com.johnsnowlabs.ml.util.LoadExternalModel.{
+  loadJsonStringAsset,
+  loadSentencePieceAsset,
+  loadTextAsset,
+  modelSanityCheck,
+  notSupportedEngineError
+}
+import com.johnsnowlabs.ml.util.ONNX
+import com.johnsnowlabs.nlp.AnnotatorType.DOCUMENT
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.ml.tensorflow.sentencepiece.{
+  ReadSentencePieceModel,
+  SentencePieceWrapper,
+  WriteSentencePieceModel
+}
+import com.johnsnowlabs.nlp.serialization.MapFeature
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.param._
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+import com.johnsnowlabs.nlp.serialization.{MapFeature, StructFeature}
+import org.json4s._
+import org.json4s.jackson.JsonMethods._
+
+/** OLMo: Open Language Models
+  *
+  * OLMo is a series of Open Language Models designed to enable the science of language models.
+  * The OLMo models are trained on the Dolma dataset.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val OLMo = OLMoTransformer.pretrained()
+  *   .setInputCols("document")
+  *   .setOutputCol("generation")
+  * }}}
+  * The default model is `"olmo_1b_int4"`, if no name is provided. For available pretrained models
+  * please see the [[https://sparknlp.org/models?q=OLMo Models Hub]].
+  *
+  * For extended examples of usage, see
+  * [[https://github.com/JohnSnowLabs/spark-nlp/blob/master/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/OLMoTestSpec.scala OLMoTestSpec]].
+  *
+  * '''References:'''
+  *   - [[https://allenai.org/olmo OLMo Project Page.]]
+  *   - [[https://github.com/allenai/OLMo OLMo GitHub Repository.]]
+  *   - [[https://arxiv.org/pdf/2402.00838.pdf OLMo: Accelerating the Science of Language Models]]
+  *
+  * '''Paper Abstract:'''
+  *
+  * ''Language models (LMs) have become ubiquitous in both NLP research and in commercial product
+  * offerings. As their commercial importance has surged, the most powerful models have become
+  * closed off, gated behind proprietary interfaces, with important details of their training
+  * data, architectures, and development undisclosed. Given the importance of these details in
+  * scientifically studying these models, including their biases and potential risks, we believe
+  * it is essential for the research community to have access to powerful, truly open LMs. To this
+  * end, this technical report details the first release of OLMo, a state-of-the-art, truly Open
+  * Language Model and its framework to build and study the science of language modeling. Unlike
+  * most prior efforts that have only released model weights and inference code, we release OLMo
+  * and the whole framework, including training data and training and evaluation code. We hope
+  * this release will empower and strengthen the open research community and inspire a new wave of
+  * innovation.''
+  *
+  * '''Note:'''
+  *
+  * This is a very computationally expensive module especially on larger sequence. The use of an
+  * accelerator such as GPU is recommended.
+  *
+  * ==Example==
+  * {{{
+  * import spark.implicits._
+  * import com.johnsnowlabs.nlp.base.DocumentAssembler
+  * import com.johnsnowlabs.nlp.annotators.seq2seq.OLMoTransformer
+  * import org.apache.spark.ml.Pipeline
+  *
+  * val documentAssembler = new DocumentAssembler()
+  *   .setInputCol("text")
+  *   .setOutputCol("documents")
+  *
+  * val OLMo = OLMoTransformer.pretrained("olmo_1b_int4")
+  *   .setInputCols(Array("documents"))
+  *   .setMinOutputLength(10)
+  *   .setMaxOutputLength(50)
+  *   .setDoSample(false)
+  *   .setTopK(50)
+  *   .setNoRepeatNgramSize(3)
+  *   .setOutputCol("generation")
+  *
+  * val pipeline = new Pipeline().setStages(Array(documentAssembler, OLMo))
+  *
+  * val data = Seq(
+  *   "My name is Leonardo."
+  * ).toDF("text")
+  * val result = pipeline.fit(data).transform(data)
+  *
+  * results.select("generation.result").show(truncate = false)
+  * +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * |result                                                                                                                                                                                              |
+  * +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * |[ My name is Leonardo . I am a student of the University of California, Berkeley. I am interested in the field of Artificial Intelligence and its applications in the real world. I have a strong   |
+  * | passion for learning and am always looking for ways to improve my knowledge and skills]                                                                                                            |
+  * +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * }}}
+  *
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+class OLMoTransformer(override val uid: String)
+    extends AnnotatorModel[OLMoTransformer]
+    with HasBatchedAnnotate[OLMoTransformer]
+    with ParamsAndFeaturesWritable
+    with WriteOnnxModel
+    with HasGeneratorProperties
+    with HasEngine {
+
+  def this() = this(Identifiable.randomUID("OLMoTRANSFORMER"))
+
+  /** Input annotator type : DOCUMENT
+    *
+    * @group param
+    */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(DOCUMENT)
+
+  /** Output annotator type : DOCUMENT
+    *
+    * @group param
+    */
+  override val outputAnnotatorType: String = DOCUMENT
+
+  /** @group setParam */
+  def setRandomSeed(value: Int): OLMoTransformer.this.type = {
+    if (randomSeed.isEmpty) {
+      this.randomSeed = Some(value)
+    }
+    this
+  }
+
+  /** A list of token ids which are ignored in the decoder's output (Default: `Array()`)
+    *
+    * @group param
+    */
+  var ignoreTokenIds = new IntArrayParam(
+    this,
+    "ignoreTokenIds",
+    "A list of token ids which are ignored in the decoder's output")
+
+  /** @group setParam */
+  def setIgnoreTokenIds(tokenIds: Array[Int]): OLMoTransformer.this.type = {
+    set(ignoreTokenIds, tokenIds)
+  }
+
+  /** @group getParam */
+  def getIgnoreTokenIds: Array[Int] = $(ignoreTokenIds)
+
+  /** Vocabulary used to encode the words to ids with bpeTokenizer.encode
+    *
+    * @group param
+    */
+  val vocabulary: MapFeature[String, Int] = new MapFeature(this, "vocabulary").setProtected()
+
+  /** @group setParam */
+  def setVocabulary(value: Map[String, Int]): this.type = set(vocabulary, value)
+
+  /** Holding merges.txt coming from RoBERTa model
+    *
+    * @group param
+    */
+  val merges: MapFeature[(String, String), Int] = new MapFeature(this, "merges").setProtected()
+
+  /** @group setParam */
+  def setMerges(value: Map[(String, String), Int]): this.type = set(merges, value)
+
+  private var _model: Option[Broadcast[OLMo]] = None
+
+  val generationConfig: StructFeature[GenerationConfig] =
+    new StructFeature(this, "generationConfig").setProtected()
+
+  def setGenerationConfig(value: GenerationConfig): this.type =
+    set(generationConfig, value)
+
+  def getGenerationConfig: GenerationConfig = $$(generationConfig)
+
+  /** @group setParam */
+  def setModelIfNotSet(spark: SparkSession, onnxWrappers: DecoderWrappers): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(
+        spark.sparkContext.broadcast(
+          new OLMo(
+            onnxWrappers,
+            $$(merges),
+            $$(vocabulary),
+            generationConfig = getGenerationConfig)))
+    }
+    this
+  }
+
+  /** @group getParam */
+  def getModelIfNotSet: OLMo = _model.get.value
+
+  setDefault(
+    minOutputLength -> 0,
+    maxOutputLength -> 20,
+    doSample -> false,
+    temperature -> 0.6,
+    topK -> 50,
+    topP -> 0.9,
+    repetitionPenalty -> 1.0,
+    noRepeatNgramSize -> 3,
+    ignoreTokenIds -> Array(),
+    batchSize -> 1,
+    beamSize -> 1,
+    maxInputLength -> 4096)
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations that correspond to inputAnnotationCols generated by previous annotators if any
+    * @return
+    *   any number of annotations processed for every input annotation. Not necessary one to one
+    *   relationship
+    */
+  override def batchAnnotate(batchedAnnotations: Seq[Array[Annotation]]): Seq[Seq[Annotation]] = {
+
+    val allAnnotations = batchedAnnotations
+      .filter(_.nonEmpty)
+      .zipWithIndex
+      .flatMap { case (annotations, i) =>
+        annotations.filter(_.result.nonEmpty).map(x => (x, i))
+      }
+    val processedAnnotations = if (allAnnotations.nonEmpty) {
+      this.getModelIfNotSet.predict(
+        sentences = allAnnotations.map(_._1),
+        batchSize = $(batchSize),
+        minOutputLength = $(minOutputLength),
+        maxOutputLength = $(maxOutputLength),
+        doSample = $(doSample),
+        temperature = $(temperature),
+        topK = $(topK),
+        topP = $(topP),
+        repetitionPenalty = $(repetitionPenalty),
+        noRepeatNgramSize = $(noRepeatNgramSize),
+        randomSeed = this.randomSeed,
+        ignoreTokenIds = $(ignoreTokenIds),
+        beamSize = $(beamSize),
+        maxInputLength = $(maxInputLength))
+    } else {
+      Seq()
+    }
+    Seq(processedAnnotations)
+  }
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getEngine match {
+      case ONNX.name =>
+        val wrappers = getModelIfNotSet.onnxWrappers
+        writeOnnxModels(
+          path,
+          spark,
+          Seq((wrappers.decoder, "decoder_model.onnx")),
+          OLMoTransformer.suffix)
+    }
+  }
+}
+
+trait ReadablePretrainedOLMoTransformerModel
+    extends ParamsAndFeaturesReadable[OLMoTransformer]
+    with HasPretrained[OLMoTransformer] {
+  override val defaultModelName: Some[String] = Some("olmo_1b_int4")
+
+  /** Java compliant-overrides */
+  override def pretrained(): OLMoTransformer = super.pretrained()
+
+  override def pretrained(name: String): OLMoTransformer = super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): OLMoTransformer =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): OLMoTransformer =
+    super.pretrained(name, lang, remoteLoc)
+}
+
+trait ReadOLMoTransformerDLModel extends ReadOnnxModel {
+  this: ParamsAndFeaturesReadable[OLMoTransformer] =>
+
+  override val onnxFile: String = "decoder_model.onnx"
+  val suffix: String = "_olmo"
+
+  def readModel(instance: OLMoTransformer, path: String, spark: SparkSession): Unit = {
+    instance.getEngine match {
+      case ONNX.name =>
+        val wrapper =
+          readOnnxModel(
+            path,
+            spark,
+            suffix,
+            zipped = true,
+            useBundle = false,
+            modelName = Some("decoder_model.onnx"),
+            dataFilePostfix = Some(".onnx_data"))
+        val onnxWrappers =
+          DecoderWrappers(decoder = wrapper)
+        instance.setModelIfNotSet(spark, onnxWrappers)
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(modelPath: String, spark: SparkSession): OLMoTransformer = {
+    implicit val formats: DefaultFormats.type = DefaultFormats // for json4
+    val (localModelPath, detectedEngine) =
+      modelSanityCheck(modelPath, isDecoder = true)
+    val modelConfig: JValue =
+      parse(loadJsonStringAsset(localModelPath, "config.json"))
+
+    val beginSuppressTokens: Array[Int] =
+      (modelConfig \ "begin_suppress_tokens").extract[Array[Int]]
+
+    val suppressTokenIds: Array[Int] =
+      (modelConfig \ "suppress_tokens").extract[Array[Int]]
+
+    val forcedDecoderIds: Array[(Int, Int)] =
+      (modelConfig \ "forced_decoder_ids").extract[Array[Array[Int]]].map {
+        case idxWithTokenId: Array[Int] if idxWithTokenId.length == 2 =>
+          (idxWithTokenId(0), idxWithTokenId(1))
+        case _ =>
+          throw new Exception(
+            "Could not extract forced_decoder_ids. Should be a list of tuples with 2 entries.")
+      }
+
+    def arrayOrNone[T](array: Array[T]): Option[Array[T]] =
+      if (array.nonEmpty) Some(array) else None
+
+    var bosTokenId = -1
+    try {
+      bosTokenId = (modelConfig \ "bos_token_id").extract[Int]
+    } catch {
+      case _: Exception =>
+        println("Could not extract bos_token_id from config.json, assigning default value -1")
+    }
+    val eosTokenId = (modelConfig \ "eos_token_id").extract[Int]
+    val padTokenId = (modelConfig \ "eos_token_id").extract[Int]
+    val vocabSize = (modelConfig \ "vocab_size").extract[Int]
+
+    val vocabs = loadTextAsset(localModelPath, "vocab.txt").zipWithIndex.toMap
+
+    val bytePairs = loadTextAsset(localModelPath, "merges.txt")
+      .map(_.split(" "))
+      .filter(w => w.length == 2)
+      .map { case Array(c1, c2) => (c1, c2) }
+      .zipWithIndex
+      .toMap
+
+    val annotatorModel = new OLMoTransformer()
+      .setGenerationConfig(
+        GenerationConfig(
+          bosTokenId,
+          padTokenId,
+          eosTokenId,
+          vocabSize,
+          arrayOrNone(beginSuppressTokens),
+          arrayOrNone(suppressTokenIds),
+          arrayOrNone(forcedDecoderIds)))
+      .setVocabulary(vocabs)
+      .setMerges(bytePairs)
+
+    annotatorModel.set(annotatorModel.engine, detectedEngine)
+
+    detectedEngine match {
+      case ONNX.name =>
+        val onnxWrapperDecoder =
+          OnnxWrapper.read(
+            spark,
+            localModelPath,
+            zipped = false,
+            useBundle = true,
+            modelName = "decoder_model",
+            dataFileSuffix = Some(".onnx_data"),
+            onnxFileSuffix = Some(suffix))
+
+        val onnxWrappers = DecoderWrappers(onnxWrapperDecoder)
+
+        annotatorModel
+          .setModelIfNotSet(spark, onnxWrappers)
+
+      case _ =>
+        throw new Exception(notSupportedEngineError)
+    }
+
+    annotatorModel
+  }
+
+}
+
+object OLMoTransformer
+    extends ReadablePretrainedOLMoTransformerModel
+    with ReadOLMoTransformerDLModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/BpeSpecialTokens.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/BpeSpecialTokens.scala
index 4afb1d5b9bf18c..4e790cf171a1cd 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/BpeSpecialTokens.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/BpeSpecialTokens.scala
@@ -137,6 +137,14 @@ private[johnsnowlabs] object SpecialTokens {
           unkTokenString = "",
           maskTokenString = "",
           padTokenString = "")
+      case "olmo" =>
+        SpecialTokens(
+          vocab,
+          startTokenString = "<|endoftext|>",
+          endTokenString = "<|endoftext|>",
+          unkTokenString = "<|endoftext|>",
+          maskTokenString = "<|endoftext|>",
+          padTokenString = "<|padding|>")
       case "clip" =>
         SpecialTokens(
           vocab,
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/BpeTokenizer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/BpeTokenizer.scala
index 8c72a8f99d6685..c46fda81597e11 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/BpeTokenizer.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/BpeTokenizer.scala
@@ -297,15 +297,16 @@ private[nlp] abstract class BpeTokenizer(
   def encode(indToken: IndexedToken): Array[TokenPiece] = {
     if (!specialTokens.contains(indToken.token))
       bpe(indToken)
-    else
+    else {
       Array(
         TokenPiece(
           indToken.token,
           indToken.token,
           vocab(indToken.token),
-          isWordStart = true,
+          isWordStart = false,
           indToken.begin,
           indToken.end))
+    }
   }
 
   def encode(indTokens: Array[IndexedToken]): Array[TokenPiece] = indTokens.flatMap(encode(_))
@@ -319,7 +320,8 @@ object BpeTokenizer {
       padWithSequenceTokens: Boolean = false,
       addPrefixSpaceToSentence: Boolean = false,
       specialTokens: Option[SpecialTokens] = None,
-      alwaysAddPrefix: Boolean = true): BpeTokenizer = {
+      alwaysAddPrefix: Boolean = true,
+      prependString: String = ""): BpeTokenizer = {
 
     def modelSpecialTokens() = specialTokens match {
       case Some(specialTok) => specialTok
@@ -352,6 +354,13 @@ object BpeTokenizer {
           modelSpecialTokens(),
           padWithSequenceTokens,
           addPrefixSpaceToSentence = addPrefixSpaceToSentence)
+      case "olmo" =>
+        new OLMoTokenizer(
+          merges,
+          vocab,
+          modelSpecialTokens(),
+          padWithSequenceTokens,
+          addPrefixSpaceToSentence = addPrefixSpaceToSentence)
       case "clip" =>
         new CLIPTokenizer(merges, vocab, modelSpecialTokens())
       case "phi2" =>
@@ -382,6 +391,47 @@ object BpeTokenizer {
           modelSpecialTokens(),
           padWithSequenceTokens,
           addPrefixSpaceToSentence = addPrefixSpaceToSentence)
+      case "Janus" =>
+        new JanusTokenizer(
+          merges,
+          vocab,
+          modelSpecialTokens(),
+          padWithSequenceTokens,
+          addPrefixSpaceToSentence = addPrefixSpaceToSentence,
+          alwaysAddPrefix = alwaysAddPrefix,
+          prependString = prependString)
+      case "mllama" =>
+        new MLLamaTokenizer(
+          merges,
+          vocab,
+          modelSpecialTokens(),
+          padWithSequenceTokens,
+          addPrefixSpaceToSentence = addPrefixSpaceToSentence)
+      case "qwen2vl" =>
+        new Qwen2VLTokenizer(
+          merges,
+          vocab,
+          modelSpecialTokens(),
+          padWithSequenceTokens,
+          addPrefixSpaceToSentence = addPrefixSpaceToSentence,
+          prependString = prependString)
+      case "llava" =>
+        new LLAVATokenizer(
+          merges,
+          vocab,
+          modelSpecialTokens(),
+          padWithSequenceTokens,
+          addPrefixSpaceToSentence = addPrefixSpaceToSentence,
+          prependString = prependString)
+      case "phi3v" =>
+        new Phi3VisionTokenizer(
+          merges,
+          vocab,
+          modelSpecialTokens(),
+          padWithSequenceTokens,
+          addPrefixSpaceToSentence = addPrefixSpaceToSentence,
+          alwaysAddPrefix = alwaysAddPrefix,
+          prependString = prependString)
       case _ =>
         throw new IllegalArgumentException("Model type \"" + modelType + "\" not supported yet.")
     }
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/JanusTokenizer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/JanusTokenizer.scala
new file mode 100644
index 00000000000000..d3960474dd8707
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/JanusTokenizer.scala
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.tokenizer.bpe
+
+import com.johnsnowlabs.nlp.annotators.common.IndexedToken
+
+import java.nio.charset.Charset
+import scala.collection.mutable.ListBuffer
+import scala.util.matching.Regex
+
+class JanusTokenizer(
+    merges: Map[(String, String), Int],
+    vocab: Map[String, Int],
+    specialTokens: SpecialTokens,
+    padWithSequenceTokens: Boolean = true,
+    prependString: String = "",
+    addPrefixSpaceToSentence: Boolean = false,
+    alwaysAddPrefix: Boolean = true,
+    splitPatternRegex: Regex =
+      raw"""(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+""".r)
+    extends BpeTokenizer(
+      merges,
+      vocab,
+      specialTokens,
+      padWithSequenceTokens,
+      addPrefixSpaceToSentence,
+      alwaysAddPrefix) {
+
+  /** Mapping for bytes to a different set of unicode characters (especially white spaces). This
+    * improved model performance for gpt-2
+    */
+  protected val bytesToUnicodeMapping: Map[Int, String] = {
+    val bytes: ListBuffer[Int] =
+      ListBuffer.range('!', '~' + 1) ++ ListBuffer.range('¡', '¬' + 1) ++ ListBuffer
+        .range('®', 'ÿ' + 1)
+    val characters: ListBuffer[Int] = bytes.clone
+    var n = 0
+    for (b <- 0 to 256) {
+      if (!bytes.contains(b)) {
+        bytes += b
+        characters += (256 + n)
+        n += 1
+      }
+    }
+    (bytes zip characters.map(_.toChar.toString)).toMap
+  }
+
+  // Differs from Transformers, space is always prepended.
+  // FIX: Space should not be prepended to all tokens, but to the beginning of the text only. Otherwise token
+  // such as '.' get space prepended and they should not.
+  override val prefixForPieceId: Option[String] =
+    if (prependString.nonEmpty) Some(prependString) else None
+
+  protected val decoderVocab: Map[Int, String] = vocab.map(x => (x._2, x._1))
+
+  protected val unicodeToByteMapping: Map[String, Int] =
+    bytesToUnicodeMapping.map(x => (x._2, x._1))
+
+  override def preProcessTokenForBpe(token: String): String = {
+    token
+      .getBytes("UTF-8")
+      .map { b => if (b < 0) 256 + b else b }
+      .foldLeft("")(_ + bytesToUnicodeMapping(_))
+  }
+
+  val splitPattern: Regex = splitPatternRegex
+
+  override def tokenizeSubText(text: String, indexOffset: Int): Array[IndexedToken] = {
+    // split pattern based on gpt2's bpe tokenizer
+    splitPattern
+      .findAllMatchIn(if (prefixForPieceId.isDefined || text.startsWith(" ")) text
+      else text) // Prepend space to the beginning of text
+      .map(tok => IndexedToken(tok.matched, tok.start + indexOffset, tok.end + indexOffset - 1))
+      .toArray
+  }
+
+  //  def decodeTokens(tokens: Array[Int]): String = {
+  //    val decoded = new mutable.StringBuilder()
+  //    tokens.foreach { token =>
+  //      {
+  //        val decodedToken = decoderVocab(token)
+  //        if (!specialTokens.contains(decodedToken)) {
+  //          if (decodedToken.startsWith("<0x") && decodedToken.endsWith(">")) {
+  //            val strippedHex = decodedToken.replaceAll("<0x|>", "")
+  //            val byteValue = Integer.parseInt(strippedHex, 16)
+  //            decoded.append(byteValue.toChar)
+  //          } else {
+  //            decoded.append(decodedToken)
+  //          }
+  //        }
+  //      }
+  //
+  //    }
+  //    decoded.toString().replaceAll(decoderVocab(29871), " ").trim()
+  //  }
+  def decodeTokens(tokens: Array[Int]): String = {
+    val text = tokens
+      .map(token => decoderVocab(token))
+      .filter(x => !specialTokens.contains(x))
+      .mkString("")
+
+    val bytes =
+      text.map(x => unicodeToByteMapping(x.toString)).map(x => x.toByte).toArray
+    new String(bytes, Charset.forName("UTF-8"))
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/LLAVATokenizer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/LLAVATokenizer.scala
new file mode 100644
index 00000000000000..4b2388b5524820
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/LLAVATokenizer.scala
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.tokenizer.bpe
+
+import com.johnsnowlabs.nlp.annotators.common.IndexedToken
+
+import java.nio.charset.Charset
+import scala.collection.mutable.ListBuffer
+import scala.util.matching.Regex
+import scala.collection.mutable
+
+class LLAVATokenizer(
+    merges: Map[(String, String), Int],
+    vocab: Map[String, Int],
+    specialTokens: SpecialTokens,
+    padWithSequenceTokens: Boolean = true,
+    prependString: String = "",
+    addPrefixSpaceToSentence: Boolean = false,
+    alwaysAddPrefix: Boolean = true,
+    splitPatternRegex: Regex =
+      raw"""(?i)(?:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+""".r)
+    extends BpeTokenizer(
+      merges,
+      vocab,
+      specialTokens,
+      padWithSequenceTokens,
+      addPrefixSpaceToSentence,
+      alwaysAddPrefix) {
+
+  /** Mapping for bytes to a different set of unicode characters (especially white spaces). This
+    * improved model performance for gpt-2
+    */
+  protected val bytesToUnicodeMapping: Map[Int, String] = {
+    val bytes: ListBuffer[Int] =
+      ListBuffer.range('!', '~' + 1) ++ ListBuffer.range('¡', '¬' + 1) ++ ListBuffer
+        .range('®', 'ÿ' + 1)
+    val characters: ListBuffer[Int] = bytes.clone
+    var n = 0
+    for (b <- 0 to 256) {
+      if (!bytes.contains(b)) {
+        bytes += b
+        characters += (256 + n)
+        n += 1
+      }
+    }
+    (bytes zip characters.map(_.toChar.toString)).toMap
+  }
+
+  // Differs from Transformers, space is always prepended.
+  // FIX: Space should not be prepended to all tokens, but to the beginning of the text only. Otherwise token
+  // such as '.' get space prepended and they should not.
+  override val prefixForPieceId: Option[String] =
+    if (prependString.nonEmpty) Some(prependString) else None
+
+  protected val decoderVocab: Map[Int, String] = vocab.map(x => (x._2, x._1))
+
+  protected val unicodeToByteMapping: Map[String, Int] =
+    bytesToUnicodeMapping.map(x => (x._2, x._1))
+
+  override def preProcessTokenForBpe(token: String): String = {
+    token
+      .getBytes("UTF-8")
+      .map { b => if (b < 0) 256 + b else b }
+      .foldLeft("")(_ + bytesToUnicodeMapping(_))
+  }
+
+  val splitPattern: Regex = splitPatternRegex
+
+  override def tokenizeSubText(text: String, indexOffset: Int): Array[IndexedToken] = {
+    // split pattern based on gpt2's bpe tokenizer
+    splitPattern
+      .findAllMatchIn(if (prefixForPieceId.isDefined || text.startsWith(" ")) text
+      else " " + text) // Prepend space to the beginning of text
+      .map(tok => IndexedToken(tok.matched, tok.start + indexOffset, tok.end + indexOffset - 1))
+      .toArray
+  }
+
+  def decodeTokens(tokens: Array[Int]): String = {
+    val decoded = new mutable.StringBuilder()
+    tokens.foreach { token =>
+      {
+        val decodedToken = decoderVocab(token)
+        if (!specialTokens.contains(decodedToken)) {
+          if (decodedToken.startsWith("<0x") && decodedToken.endsWith(">")) {
+            val strippedHex = decodedToken.replaceAll("<0x|>", "")
+            val byteValue = Integer.parseInt(strippedHex, 16)
+            decoded.append(byteValue.toChar)
+          } else {
+            decoded.append(decodedToken)
+          }
+        }
+      }
+
+    }
+    decoded.toString().replaceAll(decoderVocab(29871), " ").trim()
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/MLLamaTokenizer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/MLLamaTokenizer.scala
new file mode 100644
index 00000000000000..ee3cfe9be15173
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/MLLamaTokenizer.scala
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.tokenizer.bpe
+
+import com.johnsnowlabs.nlp.annotators.common.IndexedToken
+
+import java.nio.charset.Charset
+import scala.collection.mutable.ListBuffer
+import scala.util.matching.Regex
+import scala.collection.mutable
+
+class MLLamaTokenizer(
+    merges: Map[(String, String), Int],
+    vocab: Map[String, Int],
+    specialTokens: SpecialTokens,
+    padWithSequenceTokens: Boolean = true,
+    prependString: String = "",
+    addPrefixSpaceToSentence: Boolean = false,
+    alwaysAddPrefix: Boolean = false,
+    splitPatternRegex: Regex =
+      raw"""(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+""".r)
+    extends BpeTokenizer(
+      merges,
+      vocab,
+      specialTokens,
+      padWithSequenceTokens,
+      addPrefixSpaceToSentence,
+      alwaysAddPrefix) {
+
+  /** Mapping for bytes to a different set of unicode characters (especially white spaces). This
+    * improved model performance for gpt-2
+    */
+  protected val bytesToUnicodeMapping: Map[Int, String] = {
+    val bytes: ListBuffer[Int] =
+      ListBuffer.range('!', '~' + 1) ++ ListBuffer.range('¡', '¬' + 1) ++ ListBuffer
+        .range('®', 'ÿ' + 1)
+    val characters: ListBuffer[Int] = bytes.clone
+    var n = 0
+    for (b <- 0 to 256) {
+      if (!bytes.contains(b)) {
+        bytes += b
+        characters += (256 + n)
+        n += 1
+      }
+    }
+    (bytes zip characters.map(_.toChar.toString)).toMap
+  }
+
+  // Differs from Transformers, space is always prepended.
+  // FIX: Space should not be prepended to all tokens, but to the beginning of the text only. Otherwise token
+  // such as '.' get space prepended and they should not.
+  override val prefixForPieceId: Option[String] =
+    if (prependString.nonEmpty) Some(prependString) else None
+
+  protected val decoderVocab: Map[Int, String] = vocab.map(x => (x._2, x._1))
+
+  protected val unicodeToByteMapping: Map[String, Int] =
+    bytesToUnicodeMapping.map(x => (x._2, x._1))
+
+  override def preProcessTokenForBpe(token: String): String = {
+    token
+      .getBytes("UTF-8")
+      .map { b => if (b < 0) 256 + b else b }
+      .foldLeft("")(_ + bytesToUnicodeMapping(_))
+  }
+
+  val splitPattern: Regex = splitPatternRegex
+
+  override def tokenizeSubText(text: String, indexOffset: Int): Array[IndexedToken] = {
+    // split pattern based on gpt2's bpe tokenizer
+    splitPattern
+      .findAllMatchIn(if (prefixForPieceId.isDefined || text.startsWith(" ")) text
+      else text) // Prepend space to the beginning of text
+      .map(tok => IndexedToken(tok.matched, tok.start + indexOffset, tok.end + indexOffset - 1))
+      .toArray
+  }
+
+//  def decodeTokens(tokens: Array[Int]): String = {
+//    val decoded = new mutable.StringBuilder()
+//    tokens.foreach { token =>
+//      {
+//        val decodedToken = decoderVocab(token)
+//        if (!specialTokens.contains(decodedToken)) {
+//          if (decodedToken.startsWith("<0x") && decodedToken.endsWith(">")) {
+//            val strippedHex = decodedToken.replaceAll("<0x|>", "")
+//            val byteValue = Integer.parseInt(strippedHex, 16)
+//            decoded.append(byteValue.toChar)
+//          } else {
+//            decoded.append(decodedToken)
+//          }
+//        }
+//      }
+//
+//    }
+//    decoded.toString().replaceAll(decoderVocab(29871), " ").trim()
+//  }
+  def decodeTokens(tokens: Array[Int]): String = {
+    val text = tokens
+      .map(token => decoderVocab(token))
+      .filter(x => !specialTokens.contains(x))
+      .mkString("")
+
+    val bytes =
+      text.map(x => unicodeToByteMapping(x.toString)).map(x => x.toByte).toArray
+    new String(bytes, Charset.forName("UTF-8"))
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/OLMoTokenizer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/OLMoTokenizer.scala
new file mode 100644
index 00000000000000..95f046f5913670
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/OLMoTokenizer.scala
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2017-2023 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.tokenizer.bpe
+
+class OLMoTokenizer(
+    merges: Map[(String, String), Int],
+    vocab: Map[String, Int],
+    specialTokens: SpecialTokens,
+    padWithSequenceTokens: Boolean = false,
+    addPrefixSpaceToSentence: Boolean = false)
+    extends Gpt2Tokenizer(
+      merges,
+      vocab,
+      specialTokens,
+      padWithSequenceTokens,
+      prependString = "Ġ",
+      addPrefixSpaceToSentence)
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/Phi3VisionTokenizer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/Phi3VisionTokenizer.scala
new file mode 100644
index 00000000000000..9a2318dcd88b16
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/Phi3VisionTokenizer.scala
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.tokenizer.bpe
+
+import com.johnsnowlabs.nlp.annotators.common.IndexedToken
+
+import java.nio.charset.Charset
+import scala.collection.mutable.ListBuffer
+import scala.util.matching.Regex
+import scala.collection.mutable
+
+class Phi3VisionTokenizer(
+    merges: Map[(String, String), Int],
+    vocab: Map[String, Int],
+    specialTokens: SpecialTokens,
+    padWithSequenceTokens: Boolean = true,
+    prependString: String = "",
+    addPrefixSpaceToSentence: Boolean = false,
+    alwaysAddPrefix: Boolean = true,
+    splitPatternRegex: Regex =
+      raw"""(?i)(?:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+""".r)
+    extends BpeTokenizer(
+      merges,
+      vocab,
+      specialTokens,
+      padWithSequenceTokens,
+      addPrefixSpaceToSentence,
+      alwaysAddPrefix) {
+
+  /** Mapping for bytes to a different set of unicode characters (especially white spaces). This
+    * improved model performance for gpt-2
+    */
+  protected val bytesToUnicodeMapping: Map[Int, String] = {
+    val bytes: ListBuffer[Int] =
+      ListBuffer.range('!', '~' + 1) ++ ListBuffer.range('¡', '¬' + 1) ++ ListBuffer
+        .range('®', 'ÿ' + 1)
+    val characters: ListBuffer[Int] = bytes.clone
+    var n = 0
+    for (b <- 0 to 256) {
+      if (!bytes.contains(b)) {
+        bytes += b
+        characters += (256 + n)
+        n += 1
+      }
+    }
+    (bytes zip characters.map(_.toChar.toString)).toMap
+  }
+
+  // Differs from Transformers, space is always prepended.
+  // FIX: Space should not be prepended to all tokens, but to the beginning of the text only. Otherwise token
+  // such as '.' get space prepended and they should not.
+  override val prefixForPieceId: Option[String] =
+    if (prependString.nonEmpty) Some(prependString) else None
+
+  protected val decoderVocab: Map[Int, String] = vocab.map(x => (x._2, x._1))
+
+  protected val unicodeToByteMapping: Map[String, Int] =
+    bytesToUnicodeMapping.map(x => (x._2, x._1))
+
+  override def preProcessTokenForBpe(token: String): String = {
+    token
+      .getBytes("UTF-8")
+      .map { b => if (b < 0) 256 + b else b }
+      .foldLeft("")(_ + bytesToUnicodeMapping(_))
+  }
+
+  val splitPattern: Regex = splitPatternRegex
+
+  override def tokenizeSubText(text: String, indexOffset: Int): Array[IndexedToken] = {
+    // split pattern based on gpt2's bpe tokenizer
+    splitPattern
+      .findAllMatchIn(if (prefixForPieceId.isDefined || text.startsWith(" ")) text
+      else " " + text) // Prepend space to the beginning of text
+      .map(tok => IndexedToken(tok.matched, tok.start + indexOffset, tok.end + indexOffset - 1))
+      .toArray
+  }
+
+  def decodeTokens(tokens: Array[Int]): String = {
+    val decoded = new mutable.StringBuilder()
+    tokens.foreach { token =>
+      {
+        val decodedToken = decoderVocab(token)
+        if (!specialTokens.contains(decodedToken)) {
+          if (decodedToken.startsWith("<0x") && decodedToken.endsWith(">")) {
+            val strippedHex = decodedToken.replaceAll("<0x|>", "")
+            val byteValue = Integer.parseInt(strippedHex, 16)
+            decoded.append(byteValue.toChar)
+          } else {
+            decoded.append(decodedToken)
+          }
+        }
+      }
+
+    }
+    decoded.toString().replaceAll(decoderVocab(29871), " ").trim()
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/Qwen2VLTokenizer.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/Qwen2VLTokenizer.scala
new file mode 100644
index 00000000000000..98ca09b2d28118
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/tokenizer/bpe/Qwen2VLTokenizer.scala
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.tokenizer.bpe
+
+import com.johnsnowlabs.nlp.annotators.common.IndexedToken
+
+import java.nio.charset.Charset
+import scala.collection.mutable.ListBuffer
+import scala.util.matching.Regex
+import scala.collection.mutable
+
+class Qwen2VLTokenizer(
+    merges: Map[(String, String), Int],
+    vocab: Map[String, Int],
+    specialTokens: SpecialTokens,
+    padWithSequenceTokens: Boolean = true,
+    prependString: String = "",
+    addPrefixSpaceToSentence: Boolean = false,
+    alwaysAddPrefix: Boolean = true,
+    splitPatternRegex: Regex =
+      raw"""(?i)(?:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+""".r)
+    extends BpeTokenizer(
+      merges,
+      vocab,
+      specialTokens,
+      padWithSequenceTokens,
+      addPrefixSpaceToSentence,
+      alwaysAddPrefix) {
+
+  /** Mapping for bytes to a different set of unicode characters (especially white spaces). This
+    * improved model performance for gpt-2
+    */
+  protected val bytesToUnicodeMapping: Map[Int, String] = {
+    val bytes: ListBuffer[Int] =
+      ListBuffer.range('!', '~' + 1) ++ ListBuffer.range('¡', '¬' + 1) ++ ListBuffer
+        .range('®', 'ÿ' + 1)
+    val characters: ListBuffer[Int] = bytes.clone
+    var n = 0
+    for (b <- 0 to 256) {
+      if (!bytes.contains(b)) {
+        bytes += b
+        characters += (256 + n)
+        n += 1
+      }
+    }
+    (bytes zip characters.map(_.toChar.toString)).toMap
+  }
+
+  // Differs from Transformers, space is always prepended.
+  // FIX: Space should not be prepended to all tokens, but to the beginning of the text only. Otherwise token
+  // such as '.' get space prepended and they should not.
+  override val prefixForPieceId: Option[String] =
+    if (prependString.nonEmpty) Some(prependString) else None
+
+  protected val decoderVocab: Map[Int, String] = vocab.map(x => (x._2, x._1))
+
+  protected val unicodeToByteMapping: Map[String, Int] =
+    bytesToUnicodeMapping.map(x => (x._2, x._1))
+
+  override def preProcessTokenForBpe(token: String): String = {
+    token
+      .getBytes("UTF-8")
+      .map { b => if (b < 0) 256 + b else b }
+      .foldLeft("")(_ + bytesToUnicodeMapping(_))
+  }
+
+  val splitPattern: Regex = splitPatternRegex
+
+  override def tokenizeSubText(text: String, indexOffset: Int): Array[IndexedToken] = {
+    // split pattern based on gpt2's bpe tokenizer
+    splitPattern
+      .findAllMatchIn(if (prefixForPieceId.isDefined || text.startsWith(" ")) text
+      else " " + text) // Prepend space to the beginning of text
+      .map(tok => IndexedToken(tok.matched, tok.start + indexOffset, tok.end + indexOffset - 1))
+      .toArray
+  }
+
+  def decodeTokens(tokens: Array[Int]): String = {
+    val text = tokens
+      .map(token => decoderVocab(token))
+      .filter(x => !specialTokens.contains(x))
+      .mkString("")
+
+    val bytes =
+      text.map(x => unicodeToByteMapping(x.toString)).map(x => x.toByte).toArray
+    new String(bytes, Charset.forName("UTF-8"))
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/embeddings/AutoGGUFEmbeddings.scala b/src/main/scala/com/johnsnowlabs/nlp/embeddings/AutoGGUFEmbeddings.scala
index 98aa10eb8b31ac..389166a7ad10f6 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/embeddings/AutoGGUFEmbeddings.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/embeddings/AutoGGUFEmbeddings.scala
@@ -142,6 +142,16 @@ class AutoGGUFEmbeddings(override val uid: String)
     nCtx -> 4096,
     nBatch -> 512)
 
+  /** Sets the number of parallel processes for decoding. This is an alias for `setBatchSize`.
+    *
+    * @group setParam
+    * @param nParallel
+    *   The number of parallel processes for decoding
+    */
+  def setNParallel(nParallel: Int): this.type = {
+    setBatchSize(nParallel)
+  }
+
   override def onWrite(path: String, spark: SparkSession): Unit = {
     super.onWrite(path, spark)
     getModelIfNotSet.saveToFile(path)
@@ -175,7 +185,9 @@ class AutoGGUFEmbeddings(override val uid: String)
         } catch {
           case e: Exception =>
             logger.error("Error in llama.cpp embeddings", e)
-            (Array.empty[Array[Float]], Map("llamacpp_exception" -> e.getMessage))
+            (
+              Array.fill[Array[Float]](annotationsText.length)(Array.empty),
+              Map("llamacpp_exception" -> e.getMessage))
         }
 
       // Choose empty text for result annotations
@@ -196,7 +208,7 @@ class AutoGGUFEmbeddings(override val uid: String)
 trait ReadablePretrainedAutoGGUFEmbeddings
     extends ParamsAndFeaturesReadable[AutoGGUFEmbeddings]
     with HasPretrained[AutoGGUFEmbeddings] {
-  override val defaultModelName: Some[String] = Some("nomic-embed-text-v1.5.Q8_0.gguf")
+  override val defaultModelName: Some[String] = Some("Nomic_Embed_Text_v1.5.Q8_0.gguf")
   override val defaultLang: String = "en"
 
   /** Java compliant-overrides */
diff --git a/src/main/scala/com/johnsnowlabs/nlp/pretrained/ResourceDownloader.scala b/src/main/scala/com/johnsnowlabs/nlp/pretrained/ResourceDownloader.scala
index 0e457d4d6e20df..e64758e67e1256 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/pretrained/ResourceDownloader.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/pretrained/ResourceDownloader.scala
@@ -697,7 +697,15 @@ object PythonResourceDownloader {
     "NLLBTransformer" -> NLLBTransformer,
     "Phi3Transformer" -> Phi3Transformer,
     "QwenTransformer" -> QwenTransformer,
-    "AutoGGUFEmbeddings" -> AutoGGUFEmbeddings)
+    "AutoGGUFEmbeddings" -> AutoGGUFEmbeddings,
+    "AutoGGUFVisionModel" -> AutoGGUFVisionModel,
+    "MLLamaForMultimodal" -> MLLamaForMultimodal,
+    "Qwen2VLTransformer" -> Qwen2VLTransformer,
+    "CoHereTransformer" -> CoHereTransformer,
+    "LLAVAForMultiModal" -> LLAVAForMultiModal,
+    "Phi3Vision" -> Phi3Vision,
+    "OLMoTransformer" -> OLMoTransformer,
+    "JanusForMultiModal" -> JanusForMultiModal)
 
   // List pairs of types such as the one with key type can load a pretrained model from the value type
   val typeMapper: Map[String, String] = Map("ZeroShotNerModel" -> "RoBertaForQuestionAnswering")
diff --git a/src/main/scala/com/johnsnowlabs/partition/BaseChunker.scala b/src/main/scala/com/johnsnowlabs/partition/BaseChunker.scala
new file mode 100644
index 00000000000000..b915d6fa43ed4d
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/partition/BaseChunker.scala
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.partition
+
+import com.johnsnowlabs.partition.BasicChunker.chunkBasic
+import com.johnsnowlabs.reader.HTMLElement
+import com.johnsnowlabs.reader.util.PartitionOptions.{getDefaultInt, getDefaultString}
+import org.apache.spark.sql.Row
+import org.apache.spark.sql.expressions.UserDefinedFunction
+import org.apache.spark.sql.functions.udf
+
+import scala.collection.mutable
+
+class BaseChunker(chunkerOptions: Map[String, String]) extends Serializable {
+
+  def chunkUDF(): UserDefinedFunction = {
+    udf((elements: Seq[Row]) => {
+      val htmlElements = elements.map { row =>
+        val elementType = row.getAs[String]("elementType")
+        val content = row.getAs[String]("content")
+        val metadata = row.getAs[Map[String, String]]("metadata")
+        HTMLElement(elementType, content, mutable.Map.empty ++ metadata)
+      }.toList
+
+      val chunks = getChunkerStrategy match {
+        case "basic" => chunkBasic(htmlElements, getMaxCharacters, getNewAfterNChars, getOverlap)
+        case _ =>
+          throw new IllegalArgumentException(s"Unknown chunker strategy: $getChunkerStrategy")
+      }
+
+      chunks.flatMap(_.elements)
+    })
+  }
+
+  private def getMaxCharacters: Int = {
+    getDefaultInt(chunkerOptions, Seq("maxCharacters", "max_characters"), default = 500)
+  }
+
+  private def getNewAfterNChars: Int = {
+    getDefaultInt(chunkerOptions, Seq("newAfterNChars", "new_after_n_chars"), default = -1)
+  }
+
+  private def getOverlap: Int = {
+    getDefaultInt(chunkerOptions, Seq("overlap", "overlap"), default = 0)
+  }
+
+  private def getChunkerStrategy: String = {
+    getDefaultString(chunkerOptions, Seq("chunkingStrategy", "chunking_strategy"), default = "none")
+  }
+
+}
\ No newline at end of file
diff --git a/src/main/scala/com/johnsnowlabs/partition/BasicChunker.scala b/src/main/scala/com/johnsnowlabs/partition/BasicChunker.scala
new file mode 100644
index 00000000000000..e69a1c86b779b0
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/partition/BasicChunker.scala
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.partition
+
+import com.johnsnowlabs.reader.HTMLElement
+
+import scala.collection.mutable
+
+case class Chunk(elements: List[HTMLElement]) {
+  def length: Int = elements.map(_.content.length).sum
+}
+
+object BasicChunker {
+
+  def chunkBasic(
+                  elements: List[HTMLElement],
+                  maxCharacters: Int,
+                  newAfterNChars: Int = -1,
+                  overlap: Int = 0
+                ): List[Chunk] = {
+    val softLimit = if (newAfterNChars > 0) newAfterNChars else maxCharacters
+    var currentChunk = List.empty[HTMLElement]
+    var currentLength = 0
+    val chunks = mutable.ListBuffer.empty[Chunk]
+
+    def finalizeChunk(): Unit = {
+      if (currentChunk.nonEmpty) {
+        chunks += Chunk(currentChunk)
+        currentChunk = List.empty[HTMLElement]
+        currentLength = 0
+      }
+    }
+
+    for (element <- elements) {
+      val elLength = element.content.length
+
+      if (elLength > maxCharacters) {
+        val splitElements = splitHTMLElement(element, maxCharacters, overlap)
+        for (splitEl <- splitElements) {
+          if (currentLength + splitEl.content.length > maxCharacters || currentLength >= softLimit) finalizeChunk()
+          currentChunk :+= splitEl
+          currentLength += splitEl.content.length
+        }
+      } else if (currentLength + elLength > maxCharacters || currentLength >= softLimit) {
+        finalizeChunk()
+        currentChunk :+= element
+        currentLength += elLength
+      } else {
+        currentChunk :+= element
+        currentLength += elLength
+      }
+    }
+
+    finalizeChunk()
+    chunks.toList
+  }
+
+  private def splitHTMLElement(element: HTMLElement, maxLen: Int, overlap: Int): List[HTMLElement] = {
+    val words = element.content.split(" ")
+    val buffer = mutable.ListBuffer.empty[HTMLElement]
+    var chunk = new StringBuilder
+
+    for (word <- words) {
+      if (chunk.length + word.length + 1 > maxLen) {
+        val text = chunk.toString().trim
+        buffer += element.copy(content = text)
+        chunk = new StringBuilder
+        if (overlap > 0 && text.length >= overlap)
+          chunk.append(text.takeRight(overlap)).append(" ")
+      }
+      chunk.append(word).append(" ")
+    }
+
+    if (chunk.nonEmpty)
+      buffer += element.copy(content = chunk.toString().trim)
+
+    buffer.toList
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/partition/Partition.scala b/src/main/scala/com/johnsnowlabs/partition/Partition.scala
new file mode 100644
index 00000000000000..1bb61dd0abca17
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/partition/Partition.scala
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.partition
+
+import com.johnsnowlabs.reader.SparkNLPReader
+import org.apache.spark.sql.DataFrame
+
+import java.net.URL
+import scala.collection.JavaConverters._
+import scala.util.Try
+
+//TODO: Add notebook examples for this pipeline uses cases
+class Partition(params: java.util.Map[String, String] = new java.util.HashMap()) {
+
+  def partition(
+      path: String,
+      headers: java.util.Map[String, String] = new java.util.HashMap()): DataFrame = {
+    val sparkNLPReader = new SparkNLPReader(params, headers)
+    if (isUrl(path)) {
+      return sparkNLPReader.html(path)
+    }
+
+    val reader = getContentType match {
+      case Some(contentType) => getReaderByContentType(contentType, sparkNLPReader)
+      case None => getReaderByExtension(path, sparkNLPReader)
+    }
+
+    val partitionResult = reader(path)
+    if (hasChunkerStrategy) {
+      val chunker = new BaseChunker(params.asScala.toMap)
+      //TODO: Send column name to partitionResult dynamically
+      partitionResult.withColumn("chunks", chunker.chunkUDF()(partitionResult("txt")))
+    } else partitionResult
+  }
+
+  private def getReaderByContentType(
+      contentType: String,
+      sparkNLPReader: SparkNLPReader): String => DataFrame = {
+    contentType match {
+      case "text/plain" => sparkNLPReader.txt
+      case "text/html" => sparkNLPReader.html
+      case "message/rfc822" => sparkNLPReader.email
+      case "application/msword" |
+          "application/vnd.openxmlformats-officedocument.wordprocessingml.document" =>
+        sparkNLPReader.doc
+      case "application/vnd.ms-excel" |
+          "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" =>
+        sparkNLPReader.xls
+      case "application/vnd.ms-powerpoint" |
+          "application/vnd.openxmlformats-officedocument.presentationml.presentation" =>
+        sparkNLPReader.ppt
+      case "application/pdf" => sparkNLPReader.pdf
+      case "application/xml" | "text/xml" => sparkNLPReader.xml
+      case _ => throw new IllegalArgumentException(s"Unsupported content type: $contentType")
+    }
+  }
+
+  private def getReaderByExtension(
+      path: String,
+      sparkNLPReader: SparkNLPReader): String => DataFrame = {
+    val extension = getFileExtension(path)
+    extension match {
+      case "txt" => sparkNLPReader.txt
+      case "html" | "htm" => sparkNLPReader.html
+      case "eml" | "msg" => sparkNLPReader.email
+      case "doc" | "docx" => sparkNLPReader.doc
+      case "xls" | "xlsx" => sparkNLPReader.xls
+      case "ppt" | "pptx" => sparkNLPReader.ppt
+      case "pdf" => sparkNLPReader.pdf
+      case "xml" => sparkNLPReader.xml
+      case _ => throw new IllegalArgumentException(s"Unsupported file type: $extension")
+    }
+  }
+
+  def partitionUrls(urls: Array[String], headers: Map[String, String] = Map.empty): DataFrame = {
+    if (urls.isEmpty) throw new IllegalArgumentException("URL array is empty")
+    val sparkNLPReader = new SparkNLPReader(params, headers.asJava)
+    sparkNLPReader.html(urls)
+  }
+
+  def partitionUrlsJava(
+      urls: java.util.List[String],
+      headers: java.util.Map[String, String] = new java.util.HashMap()): DataFrame = {
+    partitionUrls(urls.asScala.toArray, headers.asScala.toMap)
+  }
+
+  def partitionText(text: String): DataFrame = {
+    val sparkNLPReader = new SparkNLPReader(params)
+    sparkNLPReader.txtContent(text)
+  }
+
+  private def getFileExtension(path: String): String = {
+    path.split("\\.").lastOption.map(_.toLowerCase).getOrElse("")
+  }
+
+  private def isUrl(path: String): Boolean = {
+    try {
+      val url = new URL(path)
+      url.getProtocol == "http" || url.getProtocol == "https"
+    } catch {
+      case _: Exception => false
+    }
+  }
+
+  private def getContentType: Option[String] = {
+    Seq("content_type", "ContentType")
+      .flatMap(key => Option(params.get(key)))
+      .flatMap(value => Try(value).toOption)
+      .headOption
+  }
+
+  import scala.jdk.CollectionConverters._
+
+  private def hasChunkerStrategy: Boolean = {
+    Seq("chunking_strategy", "chunkingStrategy")
+      .exists(params.asScala.contains)
+  }
+
+}
+
+object Partition {
+  def apply(params: Map[String, String] = Map.empty): Partition = {
+    new Partition(mapAsJavaMap(params))
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/partition/PartitionTransformer.scala b/src/main/scala/com/johnsnowlabs/partition/PartitionTransformer.scala
new file mode 100644
index 00000000000000..1ace6a686f4e3c
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/partition/PartitionTransformer.scala
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.partition
+
+import com.johnsnowlabs.nlp.AnnotatorType.{CHUNK, DOCUMENT}
+import com.johnsnowlabs.nlp.{Annotation, AnnotatorModel, HasSimpleAnnotate}
+import com.johnsnowlabs.reader.{HTMLElement, TextReader}
+import org.apache.spark.ml.PipelineModel
+import org.apache.spark.ml.param.Param
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.functions.{col, udf}
+import org.apache.spark.sql.types.{ArrayType, StructType}
+import org.apache.spark.sql.{DataFrame, Dataset, Encoders, Row}
+import org.apache.spark.sql.functions.explode
+import org.slf4j.{Logger, LoggerFactory}
+
+class PartitionTransformer(override val uid: String)
+  extends AnnotatorModel[PartitionTransformer]
+  with HasSimpleAnnotate[PartitionTransformer] {
+
+  def this() = this(Identifiable.randomUID("PartitionTransformer"))
+  protected val logger: Logger = LoggerFactory.getLogger(getClass.getName)
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+   * type
+   */
+  override val inputAnnotatorTypes: Array[AnnotatorType] = Array(DOCUMENT)
+  override val outputAnnotatorType: AnnotatorType = DOCUMENT
+
+  override def setInputCols(value: Array[String]): this.type = {
+    val validAnnotatorTypes = Array(DOCUMENT, CHUNK)
+    require(
+      value.length == inputAnnotatorTypes.length,
+      s"setInputCols in ${this.uid} expecting ${inputAnnotatorTypes.length} columns. " +
+        s"Provided column amount: ${value.length}. " +
+        s"Which should be columns from one of the following annotators: ${validAnnotatorTypes.mkString(", ")} ")
+    set(inputCols, value)
+  }
+
+//  override def getInputCols: Array[String] = $(inputCols)
+
+  val contentPath = new Param[String](this, "contentPath", "Path to the content source")
+
+  def setContentPath(value: String): this.type = set(contentPath, value)
+
+  setDefault(contentPath, "")
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+   * type
+   *
+   * @param annotations
+   * Annotations that correspond to inputAnnotationCols generated by previous annotators if any
+   * @return
+   * any number of annotations processed for every input annotation. Not necessary one to one
+   * relationship
+   */
+  override def annotate(annotations: Seq[Annotation]): Seq[Annotation] = {
+    annotations
+  }
+
+  override def _transform(dataset: Dataset[_], recursivePipeline: Option[PipelineModel]): DataFrame = {
+    val partitionDf = if ($(contentPath).isEmpty) {
+      val textColum = $(inputCols).head
+      val flattenDf = dataset.withColumn("flatten_result", explode(col(s"$textColum.result")))
+      val textReader = new TextReader()
+      val parseTxtUDF = udf((text: String) => textReader.parseTxt(text))
+      flattenDf.withColumn(
+        "txt",
+        parseTxtUDF(col("flatten_result"))
+      ).drop("flatten_result")
+    } else {
+      Partition().partition($(contentPath))
+    }
+    val colName = findHTMLElementColumn(partitionDf).getOrElse {
+      val schemaString = partitionDf.schema.treeString
+      throw new Exception(
+        s"""❌ No column of type Array[HTMLElement] was found in the DataFrame.
+           |
+           |💡 Expected a column with schema matching: Array[HTMLElement]
+           |
+           |🧪 DataFrame Schema:
+           |$schemaString
+           |
+           |👉 Make sure at least one column is an Array of structs with fields:
+           |  - elementType: String
+           |  - content: String
+           |  - metadata: Map[String, String]
+     """.stripMargin)
+    }
+    partitionDf.withColumn(
+      getOutputCol,
+      wrapColumnMetadata(convertToAnnotations(col(colName)))
+    )
+  }
+
+  private def convertToAnnotations = udf { elements: Seq[Row] =>
+    elements.map { row =>
+      val content = row.getAs[String]("content")
+      val metadata = row.getAs[Map[String, String]]("metadata")
+
+      val begin = 0
+      val end = if (content != null) content.length - 1 else 0
+
+      Annotation(
+        annotatorType = DOCUMENT,
+        begin = begin,
+        end = end,
+        result = content,
+        metadata = metadata,
+        embeddings = Array.emptyFloatArray
+      )
+    }
+  }
+
+  private def findHTMLElementColumn(df: org.apache.spark.sql.DataFrame): Option[String] = {
+    val htmlElementSchema = Encoders.product[HTMLElement].schema
+    df.schema.fields.find { field =>
+      field.dataType match {
+        case ArrayType(structType: StructType, _) =>
+          structType == htmlElementSchema
+        case _ => false
+      }
+    }.map(_.name)
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/ElementType.scala b/src/main/scala/com/johnsnowlabs/reader/ElementType.scala
index 0041f0ef3ca2df..e97f58a8c910ee 100644
--- a/src/main/scala/com/johnsnowlabs/reader/ElementType.scala
+++ b/src/main/scala/com/johnsnowlabs/reader/ElementType.scala
@@ -28,4 +28,5 @@ object ElementType {
   val LIST_ITEM = "ListItem"
   val HEADER = "Header"
   val FOOTER = "Footer"
+  val HTML = "HTML"
 }
diff --git a/src/main/scala/com/johnsnowlabs/reader/EmailReader.scala b/src/main/scala/com/johnsnowlabs/reader/EmailReader.scala
index 76ed05e6b5815e..993058a0a7c5b3 100644
--- a/src/main/scala/com/johnsnowlabs/reader/EmailReader.scala
+++ b/src/main/scala/com/johnsnowlabs/reader/EmailReader.scala
@@ -26,7 +26,8 @@ import java.util.Properties
 import scala.collection.mutable
 import scala.collection.mutable.ArrayBuffer
 
-class EmailReader(addAttachmentContent: Boolean = false) extends Serializable {
+class EmailReader(addAttachmentContent: Boolean = false, storeContent: Boolean = false)
+    extends Serializable {
 
   private val spark = ResourceHelper.spark
   import spark.implicits._
@@ -38,9 +39,11 @@ class EmailReader(addAttachmentContent: Boolean = false) extends Serializable {
         val byteArray = portableDataStream.toArray()
         (path, byteArray)
       }
-      byteArrayRDD
+      val emailDf = byteArrayRDD
         .toDF("path", "content")
         .withColumn("email", parseEmailUDF(col("content")))
+      if (storeContent) emailDf.select("path", "email", "content")
+      else emailDf.select("path", "email")
     } else throw new IllegalArgumentException(s"Invalid filePath: $filePath")
   }
 
diff --git a/src/main/scala/com/johnsnowlabs/reader/ExcelReader.scala b/src/main/scala/com/johnsnowlabs/reader/ExcelReader.scala
new file mode 100644
index 00000000000000..4025c6c74a6180
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/ExcelReader.scala
@@ -0,0 +1,222 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.reader.util.XlsxParser.{RichCell, RichRow, RichSheet}
+import org.apache.poi.hssf.usermodel.{HSSFSheet, HSSFWorkbook}
+import org.apache.poi.ss.usermodel.Workbook
+import org.apache.poi.xssf.usermodel.{XSSFSheet, XSSFWorkbook}
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.{col, udf}
+
+import java.io.ByteArrayInputStream
+import scala.collection.JavaConverters._
+import scala.collection.mutable
+
+class ExcelReader(
+    titleFontSize: Int = 9,
+    cellSeparator: String = "\t",
+    storeContent: Boolean = false,
+    includePageBreaks: Boolean = false,
+    inferTableStructure: Boolean = false,
+    appendCells: Boolean = false)
+    extends Serializable {
+
+  private val spark = ResourceHelper.spark
+  import spark.implicits._
+
+  def xls(filePath: String): DataFrame = {
+    if (ResourceHelper.validFile(filePath)) {
+      val binaryFilesRDD = spark.sparkContext.binaryFiles(filePath)
+      val byteArrayRDD = binaryFilesRDD.map { case (path, portableDataStream) =>
+        val byteArray = portableDataStream.toArray()
+        (path, byteArray)
+      }
+      val excelDf = byteArrayRDD
+        .toDF("path", "content")
+        .withColumn("xls", parseExcelUDF(col("content")))
+      if (storeContent) excelDf.select("path", "xls", "content")
+      else excelDf.select("path", "xls")
+    } else throw new IllegalArgumentException(s"Invalid filePath: $filePath")
+  }
+
+  private val parseExcelUDF = udf((data: Array[Byte]) => {
+    parseExcel(data)
+  })
+
+  // Constants for file type identification
+  private val ZipMagicNumberFirstByte: Byte = 0x50.toByte // First byte of ZIP files
+  private val ZipMagicNumberSecondByte: Byte = 0x4b.toByte // Second byte of ZIP files
+  private val OleMagicNumber: Array[Byte] =
+    Array(0xd0.toByte, 0xcf.toByte, 0x11.toByte, 0xe0.toByte) // OLE file header
+
+  private def isXlsxFile(content: Array[Byte]): Boolean = {
+    content.length > 1 &&
+    content(0) == ZipMagicNumberFirstByte &&
+    content(1) == ZipMagicNumberSecondByte
+  }
+
+  private def isXlsFile(content: Array[Byte]): Boolean = {
+    content.length >= 4 && content.slice(0, 4).sameElements(OleMagicNumber)
+  }
+
+  private def parseExcel(content: Array[Byte]): Seq[HTMLElement] = {
+    val workbookInputStream = new ByteArrayInputStream(content)
+    val workbook: Workbook =
+      if (isXlsxFile(content)) new XSSFWorkbook(workbookInputStream)
+      else if (isXlsFile(content)) new HSSFWorkbook(workbookInputStream)
+      else throw new IllegalArgumentException("Unsupported file format: must be .xls or .xlsx")
+
+    val elementsBuffer = mutable.ArrayBuffer[HTMLElement]()
+
+    for (sheetIndex <- 0 until workbook.getNumberOfSheets) {
+      if (includePageBreaks)
+        buildSheetContentWithPageBreaks(workbook, sheetIndex, elementsBuffer)
+      else
+        buildSheetContent(workbook, sheetIndex, elementsBuffer)
+    }
+
+    workbook.close()
+    elementsBuffer
+  }
+
+  private def buildSheetContent(
+      workbook: Workbook,
+      sheetIndex: Int,
+      elementsBuffer: mutable.ArrayBuffer[HTMLElement]): Unit = {
+
+    val sheet = workbook.getSheetAt(sheetIndex)
+    val sheetName = sheet.getSheetName
+
+    val rowIterator = sheet.iterator()
+
+    val allContents = new StringBuilder
+    val allMetadata = mutable.Map[String, String]("SheetName" -> sheetName)
+
+    while (rowIterator.hasNext) {
+      val row = rowIterator.next()
+      val rowIndex = row.getRowNum
+
+      val elementType =
+        if (row.isTitle(titleFontSize)) ElementType.TITLE else ElementType.NARRATIVE_TEXT
+
+      val cellValuesWithMetadata = row
+        .cellIterator()
+        .asScala
+        .map { cell =>
+          val cellIndex = cell.getColumnIndex
+          val cellValue = cell.getCellValue.trim
+
+          val cellMetadata = mutable.Map(
+            "SheetName" -> sheetName,
+            "location" -> s"(${rowIndex.toString}, ${cellIndex.toString})")
+
+          (cellValue, cellMetadata)
+        }
+        .toSeq
+
+      val content = cellValuesWithMetadata.map(_._1).mkString(cellSeparator).trim
+
+      if (content.nonEmpty) {
+        if (appendCells) {
+          if (allContents.nonEmpty) allContents.append("\n")
+          allContents.append(content)
+        } else {
+          val rowMetadata = cellValuesWithMetadata
+            .flatMap(_._2)
+            .toMap
+
+          val element = HTMLElement(
+            elementType = elementType,
+            content = content,
+            metadata = mutable.Map(rowMetadata.toSeq: _*))
+          elementsBuffer += element
+        }
+      }
+    }
+
+    if (appendCells && allContents.nonEmpty) {
+      elementsBuffer += HTMLElement(
+        elementType = ElementType.NARRATIVE_TEXT,
+        content = allContents.toString(),
+        metadata = allMetadata)
+    }
+
+    if (inferTableStructure) sheet.buildHtmlIfNeeded(elementsBuffer)
+  }
+
+  private def buildSheetContentWithPageBreaks(
+      workbook: Workbook,
+      sheetIndex: Int,
+      elementsBuffer: mutable.ArrayBuffer[HTMLElement]): Unit = {
+    val sheet = workbook.getSheetAt(sheetIndex)
+    val sheetName = sheet.getSheetName
+
+    val colBreaks: Seq[Int] = sheet match {
+      case xssf: XSSFSheet =>
+        if (xssf.getCTWorksheet.isSetColBreaks)
+          xssf.getCTWorksheet.getColBreaks.getBrkList.asScala.map(_.getId.toInt).sorted
+        else Seq.empty[Int]
+      case hssf: HSSFSheet =>
+        Option(hssf.getColumnBreaks).map(_.toSeq).getOrElse(Seq.empty[Int])
+      case _ => Seq.empty[Int]
+    }
+
+    val rowIterator = sheet.iterator()
+    while (rowIterator.hasNext) {
+      val row = rowIterator.next()
+      val rowIndex = row.getRowNum
+
+      val elementType =
+        if (row.isTitle(titleFontSize)) ElementType.TITLE else ElementType.NARRATIVE_TEXT
+
+      val cellsByPage: Map[Int, Seq[org.apache.poi.ss.usermodel.Cell]] =
+        row
+          .cellIterator()
+          .asScala
+          .toSeq
+          .groupBy(cell => getPageNumberForCell(cell.getColumnIndex, colBreaks))
+
+      for ((page, cells) <- cellsByPage) {
+        val cellValuesWithMetadata = cells.map { cell =>
+          val cellIndex = cell.getColumnIndex
+          val cellValue = cell.getCellValue.trim
+          val cellMetadata =
+            mutable.Map("location" -> s"($rowIndex, $cellIndex)", "SheetName" -> sheetName)
+          (cellValue, cellMetadata)
+        }
+        val content = cellValuesWithMetadata.map(_._1).mkString(cellSeparator).trim
+
+        if (content.nonEmpty) {
+          val rowMetadata = cellValuesWithMetadata.flatMap(_._2).toMap
+          val elementMetadata = mutable.Map(rowMetadata.toSeq: _*)
+          elementMetadata += ("pageBreak" -> page.toString)
+          val element =
+            HTMLElement(elementType = elementType, content = content, metadata = elementMetadata)
+          elementsBuffer += element
+        }
+      }
+    }
+    if (inferTableStructure) sheet.buildHtmlIfNeeded(elementsBuffer)
+  }
+
+  private def getPageNumberForCell(cellIndex: Int, breaks: Seq[Int]): Int = {
+    breaks.count(break => cellIndex > break) + 1
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/HTMLReader.scala b/src/main/scala/com/johnsnowlabs/reader/HTMLReader.scala
index 01640ef04ce660..6395439534b140 100644
--- a/src/main/scala/com/johnsnowlabs/reader/HTMLReader.scala
+++ b/src/main/scala/com/johnsnowlabs/reader/HTMLReader.scala
@@ -26,7 +26,12 @@ import scala.collection.JavaConverters._
 import scala.collection.mutable
 import scala.collection.mutable.ArrayBuffer
 
-class HTMLReader(titleFontSize: Int = 16) extends Serializable {
+class HTMLReader(
+    titleFontSize: Int = 16,
+    storeContent: Boolean = false,
+    timeout: Int = 0,
+    headers: Map[String, String] = Map.empty)
+    extends Serializable {
 
   private val spark = ResourceHelper.spark
   import spark.implicits._
@@ -35,16 +40,19 @@ class HTMLReader(titleFontSize: Int = 16) extends Serializable {
 
     ResourceHelper match {
       case _ if validFile(inputSource) && !inputSource.startsWith("http") =>
-        spark.sparkContext
+        val htmlDf = spark.sparkContext
           .wholeTextFiles(inputSource)
           .toDF("path", "content")
           .withColumn("html", parseHtmlUDF(col("content")))
-
+        if (storeContent) htmlDf.select("path", "content", "html")
+        else htmlDf.select("path", "html")
       case _ if isValidURL(inputSource) =>
-        spark
+        val htmlDf = spark
           .createDataset(Seq(inputSource))
           .toDF("url")
           .withColumn("html", parseURLUDF(col("url")))
+        if (storeContent) htmlDf.select("url", "content", "html")
+        else htmlDf.select("url", "html")
       case _ =>
         throw new IllegalArgumentException(s"Invalid inputSource: $inputSource")
     }
@@ -67,7 +75,11 @@ class HTMLReader(titleFontSize: Int = 16) extends Serializable {
   })
 
   private val parseURLUDF = udf((url: String) => {
-    val document = Jsoup.connect(url).get()
+    val connection = Jsoup
+      .connect(url)
+      .headers(headers.asJava)
+      .timeout(timeout * 1000)
+    val document = connection.get()
     startTraversalFromBody(document)
   })
 
diff --git a/src/main/scala/com/johnsnowlabs/reader/PdfToText.scala b/src/main/scala/com/johnsnowlabs/reader/PdfToText.scala
new file mode 100644
index 00000000000000..5e8ca8f13692e1
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/PdfToText.scala
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.nlp.IAnnotation
+import com.johnsnowlabs.reader.util.pdf._
+import org.apache.pdfbox.pdmodel.PDDocument
+import org.apache.pdfbox.text.PDFTextStripper
+import org.apache.spark.internal.Logging
+import org.apache.spark.ml.Transformer
+import org.apache.spark.ml.param.shared.{HasInputCol, HasOutputCol}
+import org.apache.spark.ml.param.{BooleanParam, IntParam, Param, ParamMap}
+import org.apache.spark.ml.util.{DefaultParamsWritable, Identifiable}
+import org.apache.spark.sql.expressions.UserDefinedFunction
+import org.apache.spark.sql.functions.{col, posexplode_outer, udf}
+import org.apache.spark.sql.types._
+import org.apache.spark.sql.{DataFrame, Dataset}
+
+import scala.util.{Failure, Success, Try}
+
+class PdfToText(override val uid: String)
+    extends Transformer
+    with DefaultParamsWritable
+    with HasInputValidator
+    with HasInputCol
+    with HasOutputCol
+    with HasLocalProcess
+    with PdfToTextTrait {
+
+  def this() = this(Identifiable.randomUID("PDF_TO_TEXT_TRANSFORMER"))
+
+  override def copy(extra: ParamMap): Transformer = defaultCopy(extra)
+
+  protected def outputDataType: StructType = new StructType()
+    .add($(outputCol), StringType)
+    .add("height_dimension", IntegerType)
+    .add("width_dimension", IntegerType)
+    .add($(inputCol), BinaryType)
+    .add("exception", StringType)
+    .add($(pageNumCol), IntegerType)
+
+  override def transformSchema(schema: StructType): StructType = {
+    // Add the return fields
+    validateInputCol(schema, $(inputCol), BinaryType)
+    validateInputCol(schema, $(originCol), StringType)
+    schema
+      .add(StructField($(outputCol), StringType, nullable = false))
+      .add(StructField($(pageNumCol), IntegerType, nullable = false))
+  }
+
+  final val pageNumCol = new Param[String](this, "pageNumCol", "Page number output column name.")
+  final val originCol =
+    new Param[String](this, "originCol", "Input column name with original path of file.")
+  final val partitionNum = new IntParam(this, "partitionNum", "Number of partitions.")
+  final val storeSplittedPdf =
+    new BooleanParam(this, "storeSplittedPdf", "Force to store bytes content of splitted pdf.")
+
+  /** @group getParam */
+  def setOriginCol(value: String): this.type = set(originCol, value)
+
+  /** @group setParam */
+  def setInputCol(value: String): this.type = set(inputCol, value)
+
+  /** @group setParam */
+  def setOutputCol(value: String): this.type = set(outputCol, value)
+
+  /** @group getParam */
+  def setPartitionNum(value: Int): this.type = set(partitionNum, value)
+
+  /** @group setParam */
+  def setStoreSplittedPdf(value: Boolean): this.type = set(storeSplittedPdf, value)
+
+  setDefault(
+    inputCol -> "content",
+    outputCol -> "text",
+    pageNumCol -> "pagenum",
+    originCol -> "path",
+    partitionNum -> 0,
+    storeSplittedPdf -> false)
+
+  private def transformUDF: UserDefinedFunction = udf(
+    (path: String, content: Array[Byte]) => {
+      doProcess(content)
+    },
+    ArrayType(outputDataType))
+
+  private def doProcess(
+      content: Array[Byte]): Seq[(String, Int, Int, Array[Byte], String, Int)] = {
+    val pagesTry = Try(pdfToText(content, $(storeSplittedPdf)))
+
+    pagesTry match {
+      case Failure(_) =>
+        Seq()
+      case Success(content) =>
+        content
+    }
+  }
+
+  override def transform(df: Dataset[_]): DataFrame = {
+    transformSchema(df.schema)
+
+    val selCols1 = df.columns
+      .filterNot(_ == $(inputCol))
+      .map(col) :+ posexplode_outer(transformUDF(df.col($(originCol)), df.col($(inputCol))))
+      .as(Seq("tmp_num", "tmp_result"))
+    val selCols = df.columns
+      .filterNot(_ == $(inputCol))
+      .map(col) :+ col("tmp_result.*")
+
+    var result = df.select(selCols1: _*)
+    result = result
+      .select(selCols: _*)
+    $(partitionNum) match {
+      case 0 => result
+      case _ => result.repartition($(partitionNum))
+    }
+  }
+
+  override def localProcess(
+      input: Array[Map[String, Seq[IAnnotation]]]): Array[Map[String, Seq[IAnnotation]]] = {
+    input.flatMap { case lightRecord =>
+      val pdfs = lightRecord.getOrElse(
+        getOrDefault(inputCol),
+        throw new RuntimeException(s"Column not found ${getOrDefault(inputCol)}"))
+
+      pdfs flatMap { case BinaryFile(bytes, path) =>
+        doProcess(bytes).zipWithIndex.map { case ((text, _, _, content, exception, _), pageNum) =>
+          val metadata =
+            Map("exception" -> exception, "sourcePath" -> path, "pageNum" -> pageNum.toString)
+
+          val result = lightRecord ++ Map(
+            getOutputCol -> Seq(OcrText(text, metadata, content)),
+            getOrDefault(pageNumCol) -> Seq(PageNum(pageNum)))
+          result
+        }
+      }
+    }
+  }
+
+}
+
+trait PdfToTextTrait extends Logging with PdfUtils {
+
+  /*
+   * extracts a text layer from a PDF.
+   */
+  private def extractText(document: => PDDocument, startPage: Int, endPage: Int): Seq[String] = {
+    val pdfTextStripper = new PDFTextStripper
+    pdfTextStripper.setStartPage(startPage + 1)
+    pdfTextStripper.setEndPage(endPage + 1)
+    Seq(pdfTextStripper.getText(document))
+  }
+
+  def pdfToText(
+      content: Array[Byte],
+      storeSplittedPdf: Boolean): Seq[(String, Int, Int, Array[Byte], String, Int)] = {
+    val validPdf = checkAndFixPdf(content)
+    val pdfDoc = PDDocument.load(validPdf)
+    val numPages = pdfDoc.getNumberOfPages
+    log.info(s"Number of pages ${numPages}")
+    require(numPages >= 1, "pdf input stream cannot be empty")
+
+    val result = pdfboxMethod(pdfDoc, 0, numPages - 1, content, storeSplittedPdf)
+    pdfDoc.close()
+    log.info("Close pdf")
+    result
+  }
+
+  private def pdfboxMethod(
+      pdfDoc: => PDDocument,
+      startPage: Int,
+      endPage: Int,
+      content: Array[Byte],
+      storeSplittedPdf: Boolean): Seq[(String, Int, Int, Array[Byte], String, Int)] = {
+    val text = extractText(pdfDoc, startPage, endPage).mkString(System.lineSeparator())
+    val heightDimension = pdfDoc.getPage(startPage).getMediaBox.getHeight.toInt
+    val widthDimension = pdfDoc.getPage(startPage).getMediaBox.getWidth.toInt
+    Seq((text, heightDimension, widthDimension, if (storeSplittedPdf) content else null, null, 0))
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/PowerPointReader.scala b/src/main/scala/com/johnsnowlabs/reader/PowerPointReader.scala
new file mode 100644
index 00000000000000..c2ba5576e5b2e8
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/PowerPointReader.scala
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.reader.util.PptParser.{RichHSLFSlide, RichXSLFSlide}
+import org.apache.poi.hslf.usermodel.HSLFSlideShow
+import org.apache.poi.xslf.usermodel.XMLSlideShow
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.{col, udf}
+
+import java.io.ByteArrayInputStream
+import scala.collection.JavaConverters._
+
+class PowerPointReader(
+    storeContent: Boolean = false,
+    inferTableStructure: Boolean = false,
+    includeSlideNotes: Boolean = false)
+    extends Serializable {
+
+  private val spark = ResourceHelper.spark
+  import spark.implicits._
+
+  def ppt(filePath: String): DataFrame = {
+    if (ResourceHelper.validFile(filePath)) {
+      val binaryFilesRDD = spark.sparkContext.binaryFiles(filePath)
+      val byteArrayRDD = binaryFilesRDD.map { case (path, portableDataStream) =>
+        val byteArray = portableDataStream.toArray()
+        (path, byteArray)
+      }
+      val powerPointDf = byteArrayRDD
+        .toDF("path", "content")
+        .withColumn("ppt", parsePowerPointUDF(col("content")))
+      if (storeContent) powerPointDf.select("path", "ppt", "content")
+      else powerPointDf.select("path", "ppt")
+    } else throw new IllegalArgumentException(s"Invalid filePath: $filePath")
+  }
+
+  private val parsePowerPointUDF = udf((data: Array[Byte]) => {
+    parsePowerPoint(data)
+  })
+
+  // Constants for file type identification
+  private val ZipMagicNumberFirstByte: Byte = 0x50.toByte // First byte of ZIP files
+  private val ZipMagicNumberSecondByte: Byte = 0x4b.toByte // Second byte of ZIP files
+  private val OleMagicNumber: Array[Byte] =
+    Array(0xd0.toByte, 0xcf.toByte, 0x11.toByte, 0xe0.toByte) // OLE file header
+
+  // Method to check if the file is a .pptx file (ZIP-based)
+  private def isPptxFile(content: Array[Byte]): Boolean = {
+    content.length > 1 &&
+    content(0) == ZipMagicNumberFirstByte &&
+    content(1) == ZipMagicNumberSecondByte
+  }
+
+  // Method to check if the file is a .ppt file (OLE Compound Document)
+  private def isPptFile(content: Array[Byte]): Boolean = {
+    content.length >= 4 && content.slice(0, 4).sameElements(OleMagicNumber)
+  }
+
+  val titleFontSizeThreshold = 9
+
+  private def parsePowerPoint(content: Array[Byte]): Seq[HTMLElement] = {
+    val slideInputStream = new ByteArrayInputStream(content)
+    if (isPptxFile(content)) {
+      parsePptx(slideInputStream)
+    } else if (isPptFile(content)) {
+      parsePpt(slideInputStream)
+    } else {
+      throw new IllegalArgumentException("Unsupported PowerPoint file format")
+    }
+  }
+
+  private def parsePpt(slideInputStream: ByteArrayInputStream): Seq[HTMLElement] = {
+    val ppt = new HSLFSlideShow(slideInputStream)
+    val slides = ppt.getSlides
+
+    val elements = slides.asScala.flatMap { slide =>
+      slide.extractHSLFSlideContent
+    }
+    ppt.close()
+    elements
+  }
+
+  private def parsePptx(slideInputStream: ByteArrayInputStream): Seq[HTMLElement] = {
+    val pptx = new XMLSlideShow(slideInputStream)
+    val slides = pptx.getSlides
+
+    val elements = slides.asScala.flatMap { slide =>
+      slide.extractXSLFSlideContent(inferTableStructure, includeSlideNotes)
+    }
+    pptx.close()
+    elements
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/SparkNLPReader.scala b/src/main/scala/com/johnsnowlabs/reader/SparkNLPReader.scala
index 713949a4cd701a..0f2f53181d94cb 100644
--- a/src/main/scala/com/johnsnowlabs/reader/SparkNLPReader.scala
+++ b/src/main/scala/com/johnsnowlabs/reader/SparkNLPReader.scala
@@ -15,11 +15,21 @@
  */
 package com.johnsnowlabs.reader
 
+import com.johnsnowlabs.nlp.annotators.cleaners.util.CleanerHelper.DOUBLE_PARAGRAPH_PATTERN
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.reader.util.PartitionOptions.{
+  getDefaultBoolean,
+  getDefaultInt,
+  getDefaultString
+}
+import org.apache.spark.ml.Pipeline
 import org.apache.spark.sql.DataFrame
 
 import scala.collection.JavaConverters._
 
-class SparkNLPReader(params: java.util.Map[String, String] = new java.util.HashMap()) {
+class SparkNLPReader(
+    params: java.util.Map[String, String] = new java.util.HashMap(),
+    headers: java.util.Map[String, String] = new java.util.HashMap()) {
 
   /** Instantiates class to read HTML files.
     *
@@ -68,35 +78,46 @@ class SparkNLPReader(params: java.util.Map[String, String] = new java.util.HashM
     */
 
   def html(htmlPath: String): DataFrame = {
-    val htmlReader = new HTMLReader(getTitleFontSize)
+    val htmlReader =
+      new HTMLReader(getTitleFontSize, getStoreContent, getTimeout, headers = htmlHeaders)
     htmlReader.read(htmlPath)
   }
 
   def html(urls: Array[String]): DataFrame = {
-    val htmlReader = new HTMLReader(getTitleFontSize)
+    val htmlReader =
+      new HTMLReader(getTitleFontSize, getStoreContent, getTimeout, headers = htmlHeaders)
     htmlReader.read(urls)
   }
 
   def html(urls: java.util.List[String]): DataFrame = {
-    val htmlReader = new HTMLReader(getTitleFontSize)
+    val htmlReader = new HTMLReader(
+      getTitleFontSize,
+      getStoreContent,
+      getTimeout,
+      headers = headers.asScala.toMap)
     htmlReader.read(urls.asScala.toArray)
   }
 
+  private lazy val htmlHeaders: Map[String, String] =
+    if (headers == null) Map.empty
+    else headers.asScala.toMap.map { case (k, v) => k -> v }
+
   private def getTitleFontSize: Int = {
-    val titleFontSize =
-      try {
-        params.asScala.getOrElse("titleFontSize", "16").toInt
-      } catch {
-        case _: IllegalArgumentException => 16
-      }
+    getDefaultInt(params.asScala.toMap, Seq("titleFontSize", "title_font_size"), default = 16)
+  }
 
-    titleFontSize
+  private def getStoreContent: Boolean = {
+    getDefaultBoolean(params.asScala.toMap, Seq("storeContent", "store_content"), default = false)
+  }
+
+  private def getTimeout: Int = {
+    getDefaultInt(params.asScala.toMap, Seq("timeout"), default = 30)
   }
 
   /** Instantiates class to read email files.
     *
     * emailPath: this is a path to a directory of HTML files or a path to an HTML file E.g.
-    * "path/html/emails"
+    * "path/email/files"
     *
     * ==Example==
     * {{{
@@ -137,23 +158,374 @@ class SparkNLPReader(params: java.util.Map[String, String] = new java.util.HashM
     */
 
   def email(emailPath: String): DataFrame = {
-    val emailReader = new EmailReader(getAddAttachmentContent)
+    val emailReader = new EmailReader(getAddAttachmentContent, getStoreContent)
     emailReader.read(emailPath)
   }
 
   private def getAddAttachmentContent: Boolean = {
-    val addAttachmentContent =
+    getDefaultBoolean(params.asScala.toMap, Seq("addAttachmentContent", "add_attachment_content"), default = false)
+  }
+
+  /** Instantiates class to read Word files.
+    *
+    * docPath: this is a path to a directory of Word files or a path to an HTML file E.g.
+    * "path/word/files"
+    *
+    * ==Example==
+    * {{{
+    * val docsPath = "home/user/word-directory"
+    * val sparkNLPReader = new SparkNLPReader()
+    * val docsDf = sparkNLPReader.email(docsPath)
+    * }}}
+    *
+    * ==Example 2==
+    * You can use SparkNLP for one line of code
+    * {{{
+    * val docsDf = SparkNLP.read.doc(docsPath)
+    * }}}
+    *
+    * {{{
+    * docsDf.select("doc").show(false)
+    * +----------------------------------------------------------------------------------------------------------------------------------------------------+
+    * |doc                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+    * +----------------------------------------------------------------------------------------------------------------------------------------------------+
+    * |[{Table, Header Col 1, {}}, {Table, Header Col 2, {}}, {Table, Lorem ipsum, {}}, {Table, A Link example, {}}, {NarrativeText, Dolor sit amet, {}}]  |
+    * +----------------------------------------------------------------------------------------------------------------------------------------------------+
+    *
+    * docsDf.printSchema()
+    * root
+    *  |-- path: string (nullable = true)
+    *  |-- content: binary (nullable = true)
+    *  |-- doc: array (nullable = true)
+    *  |    |-- element: struct (containsNull = true)
+    *  |    |    |-- elementType: string (nullable = true)
+    *  |    |    |-- content: string (nullable = true)
+    *  |    |    |-- metadata: map (nullable = true)
+    *  |    |    |    |-- key: string
+    *  |    |    |    |-- value: string (valueContainsNull = true)
+    * }}}
+    *
+    * @param params
+    *   Parameter with custom configuration
+    */
+
+  def doc(docPath: String): DataFrame = {
+    val wordReader = new WordReader(getStoreContent, getIncludePageBreaks)
+    wordReader.doc(docPath)
+  }
+
+  /** Instantiates class to read PDF files.
+    *
+    * pdfPath: this is a path to a directory of PDF files or a path to an PDF file E.g.
+    * "path/pdfs/"
+    *
+    * ==Example==
+    * {{{
+    * val pdfsPath = "home/user/pdfs-directory"
+    * val sparkNLPReader = new SparkNLPReader()
+    * val pdfDf = sparkNLPReader.pdf(pdfsPath)
+    * }}}
+    *
+    * ==Example 2==
+    * You can use SparkNLP for one line of code
+    * {{{
+    * val pdfDf = SparkNLP.read.pdf(pdfsPath)
+    * }}}
+    *
+    * {{{
+    * pdfDf.show(false)
+    * +--------------------+--------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+
+    * |                path|    modificationTime|length|                text|height_dimension|width_dimension|             content|exception|pagenum|
+    * +--------------------+--------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+
+    * |file:/content/pdf...|2025-01-15 20:48:...| 25803|This is a Title \...|             842|            596|[25 50 44 46 2D 3...|     NULL|      0|
+    * |file:/content/pdf...|2025-01-15 20:48:...|  9487|This is a page.\n...|             841|            595|[25 50 44 46 2D 3...|     NULL|      0|
+    * +--------------------+--------------------+------+--------------------+----------------+---------------+--------------------+---------+-------+
+    *
+    * pdf_df.printSchema()
+    * root
+    *  |-- path: string (nullable = true)
+    *  |-- modificationTime: timestamp (nullable = true)
+    *  |-- length: long (nullable = true)
+    *  |-- text: string (nullable = true)
+    *  |-- height_dimension: integer (nullable = true)
+    *  |-- width_dimension: integer (nullable = true)
+    *  |-- content: binary (nullable = true)
+    *  |-- exception: string (nullable = true)
+    *  |-- pagenum: integer (nullable = true)
+    * }}}
+    *
+    * @param params
+    *   Parameter with custom configuration
+    */
+  def pdf(pdfPath: String): DataFrame = {
+    val spark = ResourceHelper.spark
+    spark.conf.set("spark.sql.legacy.allowUntypedScalaUDF", "true")
+    val pdfToText = new PdfToText()
+      .setStoreSplittedPdf(getStoreSplittedPdf)
+    val binaryPdfDF = spark.read.format("binaryFile").load(pdfPath)
+    val pipelineModel = new Pipeline()
+      .setStages(Array(pdfToText))
+      .fit(binaryPdfDF)
+
+    pipelineModel.transform(binaryPdfDF)
+  }
+
+  private def getStoreSplittedPdf: Boolean = {
+    getDefaultBoolean(params.asScala.toMap, Seq("storeSplittedPdf", "store_splitted_pdf"), default = false)
+  }
+
+  /** Instantiates class to read Excel files.
+    *
+    * docPath: this is a path to a directory of Excel files or a path to an HTML file E.g.
+    * "path/excel/files"
+    *
+    * ==Example==
+    * {{{
+    * val docsPath = "home/user/excel-directory"
+    * val sparkNLPReader = new SparkNLPReader()
+    * val xlsDf = sparkNLPReader.xls(docsPath)
+    * }}}
+    *
+    * ==Example 2==
+    * You can use SparkNLP for one line of code
+    * {{{
+    * val xlsDf = SparkNLP.read.xls(docsPath)
+    * }}}
+    *
+    * {{{
+    * xlsDf.select("xls").show(false)
+    * +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    * |xls                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+    * +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    * |[{Title, Financial performance, {SheetName -> Index}}, {Title, Topic\tPeriod\t\t\tPage, {SheetName -> Index}}, {NarrativeText, Quarterly revenue\tNine quarters to 30 June 2023\t\t\t1.0, {SheetName -> Index}}, {NarrativeText, Group financial performance\tFY 22\tFY 23\t\t2.0, {SheetName -> Index}}, {NarrativeText, Segmental results\tFY 22\tFY 23\t\t3.0, {SheetName -> Index}}, {NarrativeText, Segmental analysis\tFY 22\tFY 23\t\t4.0, {SheetName -> Index}}, {NarrativeText, Cash flow\tFY 22\tFY 23\t\t5.0, {SheetName -> Index}}, {Title, Operational metrics, {SheetName -> Index}}, {Title, Topic\tPeriod\t\t\tPage, {SheetName -> Index}}, {NarrativeText, Mobile customers\tNine quarters to 30 June 2023\t\t\t6.0, {SheetName -> Index}}, {NarrativeText, Fixed broadband customers\tNine quarters to 30 June 2023\t\t\t7.0, {SheetName -> Index}}, {NarrativeText, Marketable homes passed\tNine quarters to 30 June 2023\t\t\t8.0, {SheetName -> Index}}, {NarrativeText, TV customers\tNine quarters to 30 June 2023\t\t\t9.0, {SheetName -> Index}}, {NarrativeText, Converged customers\tNine quarters to 30 June 2023\t\t\t10.0, {SheetName -> Index}}, {NarrativeText, Mobile churn\tNine quarters to 30 June 2023\t\t\t11.0, {SheetName -> Index}}, {NarrativeText, Mobile data usage\tNine quarters to 30 June 2023\t\t\t12.0, {SheetName -> Index}}, {NarrativeText, Mobile ARPU\tNine quarters to 30 June 2023\t\t\t13.0, {SheetName -> Index}}, {Title, Other, {SheetName -> Index}}, {Title, Topic\tPeriod\t\t\tPage, {SheetName -> Index}}, {NarrativeText, Average foreign exchange rates\tNine quarters to 30 June 2023\t\t\t14.0, {SheetName -> Index}}, {NarrativeText, Guidance rates\tFY 23/24\t\t\t14.0, {SheetName -> Index}}]|
+    * +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    *
+    * xlsDf.printSchema()
+    * root
+    *  |-- path: string (nullable = true)
+    *  |-- content: binary (nullable = true)
+    *  |-- xls: array (nullable = true)
+    *  |    |-- element: struct (containsNull = true)
+    *  |    |    |-- elementType: string (nullable = true)
+    *  |    |    |-- content: string (nullable = true)
+    *  |    |    |-- metadata: map (nullable = true)
+    *  |    |    |    |-- key: string
+    *  |    |    |    |-- value: string (valueContainsNull = true)
+    * }}}
+    *
+    * @param params
+    *   Parameter with custom configuration
+    */
+
+  def xls(docPath: String): DataFrame = {
+    val excelReader =
+      new ExcelReader(
+        titleFontSize = getTitleFontSize,
+        cellSeparator = getCellSeparator,
+        storeContent = getStoreContent,
+        includePageBreaks = getIncludePageBreaks,
+        inferTableStructure = getInferTableStructure,
+        appendCells = getAppendCells)
+    excelReader.xls(docPath)
+  }
+
+  private def getCellSeparator: String = {
+    params.asScala.getOrElse("cellSeparator", "\t")
+  }
+
+  private def getInferTableStructure: Boolean = {
+    getDefaultBoolean(params.asScala.toMap, Seq("inferTableStructure", "infer_table_structure"), default = false)
+  }
+
+  private def getAppendCells: Boolean = {
+    getDefaultBoolean(params.asScala.toMap, Seq("appendCells", "append_cells"), default = false)
+  }
+
+  /** Instantiates class to read PowerPoint files.
+    *
+    * docPath: this is a path to a directory of Excel files or a path to an HTML file E.g.
+    * "path/power-point/files"
+    *
+    * ==Example==
+    * {{{
+    * val docsPath = "home/user/power-point-directory"
+    * val sparkNLPReader = new SparkNLPReader()
+    * val pptDf = sparkNLPReader.ppt(docsPath)
+    * }}}
+    *
+    * ==Example 2==
+    * You can use SparkNLP for one line of code
+    * {{{
+    * val pptDf = SparkNLP.read.ppt(docsPath)
+    * }}}
+    *
+    * {{{
+    * xlsDf.select("ppt").show(false)
+    * +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    * |ppt                                                                                                                                                                                                                                                                                                                      |
+    * +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    * |[{Title, Adding a Bullet Slide, {}}, {ListItem, • Find the bullet slide layout, {}}, {ListItem, – Use _TextFrame.text for first bullet, {}}, {ListItem, • Use _TextFrame.add_paragraph() for subsequent bullets, {}}, {NarrativeText, Here is a lot of text!, {}}, {NarrativeText, Here is some text in a text box!, {}}]|
+    * +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    *
+    * pptDf.printSchema()
+    * root
+    *  |-- path: string (nullable = true)
+    *  |-- content: binary (nullable = true)
+    *  |-- ppt: array (nullable = true)
+    *  |    |-- element: struct (containsNull = true)
+    *  |    |    |-- elementType: string (nullable = true)
+    *  |    |    |-- content: string (nullable = true)
+    *  |    |    |-- metadata: map (nullable = true)
+    *  |    |    |    |-- key: string
+    *  |    |    |    |-- value: string (valueContainsNull = true)
+    * }}}
+    *
+    * @param params
+    *   Parameter with custom configuration
+    */
+
+  def ppt(docPath: String): DataFrame = {
+    val powerPointReader = new PowerPointReader(getStoreContent)
+    powerPointReader.ppt(docPath)
+  }
+
+  /** Instantiates class to read txt files.
+    *
+    * filePath: this is a path to a directory of TXT files or a path to an TXT file E.g.
+    * "path/txt/files"
+    *
+    * ==Example==
+    * {{{
+    * val filePath = "home/user/txt/files"
+    * val sparkNLPReader = new SparkNLPReader()
+    * val txtDf = sparkNLPReader.txt(filePath)
+    * }}}
+    *
+    * ==Example 2==
+    * You can use SparkNLP for one line of code
+    * {{{
+    * val txtDf = SparkNLP.read.txt(filePath)
+    * }}}
+    *
+    * {{{
+    * txtDf.select("txt").show(false)
+    * +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    * |txt                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+    * +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    * |[{Title, BIG DATA ANALYTICS, {paragraph -> 0}}, {NarrativeText, Apache Spark is a fast and general-purpose cluster computing system.\nIt provides high-level APIs in Java, Scala, Python, and R., {paragraph -> 0}}, {Title, MACHINE LEARNING, {paragraph -> 1}}, {NarrativeText, Spark's MLlib provides scalable machine learning algorithms.\nIt includes tools for classification, regression, clustering, and more., {paragraph -> 1}}]|
+    * +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    *
+    * emailDf.printSchema()
+    * root
+    *  |-- path: string (nullable = true)
+    *  |-- content: binary (nullable = true)
+    *  |-- txt: array (nullable = true)
+    *  |    |-- element: struct (containsNull = true)
+    *  |    |    |-- elementType: string (nullable = true)
+    *  |    |    |-- content: string (nullable = true)
+    *  |    |    |-- metadata: map (nullable = true)
+    *  |    |    |    |-- key: string
+    *  |    |    |    |-- value: string (valueContainsNull = true)
+    * }}}
+    *
+    * @param params
+    *   Parameter with custom configuration
+    */
+  def txt(filePath: String): DataFrame = {
+    val textReader = new TextReader(
+      getTitleLengthSize,
+      getStoreContent,
+      getGroupBrokenParagraphs,
+      getParagraphSplit,
+      getShortLineWordThreshold,
+      getMaxLineCount,
+      getThreshold)
+    textReader.txt(filePath)
+  }
+
+  def txtContent(content: String): DataFrame = {
+    val textReader = new TextReader(
+      getTitleLengthSize,
+      getStoreContent,
+      getGroupBrokenParagraphs,
+      getParagraphSplit,
+      getShortLineWordThreshold,
+      getMaxLineCount,
+      getThreshold)
+    textReader.txtContent(content)
+  }
+
+  private def getTitleLengthSize: Int = {
+    getDefaultInt(params.asScala.toMap, Seq("titleLengthSize", "title_length_size"), default = 50)
+  }
+
+  private def getIncludePageBreaks: Boolean = {
+    getDefaultBoolean(params.asScala.toMap, Seq("includePageBreaks", "include_page_breaks"), default = false)
+  }
+
+  private def getGroupBrokenParagraphs: Boolean = {
+    getDefaultBoolean(params.asScala.toMap, Seq("groupBrokenParagraphs", "group_broken_paragraphs"), default = false)
+  }
+
+  private def getParagraphSplit: String = {
+    getDefaultString(params.asScala.toMap, Seq("paragraphSplit", "paragraph_split"), default = DOUBLE_PARAGRAPH_PATTERN)
+  }
+
+  private def getShortLineWordThreshold: Int = {
+    getDefaultInt(params.asScala.toMap, Seq("shortLineWordThreshold", "short_line_word_threshold"), default = 5)
+  }
+
+  private def getMaxLineCount: Int = {
+    getDefaultInt(params.asScala.toMap, Seq("maxLineCount", "max_line_count"), default = 2000)
+  }
+
+  private def getThreshold: Double = {
+    val threshold =
       try {
-        params.asScala.getOrElse("addAttachmentContent", "false").toBoolean
+        params.asScala.getOrElse("threshold", "0.1").toDouble
       } catch {
-        case _: IllegalArgumentException => false
+        case _: IllegalArgumentException => 0.1
       }
-    addAttachmentContent
+
+    threshold
   }
 
-  def doc(docPath: String): DataFrame = {
-    val wordReader = new WordReader()
-    wordReader.doc(docPath)
+  def xml(xmlPath: String): DataFrame = {
+    val xmlReader = new XMLReader(getStoreContent, getXmlKeepTags, getOnlyLeafNodes)
+    xmlReader.read(xmlPath)
+  }
+
+  private def getXmlKeepTags: Boolean = {
+    getDefaultBoolean(params.asScala.toMap, Seq("xmlKeepTags", "xml_keep_tags"), default = false)
+  }
+
+  private def getOnlyLeafNodes: Boolean = {
+    getDefaultBoolean(params.asScala.toMap, Seq("onlyLeafNodes", "only_leaf_nodes"), default = true)
   }
 
+//  private def getDefaultBoolean(options: Seq[String], default: Boolean): Boolean = {
+//    options
+//      .flatMap(key => Option(params.get(key)))
+//      .map(_.trim.toLowerCase)
+//      .flatMap(value => Try(value.toBoolean).toOption)
+//      .headOption
+//      .getOrElse(default)
+//  }
+
+//  private def getDefaultInt(options: Seq[String], default: Int): Int = {
+//    options
+//      .flatMap(key => Option(params.get(key)))
+//      .flatMap(value => Try(value.toInt).toOption)
+//      .headOption
+//      .getOrElse(default)
+//  }
+
+//  private def getDefaultString(options: Seq[String], default: String): String = {
+//    options
+//      .flatMap(key => Option(params.get(key)))
+//      .flatMap(value => Try(value).toOption)
+//      .headOption
+//      .getOrElse(default)
+//  }
+
 }
diff --git a/src/main/scala/com/johnsnowlabs/reader/TextReader.scala b/src/main/scala/com/johnsnowlabs/reader/TextReader.scala
new file mode 100644
index 00000000000000..dec5dcee5d938b
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/TextReader.scala
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.nlp.annotators.cleaners.util.CleanerHelper.DOUBLE_PARAGRAPH_PATTERN
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.reader.util.TextParser
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.udf
+
+import scala.collection.mutable
+
+class TextReader(
+    titleLengthSize: Int = 50,
+    storeContent: Boolean = false,
+    groupBrokenParagraphs: Boolean = false,
+    paragraphSplit: String = DOUBLE_PARAGRAPH_PATTERN,
+    shortLineWordThreshold: Int = 5,
+    maxLineCount: Int = 2000,
+    threshold: Double = 0.1)
+    extends Serializable {
+
+  private val spark = ResourceHelper.spark
+  import spark.implicits._
+
+  /** Parses TXT files and returns a DataFrame.
+    *
+    * The DataFrame will contain:
+    *   - "path": the file path,
+    *   - "content": the raw text content,
+    *   - "txt": a Seq[HTMLElement] containing the parsed elements.
+    */
+  def txt(filePath: String): DataFrame = {
+    if (ResourceHelper.validFile(filePath)) {
+      val textFilesRDD = spark.sparkContext.wholeTextFiles(filePath)
+      val textDf = textFilesRDD
+        .toDF("path", "content")
+        .withColumn("txt", parseTxtUDF($"content"))
+      if (storeContent) textDf.select("path", "txt", "content") else textDf.select("path", "txt")
+    } else {
+      throw new IllegalArgumentException(s"Invalid filePath: $filePath")
+    }
+  }
+
+  def txtContent(content: String): DataFrame = {
+    val df = spark.createDataFrame(Seq(("in-memory", content))).toDF("source", "content")
+    val textDf = df.withColumn("txt", parseTxtUDF($"content"))
+    if (storeContent) textDf.select("txt", "content")
+    else textDf.select("txt")
+  }
+
+  private val parseTxtUDF = udf((text: String) => parseTxt(text))
+
+  /** Parses the given text into a sequence of HTMLElements.
+    *
+    * Parsing logic:
+    *   - Split the text into blocks using a delimiter of two or more consecutive newlines.
+    *   - Using heuristics, consider a block a title if it is all uppercase and short.
+    *   - If a block is a title candidate and the following block exists and is not a title
+    *     candidate, treat the first as the Title and the second as its NarrativeText.
+    *   - Otherwise, treat blocks as narrative text.
+    *   - Omit any element with empty content.
+    */
+  def parseTxt(text: String): Seq[HTMLElement] = {
+    val processedText = if (groupBrokenParagraphs) {
+      TextParser.autoParagraphGrouper(
+        text,
+        paragraphSplit,
+        maxLineCount,
+        threshold,
+        shortLineWordThreshold)
+    } else {
+      text
+    }
+
+    // Split the processed text into blocks using two or more newlines.
+    val blocks = processedText.split("\\n\\n+").map(_.trim).filter(_.nonEmpty)
+    val elements = mutable.ArrayBuffer[HTMLElement]()
+    var i = 0
+    while (i < blocks.length) {
+      val currentBlock = blocks(i)
+      if (isTitleCandidate(currentBlock)) {
+        elements += HTMLElement(
+          ElementType.TITLE,
+          currentBlock,
+          mutable.Map("paragraph" -> (i / 2).toString))
+        if (i + 1 < blocks.length && !isTitleCandidate(blocks(i + 1))) {
+          val narrative = blocks(i + 1)
+          if (narrative.nonEmpty) {
+            elements += HTMLElement(
+              ElementType.NARRATIVE_TEXT,
+              narrative,
+              mutable.Map("paragraph" -> (i / 2).toString))
+          }
+          i += 2
+        } else {
+          i += 1
+        }
+      } else {
+        elements += HTMLElement(
+          ElementType.NARRATIVE_TEXT,
+          currentBlock,
+          mutable.Map("paragraph" -> (i / 2).toString))
+        i += 1
+      }
+    }
+    elements
+  }
+
+  /** Heuristic function to determine if a given line/block is a title candidate.
+    *
+    * Currently, we consider a block a title candidate if:
+    *   - It is non-empty.
+    *   - It consists mostly of uppercase letters (ignoring non-letter characters).
+    *   - It is relatively short (e.g., 50 characters or fewer).
+    */
+  private def isTitleCandidate(text: String): Boolean = {
+    val trimmed = text.trim
+    if (trimmed.isEmpty) return false
+    val isAllUpper = trimmed.forall(c => !c.isLetter || c.isUpper)
+    val isTitleCase = trimmed.split("\\s+").forall(word => word.headOption.exists(_.isUpper))
+    val isShort = trimmed.length <= titleLengthSize
+    val hasLetters = trimmed.exists(_.isLetter)
+    (isAllUpper || isTitleCase) && isShort && hasLetters
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/WordReader.scala b/src/main/scala/com/johnsnowlabs/reader/WordReader.scala
index 208a88d4073c86..7774fb352e3fdf 100644
--- a/src/main/scala/com/johnsnowlabs/reader/WordReader.scala
+++ b/src/main/scala/com/johnsnowlabs/reader/WordReader.scala
@@ -17,8 +17,11 @@ package com.johnsnowlabs.reader
 
 import com.johnsnowlabs.nlp.util.io.ResourceHelper
 import com.johnsnowlabs.reader.util.DocParser.RichParagraph
-import com.johnsnowlabs.reader.util.DocxParser
-import com.johnsnowlabs.reader.util.DocxParser.RichXWPFParagraph
+import com.johnsnowlabs.reader.util.DocxParser.{
+  RichXWPFDocument,
+  RichXWPFParagraph,
+  RichXWPFTable
+}
 import org.apache.poi.hwpf.HWPFDocument
 import org.apache.poi.xwpf.usermodel.{XWPFDocument, XWPFParagraph, XWPFTable}
 import org.apache.spark.sql.DataFrame
@@ -28,7 +31,11 @@ import java.io.{ByteArrayInputStream, IOException}
 import scala.collection.JavaConverters._
 import scala.collection.mutable
 
-class WordReader extends Serializable {
+class WordReader(
+    storeContent: Boolean = false,
+    includePageBreaks: Boolean = false,
+    inferTableStructure: Boolean = false)
+    extends Serializable {
 
   private val spark = ResourceHelper.spark
   import spark.implicits._
@@ -40,9 +47,10 @@ class WordReader extends Serializable {
         val byteArray = portableDataStream.toArray()
         (path, byteArray)
       }
-      byteArrayRDD
+      val wordDf = byteArrayRDD
         .toDF("path", "content")
         .withColumn("doc", parseWordUDF(col("content")))
+      if (storeContent) wordDf.select("path", "doc", "content") else wordDf.select("path", "doc")
     } else throw new IllegalArgumentException(s"Invalid filePath: $filePath")
   }
 
@@ -75,10 +83,10 @@ class WordReader extends Serializable {
     try {
       if (isDocxFile(content)) {
         val document = new XWPFDocument(docInputStream)
-        val headers = DocxParser.extractHeaders(document).map { header =>
+        val headers = document.extractHeaders.map { header =>
           HTMLElement(ElementType.HEADER, header, mutable.Map())
         }
-        val footers = DocxParser.extractFooters(document).map { footer =>
+        val footers = document.extractFooters.map { footer =>
           HTMLElement(ElementType.FOOTER, footer, mutable.Map())
         }
         val docElements = parseDocxToElements(document)
@@ -102,10 +110,10 @@ class WordReader extends Serializable {
 
     val elements = document.getBodyElements.asScala.flatMap {
       case paragraph: XWPFParagraph =>
-        processParagraph(paragraph, document, "paragraph")
+        processParagraph(paragraph, "paragraph")
 
       case table: XWPFTable =>
-        processTable(table, document)
+        processTable(table)
 
       case _ => None
     }
@@ -115,21 +123,23 @@ class WordReader extends Serializable {
 
   private def processParagraph(
       paragraph: XWPFParagraph,
-      document: XWPFDocument,
-      source: String): Option[HTMLElement] = {
+      source: String,
+      tableLocation: mutable.Map[String, String] = mutable.Map()): Option[HTMLElement] = {
     val text = paragraph.getText.trim
     if (text.isEmpty) None
     else {
       val metadata = mutable.Map[String, String]()
 
-      if (paragraph.isCustomPageBreak) {
-        pageBreak += 1
-        metadata += ("pageBreak" -> pageBreak.toString)
+      if (includePageBreaks) {
+        val isBreak = paragraph.isCustomPageBreak || paragraph.isSectionBreak
+        if (isBreak) {
+          pageBreak += 1
+          metadata += ("pageBreak" -> pageBreak.toString)
+        }
       }
 
-      if (paragraph.isSectionBreak) {
-        pageBreak += 1
-        metadata += "pageBreak" -> pageBreak.toString
+      if (tableLocation.nonEmpty) {
+        metadata ++= tableLocation
       }
 
       val elementType = paragraph match {
@@ -141,14 +151,25 @@ class WordReader extends Serializable {
     }
   }
 
-  private def processTable(table: XWPFTable, document: XWPFDocument): Seq[HTMLElement] = {
-    table.getRows.asScala.flatMap { row =>
-      row.getTableCells.asScala.flatMap { cell =>
-        cell.getParagraphs.asScala.flatMap { paragraph =>
-          processParagraph(paragraph, document, "table")
+  private def processTable(table: XWPFTable): Seq[HTMLElement] = {
+    val tableHtml = if (inferTableStructure) Some(table.processAsHtml) else None
+
+    val tableElements: Seq[HTMLElement] = table.getRows.asScala.zipWithIndex.flatMap {
+      case (row, rowIndex) =>
+        row.getTableCells.asScala.zipWithIndex.flatMap { case (cell, cellIndex) =>
+          val tableLocation = mutable.Map("tableLocation" -> s"($rowIndex, $cellIndex)")
+          cell.getParagraphs.asScala.flatMap { paragraph =>
+            processParagraph(paragraph, "table", tableLocation)
+          }
         }
-      }
     }
+
+    if (tableHtml.isDefined) {
+      val htmlElement =
+        HTMLElement(ElementType.HTML, tableHtml.get, mutable.Map.empty[String, String])
+      tableElements :+ htmlElement
+    } else tableElements
+
   }
 
   private def parseDocToElements(document: HWPFDocument): Seq[HTMLElement] = {
diff --git a/src/main/scala/com/johnsnowlabs/reader/XMLReader.scala b/src/main/scala/com/johnsnowlabs/reader/XMLReader.scala
new file mode 100644
index 00000000000000..d0696f5cf05799
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/XMLReader.scala
@@ -0,0 +1,82 @@
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.nlp.util.io.ResourceHelper.validFile
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.{col, udf}
+
+import scala.collection.mutable
+import scala.collection.mutable.ListBuffer
+import scala.xml.{Elem, Node, XML}
+
+class XMLReader(
+    storeContent: Boolean = false,
+    xmlKeepTags: Boolean = false,
+    onlyLeafNodes: Boolean = true)
+    extends Serializable {
+
+  private val spark = ResourceHelper.spark
+  import spark.implicits._
+
+  def read(inputSource: String): DataFrame = {
+    if (validFile(inputSource)) {
+      val xmlDf = spark.sparkContext
+        .wholeTextFiles(inputSource)
+        .toDF("path", "content")
+        .withColumn("xml", parseHtmlUDF(col("content")))
+      if (storeContent) xmlDf.select("path", "content", "xml")
+      else xmlDf.select("path", "xml")
+    } else throw new IllegalArgumentException(s"Invalid inputSource: $inputSource")
+  }
+
+  private val parseHtmlUDF = udf((html: String) => {
+    parseXml(html)
+  })
+
+  private def parseXml(xmlString: String): List[HTMLElement] = {
+    val xml = XML.loadString(xmlString)
+    val elements = ListBuffer[HTMLElement]()
+
+    def traverse(node: Node, parentId: Option[String]): Unit = {
+      node match {
+        case elem: Elem =>
+          val tagName = elem.label.toLowerCase
+          val textContent = elem.text.trim
+          val elementId = hash(tagName + textContent)
+
+          val isLeaf = !elem.child.exists(_.isInstanceOf[Elem])
+
+          if (!onlyLeafNodes || isLeaf) {
+            val elementType = tagName match {
+              case "title" | "author" => ElementType.TITLE
+              case _ => ElementType.UNCATEGORIZED_TEXT
+            }
+
+            val metadata = mutable.Map[String, String]("elementId" -> elementId)
+            if (xmlKeepTags) metadata += ("tag" -> tagName)
+            parentId.foreach(id => metadata += ("parentId" -> id))
+
+            val content = if (isLeaf) textContent else ""
+            elements += HTMLElement(elementType, content, metadata)
+          }
+
+          // Traverse children
+          elem.child.foreach(traverse(_, Some(elementId)))
+
+        case _ => // Ignore other types
+      }
+    }
+
+    traverse(xml, None)
+    elements.toList
+  }
+
+  def hash(s: String): String = {
+    java.security.MessageDigest
+      .getInstance("MD5")
+      .digest(s.getBytes)
+      .map("%02x".format(_))
+      .mkString
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/DocxParser.scala b/src/main/scala/com/johnsnowlabs/reader/util/DocxParser.scala
index 966e85f5c6749e..0a03bccbab784b 100644
--- a/src/main/scala/com/johnsnowlabs/reader/util/DocxParser.scala
+++ b/src/main/scala/com/johnsnowlabs/reader/util/DocxParser.scala
@@ -15,7 +15,13 @@
  */
 package com.johnsnowlabs.reader.util
 
-import org.apache.poi.xwpf.usermodel.{ParagraphAlignment, XWPFDocument, XWPFParagraph, XWPFRun}
+import org.apache.poi.xwpf.usermodel.{
+  ParagraphAlignment,
+  XWPFDocument,
+  XWPFParagraph,
+  XWPFRun,
+  XWPFTable
+}
 
 import scala.collection.JavaConverters._
 
@@ -101,36 +107,58 @@ object DocxParser {
 
   }
 
-  def extractHeaders(document: XWPFDocument): Seq[String] = {
-    val headerFooterPolicy = Option(document.getHeaderFooterPolicy)
-    headerFooterPolicy.toSeq.flatMap { policy =>
-      Seq(
-        Option(policy.getDefaultHeader),
-        Option(policy.getFirstPageHeader),
-        Option(policy.getEvenPageHeader)).flatten
-        .flatMap { header =>
-          header.getParagraphs.asScala.map { paragraph =>
-            paragraph.getText.trim
+  implicit class RichXWPFDocument(document: XWPFDocument) {
+
+    def extractHeaders: Seq[String] = {
+      val headerFooterPolicy = Option(document.getHeaderFooterPolicy)
+      headerFooterPolicy.toSeq.flatMap { policy =>
+        Seq(
+          Option(policy.getDefaultHeader),
+          Option(policy.getFirstPageHeader),
+          Option(policy.getEvenPageHeader)).flatten
+          .flatMap { header =>
+            header.getParagraphs.asScala.map { paragraph =>
+              paragraph.getText.trim
+            }
           }
-        }
-        .filter(_.nonEmpty)
+          .filter(_.nonEmpty)
+      }
     }
-  }
 
-  def extractFooters(document: XWPFDocument): Seq[String] = {
-    val headerFooterPolicy = Option(document.getHeaderFooterPolicy)
-    headerFooterPolicy.toSeq.flatMap { policy =>
-      Seq(
-        Option(policy.getDefaultFooter),
-        Option(policy.getFirstPageFooter),
-        Option(policy.getEvenPageFooter)).flatten
-        .flatMap { footer =>
-          footer.getParagraphs.asScala.map { paragraph =>
-            paragraph.getText.trim
+    def extractFooters: Seq[String] = {
+      val headerFooterPolicy = Option(document.getHeaderFooterPolicy)
+      headerFooterPolicy.toSeq.flatMap { policy =>
+        Seq(
+          Option(policy.getDefaultFooter),
+          Option(policy.getFirstPageFooter),
+          Option(policy.getEvenPageFooter)).flatten
+          .flatMap { footer =>
+            footer.getParagraphs.asScala.map { paragraph =>
+              paragraph.getText.trim
+            }
           }
+          .filter(_.nonEmpty)
+      }
+    }
+  }
+
+  implicit class RichXWPFTable(table: XWPFTable) {
+
+    def processAsHtml: String = {
+      val htmlRows = table.getRows.asScala.zipWithIndex
+        .map { case (row, rowIndex) =>
+          val cellsHtml = row.getTableCells.asScala
+            .map { cell =>
+              val cellText = cell.getText
+              if (rowIndex == 0) s"$cellText" else s"$cellText"
+            }
+            .mkString("")
+          s"$cellsHtml"
         }
-        .filter(_.nonEmpty)
+        .mkString("")
+      s"$htmlRows
"
     }
+
   }
 
 }
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/PartitionOptions.scala b/src/main/scala/com/johnsnowlabs/reader/util/PartitionOptions.scala
new file mode 100644
index 00000000000000..e6986801e964fb
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/PartitionOptions.scala
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader.util
+
+import scala.util.Try
+
+object PartitionOptions {
+
+  def getDefaultBoolean(params: Map[String, String], options: Seq[String], default: Boolean): Boolean = {
+    options
+      .flatMap(params.get)
+      .map(_.trim.toLowerCase)
+      .flatMap(value => Try(value.toBoolean).toOption)
+      .headOption
+      .getOrElse(default)
+  }
+
+  def getDefaultInt(params: Map[String, String], options: Seq[String], default: Int): Int = {
+    options
+      .flatMap(params.get)
+      .flatMap(value => Try(value.toInt).toOption)
+      .headOption
+      .getOrElse(default)
+  }
+
+  def getDefaultString(params: Map[String, String], options: Seq[String], default: String): String = {
+    options
+      .flatMap(params.get)
+      .flatMap(value => Try(value).toOption)
+      .headOption
+      .getOrElse(default)
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/PptParser.scala b/src/main/scala/com/johnsnowlabs/reader/util/PptParser.scala
new file mode 100644
index 00000000000000..3651a06b22de0b
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/PptParser.scala
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.reader.util
+
+import com.johnsnowlabs.reader.{ElementType, HTMLElement}
+import org.apache.poi.hslf.usermodel.{HSLFSlide, HSLFTable, HSLFTextShape}
+import org.apache.poi.xslf.usermodel.{XSLFNotes, XSLFSlide, XSLFTable, XSLFTextShape}
+
+import scala.collection.JavaConverters._
+import scala.collection.mutable
+
+object PptParser {
+
+  implicit class RichHSLFSlide(slide: HSLFSlide) {
+    // Extract content from legacy PowerPoint slides (.ppt)
+    def extractHSLFSlideContent: Seq[HTMLElement] = {
+      val title = Option(slide.getTitle).getOrElse("")
+      val titleElement = if (title.nonEmpty) {
+        Seq(
+          HTMLElement(elementType = ElementType.TITLE, content = title, metadata = mutable.Map()))
+      } else Seq()
+
+      val content: Seq[HTMLElement] = slide.getShapes.asScala.flatMap {
+        case textShape: HSLFTextShape =>
+          textShape.getTextParagraphs.asScala.flatMap { paragraph =>
+            val isBullet = paragraph.isBullet
+            val bulletSymbol = Option(paragraph.getBulletChar).getOrElse("")
+            val paragraphText = paragraph.getTextRuns.asScala.map(_.getRawText).mkString("")
+
+            if (isBullet) {
+              Some(
+                HTMLElement(
+                  elementType = ElementType.LIST_ITEM,
+                  content = s"$bulletSymbol $paragraphText",
+                  metadata = mutable.Map()))
+            } else if (paragraphText.nonEmpty) {
+              Some(
+                HTMLElement(
+                  elementType = ElementType.NARRATIVE_TEXT,
+                  content = paragraphText,
+                  metadata = mutable.Map()))
+            } else {
+              None
+            }
+          }
+
+        case table: HSLFTable =>
+          val cellElements = (0 until table.getNumberOfRows).flatMap { rowIndex =>
+            (0 until table.getNumberOfColumns).map { colIndex =>
+              val cellContent =
+                Option(table.getCell(rowIndex, colIndex)).map(_.getText).getOrElse("").trim
+              HTMLElement(
+                elementType = ElementType.TABLE,
+                content = cellContent,
+                metadata =
+                  mutable.Map("tableLocation" -> s"(${rowIndex.toString}, ${colIndex.toString})"))
+            }
+          }
+
+          cellElements
+
+        case _ => Seq()
+      }
+
+      titleElement ++ content
+    }
+  }
+
+  implicit class RichXSLFSlide(slide: XSLFSlide) {
+
+    def extractXSLFSlideContent(
+        inferTableStructure: Boolean,
+        includeSlideNotes: Boolean): Seq[HTMLElement] = {
+      val title = Option(slide.getTitle).getOrElse("")
+      val titleElement = if (title.nonEmpty) {
+        Seq(
+          HTMLElement(elementType = ElementType.TITLE, content = title, metadata = mutable.Map()))
+      } else Seq()
+
+      val content: Seq[HTMLElement] = slide.getShapes.asScala.flatMap {
+        case textShape: XSLFTextShape
+            if textShape.getText != null &&
+              textShape.getText != title =>
+          textShape.getTextParagraphs.asScala.map { paragraph =>
+            val isBullet = paragraph.isBullet
+            val bulletSymbol = Option(paragraph.getBulletCharacter).getOrElse("")
+            val paragraphText = paragraph.getText
+            if (isBullet) {
+              HTMLElement(
+                elementType = ElementType.LIST_ITEM,
+                content = s"$bulletSymbol $paragraphText",
+                metadata = mutable.Map())
+            } else {
+              HTMLElement(
+                elementType = ElementType.NARRATIVE_TEXT,
+                content = paragraphText,
+                metadata = mutable.Map())
+            }
+          }
+        case table: XSLFTable =>
+          val cellElements = table.getRows.asScala.zipWithIndex.flatMap { case (row, rowIndex) =>
+            row.getCells.asScala.zipWithIndex.map { case (cell, colIndex) =>
+              val cellContent = Option(cell.getText).getOrElse("").trim // Extract cell content
+              HTMLElement(
+                elementType = ElementType.TABLE,
+                content = cellContent,
+                metadata =
+                  mutable.Map("tableLocation" -> s"(${rowIndex.toString}, ${colIndex.toString})"))
+            }
+          }
+          if (inferTableStructure) {
+            val tableHtml = buildTableHtml(table)
+            val htmlElement = HTMLElement("HTML", tableHtml, mutable.Map("element" -> "table"))
+            cellElements ++ Seq(htmlElement)
+          } else {
+            cellElements
+          }
+        case _ => Seq()
+      }
+
+      val speakerNotes = if (includeSlideNotes) extractSpeakerNotes(slide.getNotes) else Seq()
+
+      speakerNotes ++ titleElement ++ content
+    }
+
+  }
+
+  private def buildTableHtml(table: XSLFTable): String = {
+    val rowsHtml = table.getRows.asScala
+      .map { row =>
+        val cellsHtml = row.getCells.asScala
+          .map { cell =>
+            val cellText = Option(cell.getText).getOrElse("").trim
+            s"$cellText"
+          }
+          .mkString("")
+        s"$cellsHtml"
+      }
+      .mkString("")
+    s"$rowsHtml
"
+  }
+
+  private def extractSpeakerNotes(notes: XSLFNotes): Seq[HTMLElement] = {
+    notes.getShapes.asScala.collect {
+      case shape: XSLFTextShape if shape.getText != null && shape.getText.trim.nonEmpty =>
+        HTMLElement(
+          elementType = ElementType.NARRATIVE_TEXT,
+          content = shape.getText.trim,
+          metadata = mutable.Map())
+    }
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/TextParser.scala b/src/main/scala/com/johnsnowlabs/reader/util/TextParser.scala
new file mode 100644
index 00000000000000..6af1a763665876
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/TextParser.scala
@@ -0,0 +1,95 @@
+package com.johnsnowlabs.reader.util
+
+import com.johnsnowlabs.nlp.annotators.cleaners.util.CleanerHelper
+
+import scala.util.matching.Regex
+
+object TextParser {
+
+  private val eBulletPattern: Regex = "^e$".r
+  private val unicodeBulletsPattern: Regex =
+    ("^[" + CleanerHelper.UNICODE_BULLETS.mkString("") + "]").r
+
+  /** Groups paragraphs by processing text that uses blank lines to separate paragraphs.
+    *
+    * @param text
+    *   The input text.
+    * @param shortLineWordThreshold
+    *   The maximum number of words a line can have to be considered "short". Lines with fewer
+    *   words than this threshold will be treated as individual paragraphs. *
+    * @return
+    *   The processed text with paragraphs grouped.
+    */
+  def groupBrokenParagraphs(
+      text: String,
+      paragraphSplit: String,
+      shortLineWordThreshold: Int): String = {
+    // Split the text into paragraphs based on two or more newline sequences.
+    val paragraphs: Array[String] = text.split(paragraphSplit)
+    val cleanParagraphs = paragraphs.flatMap { paragraph =>
+      if (paragraph.trim.isEmpty) {
+        None
+      } else {
+        // Split the paragraph on single newline occurrences.
+        val paraSplit: Array[String] = paragraph.split("""\s*\n\s*""")
+        val allLinesShort =
+          paraSplit.forall(line => line.trim.split("\\s+").length < shortLineWordThreshold)
+        val trimmed = paragraph.trim
+        if (unicodeBulletsPattern
+            .findFirstIn(trimmed)
+            .isDefined || eBulletPattern.findFirstIn(trimmed).isDefined) {
+          groupBulletParagraph(paragraph)
+        } else if (allLinesShort) {
+          // If all lines are short, return the individual non-empty lines.
+          paraSplit.filter(_.trim.nonEmpty).toSeq
+        } else {
+          // Otherwise, replace newline sequences within the paragraph with a space.
+          Seq(paragraph.replaceAll("""\s*\n\s*""", " "))
+        }
+      }
+    }
+    cleanParagraphs.mkString("\n\n")
+  }
+
+  private def groupBulletParagraph(paragraph: String): Seq[String] = {
+    paragraph.split("\n").map(_.trim).filter(_.nonEmpty).toSeq
+  }
+
+  /** autoParagraphGrouper determines which paragraph grouping method to use based on the ratio of
+    * empty lines.
+    *
+    * @param text
+    *   The input text.
+    * @param maxLineCount
+    *   Maximum number of lines to inspect from the text when calculating the empty line ratio.
+    * @param threshold
+    *   The ratio threshold (empty lines / total lines) to decide which grouper to use. If the
+    *   ratio is below this value, newLineGrouper is used; otherwise, groupBrokenParagraphs is
+    *   used.
+    * @return
+    *   The processed text.
+    */
+  def autoParagraphGrouper(
+      text: String,
+      paragraphSplit: String,
+      maxLineCount: Int,
+      threshold: Double,
+      shortLineWordThreshold: Int): String = {
+    val lines = text.split("\n")
+    val count = Math.min(lines.length, maxLineCount)
+    var emptyLineCount = 0
+    for (i <- 0 until count) {
+      if (lines(i).trim.isEmpty) emptyLineCount += 1
+    }
+    val ratio = emptyLineCount.toDouble / count
+    if (ratio < threshold) newLineGrouper(text)
+    else groupBrokenParagraphs(text, paragraphSplit, shortLineWordThreshold)
+  }
+
+  // newLineGrouper concatenates text that uses a one-line paragraph break pattern.
+  private def newLineGrouper(text: String): String = {
+    val paragraphs = text.split("\n").map(_.trim).filter(_.nonEmpty)
+    paragraphs.mkString("\n\n")
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/XlsxParser.scala b/src/main/scala/com/johnsnowlabs/reader/util/XlsxParser.scala
new file mode 100644
index 00000000000000..e74cefc7854b60
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/XlsxParser.scala
@@ -0,0 +1,80 @@
+package com.johnsnowlabs.reader.util
+
+import com.johnsnowlabs.reader.HTMLElement
+import org.apache.poi.ss.usermodel.{Cell, CellType, DateUtil, HorizontalAlignment, Row, Sheet}
+
+import scala.collection.JavaConverters._
+import scala.collection.mutable
+
+object XlsxParser {
+
+  implicit class RichRow(row: Row) {
+
+    def isTitle(titleFontSizeThreshold: Int): Boolean = {
+      row.cellIterator().asScala.exists { cell =>
+        val cellStyle = cell.getCellStyle
+        val font = row.getSheet.getWorkbook.getFontAt(cellStyle.getFontIndexAsInt)
+
+        val isBold = font.getBold
+        val isCentered = cellStyle.getAlignment == HorizontalAlignment.CENTER
+
+        val text = cell.getCellValue.trim
+        val isUppercaseOrCapitalized =
+          text.nonEmpty && (text == text.toUpperCase || text.headOption.exists(_.isUpper))
+
+        val fontSize = font.getFontHeightInPoints
+        val isLargeFont = fontSize >= titleFontSizeThreshold
+
+        (isBold && isCentered) || (isBold && isUppercaseOrCapitalized) || (isBold && isLargeFont)
+      }
+    }
+  }
+
+  implicit class RichCell(cell: Cell) {
+
+    def getCellValue: String = {
+      cell.getCellType match {
+        case CellType.STRING => cell.getStringCellValue
+        case CellType.NUMERIC =>
+          if (DateUtil.isCellDateFormatted(cell))
+            cell.getDateCellValue.toString
+          else
+            cell.getNumericCellValue.toString
+        case CellType.BOOLEAN => cell.getBooleanCellValue.toString
+        case CellType.FORMULA => cell.getCellFormula
+        case _ => ""
+      }
+    }
+
+  }
+
+  implicit class RichSheet(sheet: Sheet) {
+
+    def buildHtmlIfNeeded(elementsBuffer: mutable.ArrayBuffer[HTMLElement]): Unit = {
+
+      val rowsHtml = sheet
+        .iterator()
+        .asScala
+        .flatMap { row =>
+          val cellsHtml = row
+            .cellIterator()
+            .asScala
+            .flatMap { cell =>
+              val cellValue = cell.getCellValue.trim
+              if (cellValue.nonEmpty) Some(s"$cellValue") else None
+            }
+            .mkString("")
+          if (cellsHtml.nonEmpty) Some(s"$cellsHtml") else None
+        }
+        .mkString("")
+
+      val sheetHtml = if (rowsHtml.nonEmpty) s"$rowsHtml
" else ""
+      if (sheetHtml.nonEmpty) {
+        val htmlElement =
+          HTMLElement("HTML", sheetHtml, mutable.Map("SheetName" -> sheet.getSheetName))
+        elementsBuffer += htmlElement
+      }
+    }
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/pdf/BinaryFile.scala b/src/main/scala/com/johnsnowlabs/reader/util/pdf/BinaryFile.scala
new file mode 100644
index 00000000000000..58b784615830b2
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/pdf/BinaryFile.scala
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader.util.pdf
+
+import com.johnsnowlabs.nlp.IAnnotation
+
+case class BinaryFile(bytes: Array[Byte], path: String) extends IAnnotation {
+
+  override def annotatorType: String = "binary_source_file"
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/pdf/HasInputValidator.scala b/src/main/scala/com/johnsnowlabs/reader/util/pdf/HasInputValidator.scala
new file mode 100644
index 00000000000000..2c32210c07e810
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/pdf/HasInputValidator.scala
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader.util.pdf
+
+import org.apache.spark.sql.types.{ArrayType, DataType, MapType, StructType}
+
+trait HasInputValidator {
+  val uid: String
+
+  def compareDataTypes(dtype1: DataType, dtype2: DataType): Boolean = {
+    if (dtype1.getClass != dtype2.getClass) {
+      return false
+    }
+
+    (dtype1, dtype2) match {
+      case (a1: ArrayType, a2: ArrayType) =>
+        compareDataTypes(a1.elementType, a2.elementType)
+
+      case (s1: StructType, s2: StructType) =>
+        if (s1.fields.length != s2.fields.length) {
+          return false
+        }
+        s1.fields.zip(s2.fields).forall { case (field1, field2) =>
+          field1.name == field2.name && compareDataTypes(field1.dataType, field2.dataType)
+        }
+
+      case (m1: MapType, m2: MapType) =>
+        compareDataTypes(m1.keyType, m2.keyType) && compareDataTypes(m1.valueType, m2.valueType)
+
+      case _ =>
+        dtype1 == dtype2
+    }
+  }
+
+  def validateInputCol(schema: StructType, colName: String, colType: DataType) {
+    require(
+      schema.exists(_.name == colName),
+      s"Missing input column in $uid: Column '${colName}' is not present." +
+        s"Make sure such transformer exist in your pipeline, " +
+        s"with the right output names.")
+    require(
+      compareDataTypes(schema.find(_.name == colName).map(_.dataType).get, colType),
+      s"Column '${colName}' is not a valid ${colType} in $uid")
+  }
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/pdf/HasLocalProcess.scala b/src/main/scala/com/johnsnowlabs/reader/util/pdf/HasLocalProcess.scala
new file mode 100644
index 00000000000000..840751100afcd4
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/pdf/HasLocalProcess.scala
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader.util.pdf
+
+import com.johnsnowlabs.nlp.IAnnotation
+
+trait HasLocalProcess {
+
+  def localProcess(
+      input: Array[Map[String, Seq[IAnnotation]]]): Array[Map[String, Seq[IAnnotation]]]
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/pdf/OcrText.scala b/src/main/scala/com/johnsnowlabs/reader/util/pdf/OcrText.scala
new file mode 100644
index 00000000000000..7b06f5eadb07ec
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/pdf/OcrText.scala
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader.util.pdf
+
+import com.johnsnowlabs.nlp.IAnnotation
+
+case class OcrText(
+    text: String,
+    metadata: Map[String, String],
+    content: Array[Byte] = Array.empty[Byte])
+    extends IAnnotation {
+
+  override def annotatorType: String = "image_to_text"
+  def begin = 0
+  def end = text.length
+  def result = text
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/pdf/PageNum.scala b/src/main/scala/com/johnsnowlabs/reader/util/pdf/PageNum.scala
new file mode 100644
index 00000000000000..4c30d679c03b82
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/pdf/PageNum.scala
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader.util.pdf
+
+import com.johnsnowlabs.nlp.IAnnotation
+
+case class PageNum(value: Int) extends IAnnotation {
+  override def annotatorType: String = "pagenum"
+}
diff --git a/src/main/scala/com/johnsnowlabs/reader/util/pdf/PdfUtils.scala b/src/main/scala/com/johnsnowlabs/reader/util/pdf/PdfUtils.scala
new file mode 100644
index 00000000000000..1ecc96f7160823
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/reader/util/pdf/PdfUtils.scala
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader.util.pdf
+
+trait PdfUtils {
+  val MAX_CHARACTER_BEFORE_HEADER = 1000
+
+  def checkAndFixPdf(content: Array[Byte]): Array[Byte] = {
+    val pdfStartIndex = new String(
+      content.slice(0, Math.min(MAX_CHARACTER_BEFORE_HEADER, content.length))).indexOf("%PDF")
+    if (pdfStartIndex == -1) throw new RuntimeException("Pdf document is not valid")
+    val validContent = content.slice(pdfStartIndex, content.length)
+    validContent
+  }
+
+}
diff --git a/src/test/resources/images/demo.jpeg b/src/test/resources/images/demo.jpeg
new file mode 100644
index 00000000000000..9fdc0400506245
Binary files /dev/null and b/src/test/resources/images/demo.jpeg differ
diff --git a/src/test/resources/images/image1.jpg b/src/test/resources/images/image1.jpg
new file mode 100644
index 00000000000000..676d2b343b2103
Binary files /dev/null and b/src/test/resources/images/image1.jpg differ
diff --git a/src/test/resources/reader/html/xml-example.xml b/src/test/resources/reader/html/xml-example.xml
new file mode 100644
index 00000000000000..83b100580081a9
--- /dev/null
+++ b/src/test/resources/reader/html/xml-example.xml
@@ -0,0 +1,7 @@
+
+    101
+    Jane Doe
+    jane.doe@example.com
+    true
+    29
+
\ No newline at end of file
diff --git a/src/test/resources/reader/pdf/image_3_pages.pdf b/src/test/resources/reader/pdf/image_3_pages.pdf
new file mode 100644
index 00000000000000..3ef6bcf538cae6
Binary files /dev/null and b/src/test/resources/reader/pdf/image_3_pages.pdf differ
diff --git a/src/test/resources/reader/pdf/pdf-title.pdf b/src/test/resources/reader/pdf/pdf-title.pdf
new file mode 100644
index 00000000000000..3e3ee79597c26f
Binary files /dev/null and b/src/test/resources/reader/pdf/pdf-title.pdf differ
diff --git a/src/test/resources/reader/pdf/text_3_pages.pdf b/src/test/resources/reader/pdf/text_3_pages.pdf
new file mode 100644
index 00000000000000..fd54f072e9d737
Binary files /dev/null and b/src/test/resources/reader/pdf/text_3_pages.pdf differ
diff --git a/src/test/resources/reader/ppt/fake-power-point-table.pptx b/src/test/resources/reader/ppt/fake-power-point-table.pptx
new file mode 100755
index 00000000000000..3e49ae3df04e86
Binary files /dev/null and b/src/test/resources/reader/ppt/fake-power-point-table.pptx differ
diff --git a/src/test/resources/reader/ppt/fake-power-point.pptx b/src/test/resources/reader/ppt/fake-power-point.pptx
new file mode 100755
index 00000000000000..01d84494896d57
Binary files /dev/null and b/src/test/resources/reader/ppt/fake-power-point.pptx differ
diff --git a/src/test/resources/reader/ppt/speaker-notes.pptx b/src/test/resources/reader/ppt/speaker-notes.pptx
new file mode 100644
index 00000000000000..16b7c42ea1b0dd
Binary files /dev/null and b/src/test/resources/reader/ppt/speaker-notes.pptx differ
diff --git a/src/test/resources/reader/txt/long-text.txt b/src/test/resources/reader/txt/long-text.txt
new file mode 100644
index 00000000000000..cadaab9be2048e
--- /dev/null
+++ b/src/test/resources/reader/txt/long-text.txt
@@ -0,0 +1 @@
+Ukrainian forces reportedly advanced in the western Donetsk-eastern Zaporizhia Oblast border area and in western Zaporizhia Oblast amid Ukrainian counteroffensive operations in southern and eastern Ukraine. Tavriisk Group of Forces Spokesperson Oleksandr Shtupun reported that Ukrainian forces are advancing in the directions of Novoprokopivka (13km south of Orikhiv), Mala Tokmachka (9km southeast of Orikhiv), and Ocheretuvate (25km southeast of Orikhiv) in western Zaporizhia Oblast.[1] Shtupun also stated that Ukrainian forces advanced near Urozhaine (9km south of Velyka Novosilka) and Robotyne (10km south of Orikhiv) and achieved unspecified successes near Staromayorske (9km south of Velyka Novosilka) in the Berdyansk direction (western Donetsk-eastern Zaporizhia Oblast border area) and in an unspecified location in the Melitopol direction (western Zaporizhia Oblast).[2] Ukrainian Eastern Group of Forces Spokesperson Ilya Yevlash stated that Ukrainian forces continued offensive operations in the Bakhmut direction.[3]
\ No newline at end of file
diff --git a/src/test/resources/reader/txt/simple-text.txt b/src/test/resources/reader/txt/simple-text.txt
new file mode 100644
index 00000000000000..dfc415d8d6701e
--- /dev/null
+++ b/src/test/resources/reader/txt/simple-text.txt
@@ -0,0 +1,9 @@
+BIG DATA ANALYTICS
+
+Apache Spark is a fast and general-purpose cluster computing system.
+It provides high-level APIs in Java, Scala, Python, and R.
+
+MACHINE LEARNING
+
+Spark's MLlib provides scalable machine learning algorithms.
+It includes tools for classification, regression, clustering, and more.
diff --git a/src/test/resources/reader/txt/test-paragraph.txt b/src/test/resources/reader/txt/test-paragraph.txt
new file mode 100644
index 00000000000000..5d9920cc198a5d
--- /dev/null
+++ b/src/test/resources/reader/txt/test-paragraph.txt
@@ -0,0 +1,5 @@
+The big brown fox
+was walking down the lane.
+
+At the end of the lane,
+the fox met a bear.
\ No newline at end of file
diff --git a/src/test/resources/reader/xls/2023-half-year-analyses-by-segment.xlsx b/src/test/resources/reader/xls/2023-half-year-analyses-by-segment.xlsx
new file mode 100755
index 00000000000000..d0ce5e673c7c26
Binary files /dev/null and b/src/test/resources/reader/xls/2023-half-year-analyses-by-segment.xlsx differ
diff --git a/src/test/resources/reader/xls/page-break-example.xlsx b/src/test/resources/reader/xls/page-break-example.xlsx
new file mode 100644
index 00000000000000..acdc7e7838d425
Binary files /dev/null and b/src/test/resources/reader/xls/page-break-example.xlsx differ
diff --git a/src/test/resources/reader/xls/vodafone.xlsx b/src/test/resources/reader/xls/vodafone.xlsx
new file mode 100755
index 00000000000000..4467a9301d55f5
Binary files /dev/null and b/src/test/resources/reader/xls/vodafone.xlsx differ
diff --git a/src/test/resources/reader/xls/xlsx-subtable-cases.xlsx b/src/test/resources/reader/xls/xlsx-subtable-cases.xlsx
new file mode 100644
index 00000000000000..944533d3847b65
Binary files /dev/null and b/src/test/resources/reader/xls/xlsx-subtable-cases.xlsx differ
diff --git a/src/test/resources/reader/xml/multi-level.xml b/src/test/resources/reader/xml/multi-level.xml
new file mode 100644
index 00000000000000..e14e5ad684be30
--- /dev/null
+++ b/src/test/resources/reader/xml/multi-level.xml
@@ -0,0 +1,20 @@
+
+    

+        
+            
+                The Alchemist
+                Paulo Coelho
+                1988
+            
+        
+    

+    

+        
+            
+                A Brief History of Time
+                Stephen Hawking
+                1988
+            
+        
+    

+
diff --git a/src/test/resources/reader/xml/test.xml b/src/test/resources/reader/xml/test.xml
new file mode 100644
index 00000000000000..44bdab910b4c96
--- /dev/null
+++ b/src/test/resources/reader/xml/test.xml
@@ -0,0 +1,14 @@
+
+    
+        Harry Potter
+        J K. Rowling
+        2005
+        29.99
+    
+    
+        Learning XML
+        Erik T. Ray
+        2003
+        39.95
+    
+
\ No newline at end of file
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/AlbertForMultipleChoiceTest.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/AlbertForMultipleChoiceTest.scala
new file mode 100644
index 00000000000000..1385f41d94f502
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/AlbertForMultipleChoiceTest.scala
@@ -0,0 +1,67 @@
+package com.johnsnowlabs.nlp.annotators.classifier.dl
+
+import com.johnsnowlabs.nlp.{Annotation, AssertAnnotations, MultiDocumentAssembler}
+import com.johnsnowlabs.nlp.annotators.SparkSessionTest
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.tags.SlowTest
+import org.apache.spark.ml.Pipeline
+import org.scalatest.flatspec.AnyFlatSpec
+
+class AlbertForMultipleChoiceTest extends AnyFlatSpec with SparkSessionTest {
+
+  import spark.implicits._
+
+  lazy val pipelineModel = getAlbertForMultipleChoicePipelineModel
+
+  val testDataframe =
+    Seq(("The Eiffel Tower is located in which country?", "Germany, France, Italy"))
+      .toDF("question", "context")
+
+  "AlbertForMultipleChoice" should "answer a multiple choice question" taggedAs SlowTest in {
+    val resultDf = pipelineModel.transform(testDataframe)
+    resultDf.show(truncate = false)
+
+    val result = AssertAnnotations.getActualResult(resultDf, "answer")
+    result.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+  }
+
+  it should "work with light pipeline fullAnnotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(pipelineModel)
+    val resultFullAnnotate = lightPipeline.fullAnnotate(
+      "The Eiffel Tower is located in which country?",
+      "Germany, France, Italy")
+    println(s"resultAnnotate: $resultFullAnnotate")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(pipelineModel)
+    val resultAnnotate = lightPipeline.annotate(
+      "The Eiffel Tower is located in which country?",
+      "Germany, France, Italy")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.nonEmpty)
+  }
+
+  private def getAlbertForMultipleChoicePipelineModel = {
+    val documentAssembler = new MultiDocumentAssembler()
+      .setInputCols("question", "context")
+      .setOutputCols("document_question", "document_context")
+
+    val bertForMultipleChoice = AlbertForMultipleChoice
+      .pretrained()
+      .setInputCols("document_question", "document_context")
+      .setOutputCol("answer")
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, bertForMultipleChoice))
+
+    pipeline.fit(emptyDataSet)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/DistilBertForMultipleChoiceTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/DistilBertForMultipleChoiceTestSpec.scala
new file mode 100644
index 00000000000000..8648a3884a5302
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/DistilBertForMultipleChoiceTestSpec.scala
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.classifier.dl
+
+import com.johnsnowlabs.nlp.{Annotation, AssertAnnotations, MultiDocumentAssembler}
+import com.johnsnowlabs.nlp.annotators.SparkSessionTest
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.tags.SlowTest
+import org.apache.spark.ml.{Pipeline, PipelineModel}
+import org.scalatest.flatspec.AnyFlatSpec
+
+class DistilBertForMultipleChoiceTestSpec extends AnyFlatSpec with SparkSessionTest {
+
+  import spark.implicits._
+
+  lazy val pipelineModel = getDistilBertForMultipleChoicePipelineModel
+
+  val testDataframe =
+    Seq(("The Eiffel Tower is located in which country?", "Germany, France, Italy"))
+      .toDF("question", "context")
+
+  "DistilBertForMultipleChoiceTestSpec" should "answer a multiple choice question" taggedAs SlowTest in {
+    val resultDf = pipelineModel.transform(testDataframe)
+    resultDf.show(truncate = false)
+
+    val result = AssertAnnotations.getActualResult(resultDf, "answer")
+    result.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+  }
+
+  it should "work with light pipeline fullAnnotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(pipelineModel)
+    val resultFullAnnotate = lightPipeline.fullAnnotate(
+      "The Eiffel Tower is located in which country?",
+      "Germany, France, Italy")
+    println(s"resultAnnotate: $resultFullAnnotate")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(pipelineModel)
+    val resultAnnotate = lightPipeline.annotate(
+      "The Eiffel Tower is located in which country?",
+      "Germany, France, Italy")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.nonEmpty)
+  }
+
+  private def getDistilBertForMultipleChoicePipelineModel: PipelineModel = {
+    val documentAssembler = new MultiDocumentAssembler()
+      .setInputCols("question", "context")
+      .setOutputCols("document_question", "document_context")
+
+    val bertForMultipleChoice = DistilBertForMultipleChoice
+      .pretrained()
+      .setInputCols("document_question", "document_context")
+      .setOutputCol("answer")
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, bertForMultipleChoice))
+
+    pipeline.fit(emptyDataSet)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/RobertaForMultipleChoiceTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/RobertaForMultipleChoiceTestSpec.scala
new file mode 100644
index 00000000000000..4dec950c81bc84
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/RobertaForMultipleChoiceTestSpec.scala
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.classifier.dl
+
+import com.johnsnowlabs.nlp.{Annotation, AssertAnnotations, MultiDocumentAssembler}
+import com.johnsnowlabs.nlp.annotators.SparkSessionTest
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.tags.SlowTest
+import org.apache.spark.ml.Pipeline
+import org.scalatest.flatspec.AnyFlatSpec
+
+class RobertaForMultipleChoiceTestSpec extends AnyFlatSpec with SparkSessionTest {
+
+  import spark.implicits._
+
+  lazy val pipelineModel = getRoBertaForMultipleChoicePipelineModel
+
+  val testDataframe =
+    Seq(("The Eiffel Tower is located in which country?", "Germany, France, Italy"))
+      .toDF("question", "context")
+
+  "RobertaForMultipleChoice" should "answer a multiple choice question" taggedAs SlowTest in {
+    val resultDf = pipelineModel.transform(testDataframe)
+    resultDf.show(truncate = false)
+
+    val result = AssertAnnotations.getActualResult(resultDf, "answer")
+    result.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+  }
+
+  it should "work with light pipeline fullAnnotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(pipelineModel)
+    val resultFullAnnotate = lightPipeline.fullAnnotate(
+      "The Eiffel Tower is located in which country?",
+      "Germany, France, Italy")
+    println(s"resultAnnotate: $resultFullAnnotate")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(pipelineModel)
+    val resultAnnotate = lightPipeline.annotate(
+      "The Eiffel Tower is located in which country?",
+      "Germany, France, Italy")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.nonEmpty)
+  }
+
+  private def getRoBertaForMultipleChoicePipelineModel = {
+    val documentAssembler = new MultiDocumentAssembler()
+      .setInputCols("question", "context")
+      .setOutputCols("document_question", "document_context")
+
+    val bertForMultipleChoice = RoBertaForMultipleChoice
+      .pretrained()
+      .setInputCols("document_question", "document_context")
+      .setOutputCol("answer")
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, bertForMultipleChoice))
+
+    pipeline.fit(emptyDataSet)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/XlmRoBertaForMultipleChoiceTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/XlmRoBertaForMultipleChoiceTestSpec.scala
new file mode 100644
index 00000000000000..2e571cf2662b19
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/classifier/dl/XlmRoBertaForMultipleChoiceTestSpec.scala
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.classifier.dl
+
+import com.johnsnowlabs.nlp.{Annotation, AssertAnnotations, MultiDocumentAssembler}
+import com.johnsnowlabs.nlp.annotators.SparkSessionTest
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.tags.SlowTest
+import org.apache.spark.ml.Pipeline
+import org.scalatest.flatspec.AnyFlatSpec
+
+class XlmRoBertaForMultipleChoiceTestSpec extends AnyFlatSpec with SparkSessionTest {
+
+  import spark.implicits._
+
+  lazy val pipelineModel = getXlmRoBertaForMultipleChoicePipelineModel
+
+  val testDataframe =
+    Seq(("The Eiffel Tower is located in which country?", "Germany, France, Italy"))
+      .toDF("question", "context")
+
+  "XlmRoBertaForMultipleChoice" should "answer a multiple choice question" taggedAs SlowTest in {
+    val resultDf = pipelineModel.transform(testDataframe)
+    resultDf.show(truncate = false)
+
+    val result = AssertAnnotations.getActualResult(resultDf, "answer")
+    result.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+  }
+
+  it should "work with light pipeline fullAnnotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(pipelineModel)
+    val resultFullAnnotate = lightPipeline.fullAnnotate(
+      "The Eiffel Tower is located in which country?",
+      "Germany, France, Italy")
+    println(s"resultAnnotate: $resultFullAnnotate")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(pipelineModel)
+    val resultAnnotate = lightPipeline.annotate(
+      "The Eiffel Tower is located in which country?",
+      "Germany, France, Italy")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.nonEmpty)
+  }
+
+  private def getXlmRoBertaForMultipleChoicePipelineModel = {
+    val documentAssembler = new MultiDocumentAssembler()
+      .setInputCols("question", "context")
+      .setOutputCols("document_question", "document_context")
+
+    val bertForMultipleChoice = XlmRoBertaForMultipleChoice
+      .pretrained()
+      .setInputCols("document_question", "document_context")
+      .setOutputCol("answer")
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, bertForMultipleChoice))
+
+    pipeline.fit(emptyDataSet)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/CleanerTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/CleanerTestSpec.scala
new file mode 100644
index 00000000000000..2eab07b26b7df0
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/CleanerTestSpec.scala
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.cleaners
+
+import com.johnsnowlabs.nlp.annotators.SparkSessionTest
+import com.johnsnowlabs.tags.{FastTest, SlowTest}
+import org.apache.spark.ml.Pipeline
+import org.scalatest.flatspec.AnyFlatSpec
+
+class CleanerTestSpec extends AnyFlatSpec with SparkSessionTest {
+
+  import spark.implicits._
+
+  "Cleaner" should "convert an output string that looks like a byte string to a string using the specified encoding" taggedAs FastTest in {
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("bytes_string_to_string")
+
+    val testDf =
+      Seq("This is a test with regular text", "Hello ð\\x9f\\x98\\x80").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+  "Cleaner" should "clean text" taggedAs FastTest in {
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("clean")
+      .setBullets(true)
+      .setExtraWhitespace(true)
+      .setDashes(true)
+
+    val testDf = Seq("● An excellent point!", "ITEM 1A:     RISK-FACTORS").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+  "Cleaner" should "clean non-ascii characters" taggedAs FastTest in {
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("clean_non_ascii_chars")
+
+    val testDf = Seq("\\x88This text contains ®non-ascii characters!●").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+  "Cleaner" should "clean ordered bullets" taggedAs FastTest in {
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("clean_ordered_bullets")
+
+    val testDf = Seq(
+      "1.1 This is a very important point",
+      "a.1 This is a very important point",
+      "1.4.2 This is a very important point").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+  it should "clean postfix" taggedAs FastTest in {
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("clean_postfix")
+      .setCleanPrefixPattern("(END|STOP)")
+
+    val testDf = Seq("The end! END").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+  it should "clean prefix" taggedAs FastTest in {
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("clean_prefix")
+      .setCleanPrefixPattern("(SUMMARY|DESCRIPTION):")
+
+    val testDf = Seq("SUMMARY: This is the best summary of all time!").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+  it should "remove punctuation" taggedAs FastTest in {
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("remove_punctuation")
+
+    val testDf = Seq("$A lovely quote!”").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+  it should "replace unicode quotes" taggedAs FastTest in {
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("replace_unicode_characters")
+
+    val testDf = Seq(
+      """\x93A lovely quote!\x94""",
+      """\x91A lovely quote!\x92""",
+      """"\u201CA lovely quote!\u201D — with a dash"""").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+  it should "translate text" taggedAs SlowTest in {
+    val cleaner = Cleaner
+      .pretrained()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+
+    val testDf = Seq("This should go to French").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, cleaner))
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+    resultDf.select("cleaned").show(truncate = false)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/ExtractorTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/ExtractorTestSpec.scala
new file mode 100644
index 00000000000000..e9c3aaa683ed1e
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/ExtractorTestSpec.scala
@@ -0,0 +1,350 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.cleaners
+
+import com.johnsnowlabs.nlp.AssertAnnotations
+import com.johnsnowlabs.nlp.annotators.SparkSessionTest
+import com.johnsnowlabs.tags.FastTest
+import org.apache.spark.ml.Pipeline
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers.convertToAnyShouldWrapper
+
+class ExtractorTestSpec extends AnyFlatSpec with SparkSessionTest {
+
+  import spark.implicits._
+
+  val emlData =
+    "from ABC.DEF.local ([ba23::58b5:2236:45g2:88h2]) by\n  \\n ABC.DEF.local2 ([ba23::58b5:2236:45g2:88h2%25]) with mapi id\\\n  n 32.88.5467.123; Fri, 26 Mar 2021 11:04:09 +1200"
+
+  "Extractor" should "be able to extract dates" taggedAs FastTest in {
+    val dateExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("date")
+      .setExtractorMode("email_date")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, dateExtractor))
+    val testDf = Seq(
+      emlData,
+      "First date Fri, 26 Mar 2021 11:04:09 +1200 and then another date Wed, 26 Jul 2025 11:04:09 +1200").toDS
+      .toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "date")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(
+      Seq("Fri, 26 Mar 2021 11:04:09 +1200"),
+      Seq("Fri, 26 Mar 2021 11:04:09 +1200", "Wed, 26 Jul 2025 11:04:09 +1200"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract email addresses" taggedAs FastTest in {
+    val emailExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("email")
+      .setExtractorMode("email_address")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, emailExtractor))
+    val testDf = Seq(
+      "Me me@email.com and You \n  ([ba23::58b5:2236:45g2:88h2]) (10.0.2.01)",
+      "Im Rabn ").toDS.toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "email")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("me@email.com", "You@email.com"), Seq("Im.Rabn@npf.gov.nr"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract IPv4 and IPv6 addresses" taggedAs FastTest in {
+    val ipAddressExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("ip")
+      .setExtractorMode("ip_address")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, ipAddressExtractor))
+    val testDf = Seq("""from ABC.DEF.local ([ba23::58b5:2236:45g2:88h2]) by
+    \n ABC.DEF.local ([68.183.71.12]) with mapi id\
+    n 32.88.5467.123; Fri, 26 Mar 2021 11:04:09 +1200""").toDS
+      .toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "ip")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("ba23::58b5:2236:45g2:88h2", "68.183.71.12"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract only IPv4 addresses" taggedAs FastTest in {
+    val ipAddressExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("ip")
+      .setExtractorMode("ip_address")
+      .setIpAddressPattern(
+        "(?:25[0-5]|2[0-4]\\d|1\\d{2}|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d{2}|[1-9]?\\d)){3}")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, ipAddressExtractor))
+    val testDf =
+      Seq("Me me@email.com and You  ([ba23::58b5:2236:45g2:88h2]) (10.0.2.0)").toDS
+        .toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "ip")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("10.0.2.0"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract only IP address name" taggedAs FastTest in {
+    val ipAddressExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("ip")
+      .setExtractorMode("ip_address_name")
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, ipAddressExtractor))
+    val testDf = Seq(emlData).toDS.toDF("text")
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "ip")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("ABC.DEF.local", "ABC.DEF.local"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract only MAPI IDs" taggedAs FastTest in {
+    val mapiIdExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("mapi_id")
+      .setExtractorMode("mapi_id")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, mapiIdExtractor))
+    val testDf = Seq(emlData).toDS.toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "mapi_id")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("32.88.5467.123"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract US phone numbers" taggedAs FastTest in {
+    val usPhonesExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("us_phone")
+      .setExtractorMode("us_phone_numbers")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, usPhonesExtractor))
+    val testDf =
+      Seq("215-867-5309", "Phone Number: +1 215.867.5309", "Phone Number: Just Kidding").toDS
+        .toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "us_phone")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("215-867-5309"), Seq("+1 215.867.5309"), Seq())
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract bullets" taggedAs FastTest in {
+    val bulletExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("bullets")
+      .setExtractorMode("bullets")
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, bulletExtractor))
+    val testDf = Seq(
+      "1. Introduction:",
+      "a. Introduction:",
+      "20.3 Morse code ●●●",
+      "5.3.1 Convolutional Networks",
+      "D.b.C Recurrent Neural Networks",
+      "2.b.1 Recurrent Neural Networks",
+      "eins. Neural Networks",
+      "bb.c Feed Forward Neural Networks",
+      "aaa.ccc Metrics",
+      "version = 3.8",
+      "1 2. 3 4",
+      "1) 2. 3 4",
+      "2",
+      "1..2.3 four",
+      "Fig. 2: The relationship",
+      "23 is everywhere",
+      "• bullet 1").toDS.toDF("text")
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "bullets")
+    val actualResult: Array[Seq[String]] = resultAnnotation.map(_.map(_.result))
+    val expectedResult: Array[Seq[String]] = Array(
+      Seq("(1,None,None)"),
+      Seq("(a,None,None)"),
+      Seq("(20,3,None)"),
+      Seq("(5,3,1)"),
+      Seq("(D,b,C)"),
+      Seq("(2,b,1)"),
+      Seq("(None,None,None)"),
+      Seq("(bb,c,None)"),
+      Seq("(None,None,None)"),
+      Seq("(None,None,None)"),
+      Seq("(None,None,None)"),
+      Seq("(None,None,None)"),
+      Seq("(None,None,None)"),
+      Seq("(None,None,None)"),
+      Seq("(None,None,None)"),
+      Seq("(None,None,None)"),
+      Seq("(None,None,None)"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract image URLs" taggedAs FastTest in {
+    val imageUrlExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("image_urls")
+      .setExtractorMode("image_urls")
+
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, imageUrlExtractor))
+    val testDf = Seq("""
+      
+      
+      
+      """).toDS.toDF("text")
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "image_urls")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult =
+      Array(Seq("https://example.com/images/photo1.jpg", "https://example.org/assets/icon.png"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract images for different cases" taggedAs FastTest in {
+    val imageUrlExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("image_urls")
+      .setExtractorMode("image_urls")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, imageUrlExtractor))
+    val testDf = Seq(
+      "https://my-image.jpg",
+      "https://my-image.png with some text",
+      "https://my-image/with/some/path.png",
+      "some text https://my-image.jpg with another http://my-image.bmp",
+      "http://not-an-image.com",
+      "some text",
+      "some text https://my-image.JPG with ano100" +
+        "ther http://my-image.BMP",
+      "http://my-path-with-CAPS/my-image.JPG",
+      "http://my-path/my%20image.JPG",
+      "https://my-image.jpg#ref").toDS.toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "image_urls")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(
+      Seq("https://my-image.jpg"),
+      Seq("https://my-image.png"),
+      Seq("https://my-image/with/some/path.png"),
+      Seq("https://my-image.jpg", "http://my-image.bmp"),
+      Seq(),
+      Seq(),
+      Seq("https://my-image.JPG", "http://my-image.BMP"),
+      Seq("http://my-path-with-CAPS/my-image.JPG"),
+      Seq("http://my-path/my%20image.JPG"),
+      Seq("https://my-image.jpg"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract text after" taggedAs FastTest in {
+    val textAfterExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("text_after")
+      .setExtractorMode("text_after")
+      .setTextPattern("SPEAKER \\d{1}:")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, textAfterExtractor))
+    val testDf = Seq("SPEAKER 1: Look at me, I'm flying!").toDS.toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "text_after")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("Look at me, I'm flying!"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract text after with a pattern with punctuation" taggedAs FastTest in {
+    val textAfterExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("text_after")
+      .setExtractorMode("text_after")
+      .setTextPattern("BLAH;")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, textAfterExtractor))
+    val testDf = Seq("Teacher: BLAH BLAH BLAH; Student: BLAH BLAH BLAH!").toDS.toDF("text")
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "text_after")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("Student: BLAH BLAH BLAH!"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract text before" taggedAs FastTest in {
+    val textAfterExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("text_before")
+      .setExtractorMode("text_before")
+      .setTextPattern("STOP")
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, textAfterExtractor))
+    val testDf = Seq("Here I am! STOP Look at me! STOP I'm flying! STOP").toDS.toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "text_before")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("Here I am!"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+  it should "be able to extract text before with index" taggedAs FastTest in {
+    val textAfterExtractor = new Extractor()
+      .setInputCols("document")
+      .setOutputCol("text_before")
+      .setExtractorMode("text_before")
+      .setTextPattern("BLAH")
+      .setIndex(1)
+    val pipeline = new Pipeline().setStages(Array(documentAssembler, textAfterExtractor))
+    val testDf = Seq("Teacher: BLAH BLAH BLAH; Student: BLAH BLAH BLAH!").toDS.toDF("text")
+
+    val resultDf = pipeline.fit(testDf).transform(testDf)
+
+    val resultAnnotation = AssertAnnotations.getActualResult(resultDf, "text_before")
+    val actualResult = resultAnnotation.map(_.map(_.result))
+    val expectedResult = Array(Seq("Teacher: BLAH"))
+
+    actualResult shouldEqual expectedResult
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/util/CleanerHelperTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/util/CleanerHelperTestSpec.scala
new file mode 100644
index 00000000000000..391ada8e06306b
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/cleaners/util/CleanerHelperTestSpec.scala
@@ -0,0 +1,349 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.cleaners.util
+
+import com.johnsnowlabs.nlp.annotators.cleaners.util.CleanerHelper.{
+  cleanBullets,
+  cleanDashes,
+  cleanExtraWhitespace,
+  cleanNonAsciiChars,
+  cleanOrderedBullets,
+  cleanPostfix,
+  cleanPrefix,
+  cleanTrailingPunctuation,
+  removePunctuation,
+  replaceUnicodeCharacters
+}
+import com.johnsnowlabs.tags.FastTest
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.prop.TableDrivenPropertyChecks.forAll
+import org.scalatest.prop.Tables.Table
+
+class CleanerHelperTestSpec extends AnyFlatSpec {
+
+  "cleanTrailingPunctuation" should "remove a trailing symbols" taggedAs FastTest in {
+    val inputs = Seq("Hello.", "Hello,", "Hello:", "Hello;", "Hello,.", ";", "")
+    val expectedOutputs = Seq("Hello", "Hello", "Hello", "Hello", "Hello")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = cleanTrailingPunctuation(input)
+      assert(actual == expected)
+    }
+  }
+
+  it should "not remove punctuation if none exists" taggedAs FastTest in {
+    val inputs = Seq("Hello", "", "Hello, world!")
+    val expectedOutputs = Seq("Hello", "", "Hello, world!")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = cleanTrailingPunctuation(input)
+      assert(actual == expected)
+    }
+  }
+
+  "cleanDashes" should "replace a single dash with a space" taggedAs FastTest in {
+    val inputs = Seq(
+      "Hello-World",
+      "Hello---World",
+      "Hello\u2013World",
+      "Hello-World\u2013Scala",
+      "-Hello World-",
+      "---")
+    val expectedOutputs =
+      Seq("Hello World", "Hello   World", "Hello World", "Hello World Scala", "Hello World", "")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = cleanDashes(input)
+      assert(actual == expected)
+    }
+  }
+
+  it should "handle strings with no dashes without modifying them" taggedAs FastTest in {
+    val inputs = Seq("Hello World", "")
+    val expectedOutputs = Seq("Hello World", "")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = cleanDashes(input)
+      assert(actual == expected)
+    }
+  }
+
+  "cleanExtraWhitespace" should "replace non-breaking spaces with a single space" taggedAs FastTest in {
+    val inputs = Seq(
+      "Hello\u00a0World",
+      "Hello\nWorld",
+      "Hello   World",
+      "Hello\u00a0\n  World",
+      "  Hello World  ",
+      "   ",
+      "RISK\n\nFACTORS",
+      "Item\\xa01A",
+      "  Risk factors ",
+      "Risk   factors ")
+    val expectedOutputs = Seq(
+      "Hello World",
+      "Hello World",
+      "Hello World",
+      "Hello World",
+      "Hello World",
+      "",
+      "RISK FACTORS",
+      "Item 1A",
+      "Risk factors",
+      "Risk factors")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = cleanExtraWhitespace(input)
+      assert(actual == expected)
+    }
+  }
+
+  it should "handle strings with no whitespace without modifying them" taggedAs FastTest in {
+    val inputs = Seq("HelloWorld", "")
+    val expectedOutputs = Seq("HelloWorld", "")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = cleanExtraWhitespace(input)
+      assert(actual == expected)
+    }
+  }
+
+  "clean bullets" should "remove a leading bullet character" taggedAs FastTest in {
+    val inputs = Seq(
+      """● An excellent point!""",
+      """●● An excellent point!""",
+      """● An excellent point! ●●●""",
+      """An excellent point!""",
+      """Morse code! ●●●""")
+
+    val expectedOutputs = Seq(
+      "An excellent point!",
+      """● An excellent point!""",
+      "An excellent point! ●●●",
+      "An excellent point!",
+      "Morse code! ●●●")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = cleanBullets(input)
+      assert(actual == expected)
+    }
+  }
+
+  it should "remove a leading bullet unicode characters" taggedAs FastTest in {
+    val inputs = Seq(
+      "\u2022 Item 1",
+      "\u2022  Item 2",
+      "\u2043Item with dash bullet",
+      "\u2022",
+      "\u2022\u2022 Multiple bullets")
+
+    val expectedOutputs =
+      Seq("Item 1", "Item 2", "Item with dash bullet", "", "\u2022 Multiple bullets")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = cleanBullets(input)
+      assert(actual == expected)
+    }
+  }
+
+  it should "handle empty strings" in {
+    val input = ""
+    val expected = ""
+    assert(cleanBullets(input) == expected)
+  }
+
+  it should "replace unicode characters" in {
+    val inputs = Seq(
+      """\x93A lovely quote!\x94""",
+      """\x91A lovely quote!\x92""",
+      """Our dog's bowl.""")
+    val expectedOutputs = Seq("“A lovely quote!”", "‘A lovely quote!’", "Our dog's bowl.")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      assert(replaceUnicodeCharacters(input) == expected)
+    }
+  }
+
+  it should "clean non-ascii characters" taggedAs FastTest in {
+    val inputs = Seq(
+      """\x88This text contains non-ascii characters!\x88""",
+      """\x93A lovely quote!\x94""",
+      """● An excellent point! ●●●""",
+      """Item\xa01A""",
+      """Our dog's bowl.""",
+      """5 w=E2=80=99s""")
+
+    val expectedOutputs = Seq(
+      "This text contains non-ascii characters!",
+      "A lovely quote!",
+      " An excellent point! ",
+      "Item1A",
+      "Our dog's bowl.",
+      "5 w=E2=80=99s")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      assert(cleanNonAsciiChars(input) == expected)
+    }
+  }
+
+  "cleanOrderedBullets" should "remove ordered bullets" taggedAs FastTest in {
+    val inputs = Seq(
+      "1. Introduction:",
+      "a. Introduction:",
+      "20.3 Morse code ●●●",
+      "5.3.1 Convolutional Networks ",
+      "D.b.C Recurrent Neural Networks",
+      "2.b.1 Recurrent Neural Networks",
+      "eins. Neural Networks",
+      "bb.c Feed Forward Neural Networks",
+      "aaa.ccc Metrics",
+      " version = 3.8",
+      "1 2. 3 4",
+      "1) 2. 3 4",
+      "2,3. Morse code 3. ●●●",
+      "1..2.3 four",
+      "Fig. 2: The relationship",
+      "23 is everywhere")
+
+    val expectedOutputs = Seq(
+      "Introduction:",
+      "Introduction:",
+      "Morse code ●●●",
+      "Convolutional Networks",
+      "Recurrent Neural Networks",
+      "Recurrent Neural Networks",
+      "eins. Neural Networks",
+      "Feed Forward Neural Networks",
+      "aaa.ccc Metrics",
+      " version = 3.8",
+      "1 2. 3 4",
+      "1) 2. 3 4",
+      "2,3. Morse code 3. ●●●",
+      "1..2.3 four",
+      "Fig. 2: The relationship",
+      "23 is everywhere")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      assert(cleanOrderedBullets(input) == expected)
+    }
+  }
+
+  "removePunctuation" should "remove punctuation" taggedAs FastTest in {
+    val inputs = Seq("""“A lovely quote!”""", """‘A lovely quote!’""", """'()[]{};:'\",.?/\\-_""")
+
+    val expectedOutputs = Seq("A lovely quote", "A lovely quote", "")
+
+    inputs.zip(expectedOutputs).foreach { case (input, expected) =>
+      val actual = removePunctuation(input)
+      assert(actual == expected)
+    }
+  }
+
+  "cleanPrefix" should "remove the prefix and any following punctuation/whitespace" taggedAs FastTest in {
+    val testCases = Table(
+      ("description", "text", "pattern", "ignoreCase", "strip", "expected"),
+      (
+        "Standard summary removal",
+        "SUMMARY: A great SUMMARY",
+        "(SUMMARY|DESC)",
+        false,
+        true,
+        "A great SUMMARY"),
+      (
+        "Desc removal with case-sensitive match",
+        "DESC: A great SUMMARY",
+        "(SUMMARY|DESC)",
+        false,
+        true,
+        "A great SUMMARY"),
+      (
+        "Without extra stripping",
+        "SUMMARY: A great SUMMARY",
+        "(SUMMARY|DESC)",
+        false,
+        false,
+        "A great SUMMARY"),
+      (
+        "Removal with case ignored",
+        "desc: A great SUMMARY",
+        "(SUMMARY|DESC)",
+        true,
+        true,
+        "A great SUMMARY"))
+
+    forAll(testCases) { (desc, text, pattern, ignoreCase, strip, expected) =>
+      withClue(s"Failed in case: $desc") {
+        val actual = cleanPrefix(text, pattern, ignoreCase, strip)
+        assert(actual == expected)
+      }
+    }
+  }
+
+  "cleanPostfix" should "remove the postfix and any following punctuation/whitespace" taggedAs FastTest in {
+    val testCases = Table(
+      ("description", "text", "pattern", "ignoreCase", "strip", "expected"),
+      ("Remove trailing 'END' with strip", "The END! END", "(END|STOP)", false, true, "The END!"),
+      (
+        "Remove trailing 'STOP' with strip",
+        "The END! STOP",
+        "(END|STOP)",
+        false,
+        true,
+        "The END!"),
+      (
+        "Keep trailing whitespace when not stripping",
+        "The END! END",
+        "(END|STOP)",
+        false,
+        false,
+        "The END! "),
+      (
+        "Remove trailing 'end' ignoring case",
+        "The END! end",
+        "(END|STOP)",
+        true,
+        true,
+        "The END!"))
+
+    forAll(testCases) { (description, text, pattern, ignoreCase, strip, expected) =>
+      withClue(s"Failed in case: $description") {
+        val actual = cleanPostfix(text, pattern, ignoreCase, strip)
+        assert(actual == expected)
+      }
+    }
+  }
+
+  "bytesStringToAnnotation" should "correctly decode a hex-encoded UTF-8 byte string containing Chinese characters" in {
+    val text = """\xe6\xaf\x8f\xe6\x97\xa5\xe6\x96\xb0\xe9\x97\xbb"""
+    val encoding = "utf-8"
+    val expected = "每日新闻"
+
+    val actual = CleanerHelper.bytesStringToString(text, encoding)
+
+    assert(actual == expected)
+  }
+
+  it should "correctly decode a hex-encoded UTF-8 byte string containing emoticons" taggedAs FastTest in {
+    val text = """Hello ð\x9f\x98\x80"""
+    val encoding = "utf-8"
+    val expected = "Hello 😀"
+
+    val actual = CleanerHelper.bytesStringToString(text, encoding)
+
+    assert(actual == expected)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/JanusForMultiModalTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/JanusForMultiModalTestSpec.scala
new file mode 100644
index 00000000000000..e0735a5d77b0c2
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/JanusForMultiModalTestSpec.scala
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.nlp.{Annotation, AnnotationImage, AssertAnnotations, ImageAssembler}
+import com.johnsnowlabs.tags.{FastTest, SlowTest}
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.lit
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers._
+import java.nio.file.{Files, Paths}
+import java.nio.charset.StandardCharsets
+import java.io.{File, FileOutputStream}
+
+class JanusForMultiModalTestSpec extends AnyFlatSpec {
+
+  def reshape2D(data: Array[Float], rows: Int, cols: Int): Array[Array[Float]] = {
+    data.grouped(cols).toArray.map(_.toArray)
+  }
+
+  def reshape3D(
+      data: Array[Float],
+      depth: Int,
+      rows: Int,
+      cols: Int): Array[Array[Array[Float]]] = {
+    data.grouped(rows * cols).toArray.map { slice =>
+      reshape2D(slice, rows, cols)
+    }
+  }
+
+  def reshape4D(
+      data: Array[Float],
+      batch: Int,
+      depth: Int,
+      rows: Int,
+      cols: Int): Array[Array[Array[Array[Float]]]] = {
+    data.grouped(depth * rows * cols).toArray.map { slice =>
+      reshape3D(slice, depth, rows, cols)
+    }
+  }
+  lazy val model = getJanusForMultiModalPipelineModel
+
+  "JanusForMultiModal" should "answer a question for a given image" taggedAs SlowTest in {
+
+    val testDF = getTestDF
+    val result = model.transform(testDF)
+
+    result.printSchema()
+    val answerAnnotation = AssertAnnotations.getActualResult(result, "answer")
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => println(a.result))
+    }
+
+  }
+  "reshape2D" should "reshape a 1D array into a 2D array" taggedAs SlowTest in {
+    val data = Array(1f, 2f, 3f, 4f, 5f, 6f)
+    val rows = 2
+    val cols = 3
+    val expected = Array(Array(1f, 2f, 3f), Array(4f, 5f, 6f))
+    reshape2D(data, rows, cols) shouldEqual expected
+  }
+
+  "reshape3D" should "reshape a 1D array into a 3D array" taggedAs SlowTest in {
+    val data = Array(1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f, 10f, 11f, 12f)
+    val depth = 2
+    val rows = 2
+    val cols = 3
+    val expected = Array(
+      Array(Array(1f, 2f, 3f), Array(4f, 5f, 6f)),
+      Array(Array(7f, 8f, 9f), Array(10f, 11f, 12f)))
+    reshape3D(data, depth, rows, cols) shouldBe expected
+  }
+
+  it should "generate images when generate image mode is set to true" taggedAs SlowTest in {
+    model.stages.last.asInstanceOf[JanusForMultiModal].setImageGenerateMode(true)
+    model.stages.last.asInstanceOf[JanusForMultiModal].setRandomSeed(123467L)
+    model.stages.last.asInstanceOf[JanusForMultiModal].setNumOfParallelImages(1)
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/images/image1.jpg"
+    val resultAnnotate =
+      lightPipeline.fullAnnotateImage(
+        imagePath,
+        "User: A close-up professional photo of Yorkshire Terrier on beach, extremely detailed, hyper realistic, full hd resolution, with a blurred background. The dog is looking at the camera, with a curious expression, and its fur is shiny and well-groomed. The beach is sandy, with gentle waves lapping at the shore, and a clear blue sky overhead. The lighting is soft and natural, casting a warm glow over the scene. The overall mood is peaceful and serene, capturing a moment of quiet contemplation and connection with nature.\n\nAssistant:")
+//        "User: Create a detailed image of a whimsical forest filled with vibrant, oversized mushrooms, glowing flowers, and towering, twisted trees with bioluminescent vines. The atmosphere is magical, with soft, ethereal light filtering through a misty canopy. Small floating orbs of light hover among the branches, and tiny fairy-like creatures flit through the air. A winding, moss-covered path leads to a mysterious glowing portal hidden within the trees. The scene should feel enchanting, otherworldly, and full of wonder, like a dreamlike fantasy realm.\n\nAssistant:")
+
+    val answerAnnotation = resultAnnotate("answer").head.asInstanceOf[Annotation]
+    println(s"imageName.result: ${answerAnnotation.result}")
+
+    // generated image should be in the metadata as a base64 string with the keys "generated_image_0", "generated_image_1", etc.
+    // find the keys that contain the generated images
+    val generatedImageKeys = answerAnnotation.metadata.keys.filter(_.contains("generated_image"))
+
+    assert(generatedImageKeys.nonEmpty)
+
+    for (key <- generatedImageKeys) {
+      val generatedImage = answerAnnotation.metadata(key).asInstanceOf[String]
+      val decodedImage =
+        java.util.Base64.getDecoder.decode(generatedImage)
+      // save the image to the disk
+      val fos =
+        new FileOutputStream(new File(s"src/test/resources/images/generated_image_$key.jpg"))
+      fos.write(decodedImage)
+      fos.close()
+    }
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/images/image1.jpg"
+    val resultAnnotate =
+      lightPipeline.annotate(
+        imagePath,
+        "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\n\nUser: Describe image in details\n\nAssistant:")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.contains("cat"))
+  }
+
+  it should "work with light pipeline full annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/images/bluetick.jpg"
+    val resultFullAnnotate =
+      lightPipeline.fullAnnotateImage(
+        imagePath,
+        "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\n\nUser: Describe image in details\n\nAssistant:")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    println(s"imageName.result: ${answerAnnotation.result}")
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "fullAnnotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\n\nUser: Describe image in details\n\nAssistant:"
+    val questions = Array(question, "", question)
+
+    val resultFullAnnotate = lightPipeline.fullAnnotateImages(imagesPath, questions)
+
+    resultFullAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { iAnnotation =>
+                val annotation = iAnnotation.asInstanceOf[Annotation]
+                assert(
+                  annotation.result.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+  }
+
+  it should "annotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\n\nUser: Describe image in details\n\nAssistant:"
+    val questions = Array(question, "", question)
+
+    val resultAnnotate = lightPipeline.annotate(imagesPath, questions)
+
+    resultAnnotate.foreach { annotate =>
+      println(s"annotate: $annotate")
+    }
+
+    resultAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { annotation =>
+                assert(
+                  annotation.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+
+  }
+
+  private def getJanusForMultiModalPipelineModel = {
+    val testDF = getTestDF
+
+    val imageAssembler: ImageAssembler = new ImageAssembler()
+      .setInputCol("image")
+      .setOutputCol("image_assembler")
+
+    val loadModel = JanusForMultiModal
+      .pretrained()
+      .setInputCols("image_assembler")
+      .setOutputCol("answer")
+      .setMaxOutputLength(50)
+
+    val newPipeline: Pipeline =
+      new Pipeline().setStages(Array(imageAssembler, loadModel))
+
+    newPipeline.fit(testDF)
+  }
+
+  private def getTestDF: DataFrame = {
+    val imageFolder = "src/test/resources/images/"
+    val imageDF: DataFrame = ResourceHelper.spark.read
+      .format("image")
+      .option("dropInvalid", value = true)
+      .load(imageFolder)
+
+    val testDF: DataFrame = imageDF.withColumn(
+      "text",
+      lit(
+        "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.\n\nUser: Describe image in details\n\nAssistant:"))
+
+    testDF
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModalTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModalTestSpec.scala
new file mode 100644
index 00000000000000..afa1fd86afe500
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/LLAVAForMultiModalTestSpec.scala
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.nlp.{Annotation, AssertAnnotations, ImageAssembler}
+import com.johnsnowlabs.tags.{FastTest, SlowTest}
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.lit
+import org.scalatest.flatspec.AnyFlatSpec
+
+class LLAVAForMultiModalTestSpec extends AnyFlatSpec {
+
+  lazy val model = getLLAVAForMultiModalPipelineModel
+
+  "LLAVAForMultiModal" should "answer a question for a given image" taggedAs SlowTest in {
+
+    val testDF = getTestDF
+    val result = model.transform(testDF)
+
+    val answerAnnotation = AssertAnnotations.getActualResult(result, "answer")
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => println(a.result))
+    }
+
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/image/egyptian_cat.jpeg"
+    val resultAnnotate =
+      lightPipeline.annotate(
+        imagePath,
+        "USER:  \n <|image|> \n What is unusual on this picture? \n ASSISTANT:\n")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.contains("cat"))
+  }
+
+  it should "work with light pipeline full annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/image/bluetick.jpg"
+    val resultFullAnnotate =
+      lightPipeline.fullAnnotateImage(
+        imagePath,
+        "USER:  \n <|image|> \n What's this picture about? \n ASSISTANT:\n")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    println(s"imageName.result: ${answerAnnotation.result}")
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "fullAnnotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "USER:  \n <|image|> \n What's this picture about? \n ASSISTANT:\n"
+    val questions = Array(question, "", question)
+
+    val resultFullAnnotate = lightPipeline.fullAnnotateImages(imagesPath, questions)
+
+    resultFullAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { iAnnotation =>
+                val annotation = iAnnotation.asInstanceOf[Annotation]
+                assert(
+                  annotation.result.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+  }
+
+  it should "annotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "USER:  \n <|image|> \n What's this picture about? \n ASSISTANT:\n"
+    val questions = Array(question, "", question)
+
+    val resultAnnotate = lightPipeline.annotate(imagesPath, questions)
+
+    resultAnnotate.foreach { annotate =>
+      println(s"annotate: $annotate")
+    }
+
+    resultAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { annotation =>
+                assert(
+                  annotation.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+
+  }
+
+  private def getLLAVAForMultiModalPipelineModel = {
+    val testDF = getTestDF
+
+    val imageAssembler: ImageAssembler = new ImageAssembler()
+      .setInputCol("image")
+      .setOutputCol("image_assembler")
+
+    val loadModel = LLAVAForMultiModal
+      .pretrained()
+      .setInputCols("image_assembler")
+      .setOutputCol("answer")
+      .setMaxOutputLength(50)
+
+    val newPipeline: Pipeline =
+      new Pipeline().setStages(Array(imageAssembler, loadModel))
+
+    val pipelineModel = newPipeline.fit(testDF)
+
+    pipelineModel
+      .transform(testDF)
+      .show(truncate = false)
+
+    pipelineModel
+      .transform(testDF)
+      .show(truncate = false)
+
+    pipelineModel.stages.last
+      .asInstanceOf[LLAVAForMultiModal]
+      .write
+      .overwrite()
+      .save("/tmp/llava-7b-4bit-model")
+
+    val loadedLLAMA3 = LLAVAForMultiModal.load("/tmp/llava-7b-4bit-model")
+
+    val loadedPipeline = new Pipeline().setStages(Array(imageAssembler, loadedLLAMA3))
+
+    loadedPipeline
+      .fit(testDF)
+      .transform(testDF)
+      .show(truncate = false)
+
+    pipelineModel
+  }
+
+  private def getTestDF: DataFrame = {
+    val imageFolder = "src/test/resources/image/"
+    val imageDF: DataFrame = ResourceHelper.spark.read
+      .format("image")
+      .option("dropInvalid", value = true)
+      .load(imageFolder)
+
+    val testDF: DataFrame = imageDF.withColumn(
+      "text",
+      lit("USER:  \n <|image|> \n What's this picture about? \n ASSISTANT:\n"))
+
+    testDF
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodalTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodalTestSpec.scala
new file mode 100644
index 00000000000000..30ec2f838c57ff
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/MLLamaForMultimodalTestSpec.scala
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.nlp.{Annotation, AssertAnnotations, ImageAssembler}
+import com.johnsnowlabs.tags.{FastTest, SlowTest}
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.lit
+import org.scalatest.flatspec.AnyFlatSpec
+
+class MLLamaForMultimodalTestSpec extends AnyFlatSpec {
+
+  lazy val model = getMLLamaForMultiModalPipelineModel
+
+  "MLLamaForMultiModal" should "answer a question for a given image" taggedAs SlowTest in {
+
+    val testDF = getTestDF
+    val result = model.transform(testDF)
+
+    val answerAnnotation = AssertAnnotations.getActualResult(result, "answer")
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => println(a.result))
+    }
+
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/images/image1.jpg"
+    val resultAnnotate =
+      lightPipeline.annotate(
+        imagePath,
+        "<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.contains("cat"))
+  }
+
+  it should "work with light pipeline full annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/images/bluetick.jpg"
+    val resultFullAnnotate =
+      lightPipeline.fullAnnotateImage(
+        imagePath,
+        "<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    println(s"imageName.result: ${answerAnnotation.result}")
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "fullAnnotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
+    val questions = Array(question, "", question)
+
+    val resultFullAnnotate = lightPipeline.fullAnnotateImages(imagesPath, questions)
+
+    resultFullAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { iAnnotation =>
+                val annotation = iAnnotation.asInstanceOf[Annotation]
+                assert(
+                  annotation.result.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+  }
+
+  it should "annotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
+    val questions = Array(question, "", question)
+
+    val resultAnnotate = lightPipeline.annotate(imagesPath, questions)
+
+    resultAnnotate.foreach { annotate =>
+      println(s"annotate: $annotate")
+    }
+
+    resultAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { annotation =>
+                assert(
+                  annotation.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+
+  }
+
+  private def getMLLamaForMultiModalPipelineModel = {
+    val testDF = getTestDF
+
+    val imageAssembler: ImageAssembler = new ImageAssembler()
+      .setInputCol("image")
+      .setOutputCol("image_assembler")
+
+    val loadModel = MLLamaForMultimodal
+      .pretrained()
+      .setInputCols("image_assembler")
+      .setOutputCol("answer")
+      .setMaxOutputLength(50)
+
+    val newPipeline: Pipeline =
+      new Pipeline().setStages(Array(imageAssembler, loadModel))
+
+    newPipeline.fit(testDF)
+  }
+
+  private def getTestDF: DataFrame = {
+    val imageFolder = "src/test/resources/images/"
+    val imageDF: DataFrame = ResourceHelper.spark.read
+      .format("image")
+      .option("dropInvalid", value = true)
+      .load(imageFolder)
+
+    val testDF: DataFrame = imageDF.withColumn(
+      "text",
+      lit(
+        "<|begin_of_text|><|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n<|image|>What is unusual on this image?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"))
+
+    testDF
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3VisionTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3VisionTestSpec.scala
new file mode 100644
index 00000000000000..6f3e9b56b5f427
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Phi3VisionTestSpec.scala
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.nlp.{Annotation, AssertAnnotations, ImageAssembler}
+import com.johnsnowlabs.tags.{FastTest, SlowTest}
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.lit
+import org.scalatest.flatspec.AnyFlatSpec
+
+class Phi3VisionTestSpec extends AnyFlatSpec {
+
+  lazy val model = getPhi3VisionPipelineModel
+
+  "Phi3Vision" should "answer a question for a given image" taggedAs SlowTest in {
+
+    val testDF = getTestDF
+    val result = model.transform(testDF)
+
+    val answerAnnotation = AssertAnnotations.getActualResult(result, "answer")
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => println(a.result))
+    }
+
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/image/egyptian_cat.jpeg"
+    val resultAnnotate =
+      lightPipeline.annotate(
+        imagePath,
+        "<|user|> \n <|image_1|> \n What is unusual on this picture? <|end|>\n <|assistant|>\n")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.contains("cat"))
+  }
+
+  it should "work with light pipeline full annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/image/bluetick.jpg"
+    val resultFullAnnotate =
+      lightPipeline.fullAnnotateImage(
+        imagePath,
+        "<|user|> \n <|image_1|> \n What's this picture about? <|end|>\n <|assistant|>\n")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    println(s"imageName.result: ${answerAnnotation.result}")
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "fullAnnotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "<|user|> \n <|image_1|> \n What's this picture about? <|end|>\n <|assistant|>\n"
+    val questions = Array(question, "", question)
+
+    val resultFullAnnotate = lightPipeline.fullAnnotateImages(imagesPath, questions)
+
+    resultFullAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { iAnnotation =>
+                val annotation = iAnnotation.asInstanceOf[Annotation]
+                assert(
+                  annotation.result.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+  }
+
+  it should "annotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "<|user|> \n <|image_1|> \n What's this picture about? <|end|>\n <|assistant|>\n"
+    val questions = Array(question, "", question)
+
+    val resultAnnotate = lightPipeline.annotate(imagesPath, questions)
+
+    resultAnnotate.foreach { annotate =>
+      println(s"annotate: $annotate")
+    }
+
+    resultAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { annotation =>
+                assert(
+                  annotation.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+
+  }
+
+  private def getPhi3VisionPipelineModel = {
+    val testDF = getTestDF
+
+    val imageAssembler: ImageAssembler = new ImageAssembler()
+      .setInputCol("image")
+      .setOutputCol("image_assembler")
+
+    val loadModel = Phi3Vision
+      .pretrained()
+      .setInputCols("image_assembler")
+      .setOutputCol("answer")
+      .setMaxOutputLength(50)
+
+    val newPipeline: Pipeline =
+      new Pipeline().setStages(Array(imageAssembler, loadModel))
+
+    newPipeline.fit(testDF)
+  }
+
+  private def getTestDF: DataFrame = {
+    val imageFolder = "src/test/resources/image/"
+    val imageDF: DataFrame = ResourceHelper.spark.read
+      .format("image")
+      .option("dropInvalid", value = true)
+      .load(imageFolder)
+
+    val testDF: DataFrame = imageDF.withColumn(
+      "text",
+      lit("<|user|> \n <|image_1|> \n What's this picture about? <|end|>\n <|assistant|>\n"))
+
+    testDF
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformerTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformerTestSpec.scala
new file mode 100644
index 00000000000000..9c7128239d2569
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/cv/Qwen2VLTransformerTestSpec.scala
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.cv
+
+import com.johnsnowlabs.nlp.base.LightPipeline
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.nlp.{Annotation, AssertAnnotations, ImageAssembler}
+import com.johnsnowlabs.tags.{FastTest, SlowTest}
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.lit
+import org.scalatest.flatspec.AnyFlatSpec
+
+class Qwen2VLTransformerTestSpec extends AnyFlatSpec {
+
+  lazy val model = getQwen2VLTransformerPipelineModel
+
+  "Qwen2VLTransformer" should "answer a question for a given image" taggedAs SlowTest in {
+
+    val testDF = getTestDF
+    val result = model.transform(testDF)
+
+    val answerAnnotation = AssertAnnotations.getActualResult(result, "answer")
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => assert(a.result.nonEmpty))
+    }
+
+    answerAnnotation.foreach { annotation =>
+      annotation.foreach(a => println(a.result))
+    }
+
+  }
+
+  it should "work with light pipeline annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/image/egyptian_cat.jpeg"
+    val resultAnnotate =
+      lightPipeline.annotate(
+        imagePath,
+        "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n")
+    println(s"resultAnnotate: $resultAnnotate")
+
+    assert(resultAnnotate("answer").head.contains("cat"))
+  }
+
+  it should "work with light pipeline full annotate" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagePath = "src/test/resources/image/bluetick.jpg"
+    val resultFullAnnotate =
+      lightPipeline.fullAnnotateImage(
+        imagePath,
+        "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n")
+
+    val answerAnnotation = resultFullAnnotate("answer").head.asInstanceOf[Annotation]
+
+    println(s"imageName.result: ${answerAnnotation.result}")
+    assert(answerAnnotation.result.nonEmpty)
+  }
+
+  it should "fullAnnotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n"
+    val questions = Array(question, "", question)
+
+    val resultFullAnnotate = lightPipeline.fullAnnotateImages(imagesPath, questions)
+
+    resultFullAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { iAnnotation =>
+                val annotation = iAnnotation.asInstanceOf[Annotation]
+                assert(
+                  annotation.result.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+  }
+
+  it should "annotate with empty Map when a text is empty" taggedAs SlowTest in {
+    val lightPipeline = new LightPipeline(model)
+    val imagesPath = Array(
+      "src/test/resources/image/bluetick.jpg",
+      "src/test/resources/image/chihuahua.jpg",
+      "src/test/resources/image/egyptian_cat.jpeg")
+    val question =
+      "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n"
+    val questions = Array(question, "", question)
+
+    val resultAnnotate = lightPipeline.annotate(imagesPath, questions)
+
+    resultAnnotate.foreach { annotate =>
+      println(s"annotate: $annotate")
+    }
+
+    resultAnnotate.zip(imagesPath).foreach { case (annotateMap, imagePath) =>
+      imagePath match {
+        case "src/test/resources/image/chihuahua.jpg" =>
+          // For the chihuahua image, the annotateMap should be empty because the question is empty
+          assert(
+            annotateMap.nonEmpty,
+            s"Expected empty map for image: $imagePath, but got: $annotateMap")
+
+        case _ =>
+          assert(annotateMap.nonEmpty, s"Expected non-empty map for image: $imagePath")
+
+          annotateMap.get("answer") match {
+            case Some(annotations) =>
+              annotations.foreach { annotation =>
+                assert(
+                  annotation.nonEmpty,
+                  s"Expected non-empty result for image: $imagePath, but got empty result")
+              }
+            case None =>
+              fail(s"'answer' key not found in annotateMap for image: $imagePath")
+          }
+      }
+    }
+
+  }
+
+  private def getQwen2VLTransformerPipelineModel = {
+    val testDF = getTestDF
+
+    val imageAssembler: ImageAssembler = new ImageAssembler()
+      .setInputCol("image")
+      .setOutputCol("image_assembler")
+
+    val loadModel = Qwen2VLTransformer
+      .pretrained()
+      .setInputCols("image_assembler")
+      .setOutputCol("answer")
+      .setMaxOutputLength(200)
+
+    val newPipeline: Pipeline =
+      new Pipeline().setStages(Array(imageAssembler, loadModel))
+
+    newPipeline.fit(testDF)
+  }
+
+  private def getTestDF: DataFrame = {
+    val imageFolder = "src/test/resources/image/"
+    val imageDF: DataFrame = ResourceHelper.spark.read
+      .format("image")
+      .option("dropInvalid", value = true)
+      .load(imageFolder)
+
+    val testDF: DataFrame = imageDF.withColumn(
+      "text",
+      lit(
+        "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>Describe this image.<|im_end|>\n<|im_start|>assistant\n"))
+
+    testDF
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFModelTest.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFModelTest.scala
index f755b76dfa2e72..01cb289903550d 100644
--- a/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFModelTest.scala
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFModelTest.scala
@@ -181,4 +181,28 @@ class AutoGGUFModelTest extends AnyFlatSpec {
     val metadataMap = model.getMetadataMap
     assert(metadataMap.nonEmpty)
   }
+
+  it should "return error messages when completions can't be produced" taggedAs SlowTest in {
+    val model = AutoGGUFModel
+      .pretrained()
+      .setInputCols("document")
+      .setOutputCol("completions")
+      .setGrammar("root ::= (") // Invalid grammar
+
+    val pipeline =
+      new Pipeline().setStages(Array(documentAssembler, model))
+    val result = pipeline.fit(data).transform(data)
+
+    val collected = Annotation
+      .collect(result, "completions")
+
+    assert(collected.length == data.count().toInt, "Should return the same number of rows")
+    collected
+      .foreach(annotations => {
+        assert(annotations.head.result.isEmpty, "Completions should be empty")
+        assert(
+          annotations.head.metadata.contains("llamacpp_exception"),
+          "llamacpp_exception should be present")
+      })
+  }
 }
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTestSpec.scala
new file mode 100644
index 00000000000000..961e2fc49b4488
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTestSpec.scala
@@ -0,0 +1,121 @@
+package com.johnsnowlabs.nlp.annotators.seq2seq
+
+import com.johnsnowlabs.nlp.base.DocumentAssembler
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.nlp.{Annotation, AnnotationImage, ImageAssembler}
+import com.johnsnowlabs.tags.SlowTest
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.functions.lit
+import org.apache.spark.sql.{DataFrame, Row}
+import org.scalatest.flatspec.AnyFlatSpec
+
+import scala.collection.mutable
+
+class AutoGGUFVisionModelTestSpec extends AnyFlatSpec {
+
+  behavior of "AutoGGUFVisionModel"
+
+  lazy val documentAssembler = new DocumentAssembler()
+    .setInputCol("caption")
+    .setOutputCol("caption_document")
+
+  lazy val imageAssembler = new ImageAssembler()
+    .setInputCol("image")
+    .setOutputCol("image_assembler")
+
+  lazy val imagesPath = "src/test/resources/image/"
+  lazy val data: DataFrame = ImageAssembler
+    .loadImagesAsBytes(ResourceHelper.spark, imagesPath)
+    .withColumn("caption", lit("Caption this image.")) // Add a caption to each image.
+
+  lazy val expectedWords: Map[String, String] = Map(
+    "bluetick.jpg" -> "dog",
+    "chihuahua.jpg" -> "dog",
+    "egyptian_cat.jpeg" -> "cat",
+    "hen.JPEG" -> "chick",
+    "hippopotamus.JPEG" -> "hippo",
+    "junco.JPEG" -> "bird",
+    "ostrich.JPEG" -> "ostrich",
+    "ox.JPEG" -> "bull",
+    "palace.JPEG" -> "room",
+    "tractor.JPEG" -> "tractor")
+
+  lazy val nPredict = 40
+  lazy val model = AutoGGUFVisionModel
+    .pretrained()
+    .setInputCols("caption_document", "image_assembler")
+    .setOutputCol("completions")
+    .setChatTemplate("vicuna") // llava uses vicuna as default
+    .setBatchSize(2)
+    .setNGpuLayers(99)
+    .setNCtx(4096)
+    .setMinKeep(0)
+    .setMinP(0.05f)
+    .setNPredict(nPredict)
+    .setNProbs(0)
+    .setPenalizeNl(false)
+    .setRepeatLastN(256)
+    .setRepeatPenalty(1.18f)
+    .setStopStrings(Array("", "Llama:", "User:"))
+    .setTemperature(0.05f)
+    .setTfsZ(1)
+    .setTypicalP(1)
+    .setTopK(40)
+    .setTopP(0.95f)
+
+  lazy val pipeline = new Pipeline().setStages(Array(documentAssembler, imageAssembler, model))
+
+  def checkBinaryContents(): Unit = {
+    val imageData = data.select("image.data").limit(1).collect()(0).getAs[Array[Byte]](0)
+    val byteContent = data.select("content").limit(1).collect()(0).getAs[Array[Byte]](0)
+
+    assert(imageData.length == byteContent.length)
+    assert(imageData sameElements byteContent)
+  }
+
+  it should "replace image data with bytes" taggedAs SlowTest in {
+    checkBinaryContents()
+  }
+
+  it should "caption the images correctly" taggedAs SlowTest in {
+    import java.lang.management.ManagementFactory
+    val pid = ManagementFactory.getRuntimeMXBean.getName.split("@")(0)
+    println(s"Current PID: $pid")
+
+    val result = pipeline.fit(data).transform(data.repartition(1))
+
+    val imageWithCompletions: Array[(AnnotationImage, Annotation)] =
+      result.select("image_assembler", "completions").collect().map { row =>
+        val image = AnnotationImage(row.getAs[mutable.WrappedArray[Row]](0).head)
+        val annotation = Annotation(row.getAs[mutable.WrappedArray[Row]](1).head)
+        (image, annotation)
+      }
+
+    imageWithCompletions.foreach { case (image, completion) =>
+      val fileName = image.origin.split("/").last
+      val expectedWord = expectedWords(fileName)
+      val wordFound = completion.result.contains(expectedWord)
+      assert(wordFound, s"Expected word $expectedWord not found in $result")
+    }
+  }
+
+  it should "be serializable" taggedAs SlowTest in {
+    val pipelineModel = pipeline.fit(data)
+    val savePath = "./tmp_autogguf_vision_model"
+    pipelineModel.stages.last
+      .asInstanceOf[AutoGGUFVisionModel]
+      .write
+      .overwrite()
+      .save(savePath)
+
+    val loadedModel = AutoGGUFVisionModel.load(savePath)
+    val newPipeline: Pipeline =
+      new Pipeline().setStages(Array(documentAssembler, imageAssembler, loadedModel))
+
+    newPipeline
+      .fit(data)
+      .transform(data.limit(1))
+      .select("completions")
+      .show(truncate = false)
+  }
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTestSpec.scala
new file mode 100644
index 00000000000000..d3df41d1b31ef4
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/CoHereTestSpec.scala
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2017-2023 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.seq2seq
+
+import com.johnsnowlabs.nlp.base.DocumentAssembler
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.tags.{SlowTest, FastTest}
+import org.apache.spark.ml.Pipeline
+import org.scalatest.flatspec.AnyFlatSpec
+
+class CoHereTestSpec extends AnyFlatSpec {
+
+  "CoHere" should "should handle temperature=0 correctly and not crash when predicting more than 1 element with doSample=True" taggedAs SlowTest in {
+    // Even tough the Paper states temperature in interval [0,1), using temperature=0 will result in division by 0 error.
+    // Also DoSample=True may result in infinities being generated and distFiltered.length==0 which results in exception if we don't return 0 instead internally.
+    val testData = ResourceHelper.spark
+      .createDataFrame(
+        Seq((
+          1,
+          """<|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, how are you?<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>
+            """.stripMargin)))
+      .toDF("id", "text")
+      .repartition(1)
+    val documentAssembler = new DocumentAssembler()
+      .setInputCol("text")
+      .setOutputCol("documents")
+
+    val CoHere = CoHereTransformer
+      .pretrained()
+      .setInputCols(Array("documents"))
+      .setDoSample(false)
+      .setMaxOutputLength(50)
+      .setOutputCol("generation")
+      .setBeamSize(1)
+      .setStopTokenIds(Array(255001))
+      .setTemperature(0.6)
+      .setTopP(0.9)
+      .setTopK(-1)
+    val pipeline = new Pipeline()
+      .setStages(Array(documentAssembler, CoHere))
+
+    val pipelineModel = pipeline.fit(testData)
+
+    pipelineModel
+      .transform(testData)
+      .show(truncate = false)
+
+    pipelineModel
+      .transform(testData)
+      .show(truncate = false)
+
+    pipelineModel.stages.last
+      .asInstanceOf[CoHereTransformer]
+      .write
+      .overwrite()
+      .save("/tmp/CoHere-7b-4bit-model")
+
+    val loadedCoHere = CoHereTransformer.load("/tmp/CoHere-7b-4bit-model")
+
+    val loadedPipeline = new Pipeline().setStages(Array(documentAssembler, loadedCoHere))
+
+    loadedPipeline
+      .fit(testData)
+      .transform(testData)
+      .show(truncate = false)
+
+  }
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/OLMoTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/OLMoTestSpec.scala
new file mode 100644
index 00000000000000..55cfaffa6f2474
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/OLMoTestSpec.scala
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2017-2023 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp.annotators.seq2seq
+
+import com.johnsnowlabs.nlp.base.DocumentAssembler
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.tags.{FastTest, SlowTest}
+import org.apache.spark.ml.Pipeline
+import org.scalatest.flatspec.AnyFlatSpec
+
+class OLMoTestSpec extends AnyFlatSpec {
+
+  "olmo" should "should handle temperature=0 correctly and not crash when predicting more than 1 element with doSample=True" taggedAs SlowTest in {
+    // Even tough the Paper states temperature in interval [0,1), using temperature=0 will result in division by 0 error.
+    // Also DoSample=True may result in infinities being generated and distFiltered.length==0 which results in exception if we don't return 0 instead internally.
+    val testData = ResourceHelper.spark
+      .createDataFrame(Seq((1, "My name is Leonardo.")))
+      .toDF("id", "text")
+      .repartition(1)
+    val documentAssembler = new DocumentAssembler()
+      .setInputCol("text")
+      .setOutputCol("documents")
+
+    val bart = OLMoTransformer
+      .pretrained()
+      .setInputCols(Array("documents"))
+      .setDoSample(false)
+      .setMaxOutputLength(100)
+      .setOutputCol("generation")
+      .setBeamSize(1)
+
+    val pipeline = new Pipeline()
+      .setStages(Array(documentAssembler, bart))
+
+    val pipelineModel = pipeline.fit(testData)
+
+    pipelineModel
+      .transform(testData)
+      .show(truncate = false)
+
+    pipelineModel
+      .transform(testData)
+      .show(truncate = false)
+
+    pipelineModel.stages.last
+      .asInstanceOf[OLMoTransformer]
+      .write
+      .overwrite()
+      .save("/tmp/olmo-1b-4bit-model")
+
+    val loadedLLAMA3 = OLMoTransformer.load("/tmp/olmo-1b-4bit-model")
+
+    val loadedPipeline = new Pipeline().setStages(Array(documentAssembler, loadedLLAMA3))
+
+    loadedPipeline
+      .fit(testData)
+      .transform(testData)
+      .show(truncate = false)
+
+  }
+}
diff --git a/src/test/scala/com/johnsnowlabs/nlp/embeddings/AutoGGUFEmbeddingsTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/embeddings/AutoGGUFEmbeddingsTestSpec.scala
index b7c4544bdbd87f..f9a90635d6ac2d 100644
--- a/src/test/scala/com/johnsnowlabs/nlp/embeddings/AutoGGUFEmbeddingsTestSpec.scala
+++ b/src/test/scala/com/johnsnowlabs/nlp/embeddings/AutoGGUFEmbeddingsTestSpec.scala
@@ -7,6 +7,9 @@ import com.johnsnowlabs.tags.SlowTest
 import org.apache.spark.ml.Pipeline
 import org.scalatest.flatspec.AnyFlatSpec
 
+import scala.io.Source
+import scala.util.Using
+
 class AutoGGUFEmbeddingsTestSpec extends AnyFlatSpec {
   import ResourceHelper.spark.implicits._
 
@@ -23,6 +26,13 @@ class AutoGGUFEmbeddingsTestSpec extends AnyFlatSpec {
     "The sun is " //
   ).toDF("text").repartition(1)
 
+  lazy val longDataCopies = 16
+  lazy val longData = {
+    val text = "All work and no play makes Jack a dull boy" * 100
+    Seq.fill(longDataCopies)(text).toDF("text").repartition(4)
+  }
+
+  println(ResourceHelper.spark.version)
   // nomic-embed-text-v1.5.Q8_0.gguf
   def model(poolingType: String): AutoGGUFEmbeddings = AutoGGUFEmbeddings
     .pretrained()
@@ -30,7 +40,7 @@ class AutoGGUFEmbeddingsTestSpec extends AnyFlatSpec {
     .setOutputCol("embeddings")
     .setBatchSize(4)
     .setPoolingType(poolingType)
-
+    .setNCtx(8192)
   def pipeline(embedModel: AutoGGUFEmbeddings = model("MEAN")) =
     new Pipeline().setStages(Array(documentAssembler, embedModel))
 
@@ -83,4 +93,35 @@ class AutoGGUFEmbeddingsTestSpec extends AnyFlatSpec {
       .select("embeddings.embeddings")
       .show(truncate = false)
   }
+
+  it should "return error messages when embeddings can't be created" taggedAs SlowTest in {
+    val result = pipeline().fit(longData).transform(longData)
+    val collected = Annotation.collect(result, "embeddings")
+    assert(collected.length == longDataCopies)
+
+    collected.foreach { annotations =>
+      assert(
+        annotations.head.metadata.contains("llamacpp_exception"),
+        "llamacpp_exception should be present")
+    }
+
+  }
+
+  it should "embed long text" taggedAs SlowTest in {
+    val result = pipeline(
+      model("MEAN")
+        .setNUbatch(2048)
+        .setNBatch(2048)).fit(longData).transform(longData)
+    val collected = Annotation.collect(result, "embeddings")
+    assert(collected.length == longDataCopies, "Should return the same number of rows")
+
+    collected.foreach { annotations =>
+      val embeddings = annotations.head.embeddings
+      assert(embeddings != null, "embeddings should not be null")
+      assert(
+        embeddings.sum > 0.0,
+        "embeddings should not be zero. Was there an error on llama.cpp side?")
+    }
+  }
+
 }
diff --git a/src/test/scala/com/johnsnowlabs/partition/PartitionChunkerTest.scala b/src/test/scala/com/johnsnowlabs/partition/PartitionChunkerTest.scala
new file mode 100644
index 00000000000000..5a9cf8d4ed80dd
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/partition/PartitionChunkerTest.scala
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.partition
+
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.tags.FastTest
+import org.apache.spark.sql.functions.explode
+import org.scalatest.flatspec.AnyFlatSpec
+
+class PartitionChunkerTest extends AnyFlatSpec {
+
+  import ResourceHelper.spark.implicits._
+  val txtDirectory = "src/test/resources/reader/txt"
+
+  "Partition" should "perform basic chunk text" taggedAs FastTest in {
+      val partitionOptions = Map("contentType" -> "text/plain", "chunkingStrategy" -> "basic")
+      val textDf = Partition(partitionOptions).partition(s"$txtDirectory/long-text.txt")
+      textDf.show(truncate = false)
+      textDf.printSchema()
+
+      val partitionDf = textDf.select(explode($"txt.content"))
+      partitionDf.show(truncate = false)
+
+      val chunkDf = textDf.select(explode($"chunks.content"))
+      chunkDf.show(truncate = false)
+//      assert(!textDf.select(col("txt").getItem(0)).isEmpty)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/partition/PartitionTest.scala b/src/test/scala/com/johnsnowlabs/partition/PartitionTest.scala
new file mode 100644
index 00000000000000..9937b95f59e512
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/partition/PartitionTest.scala
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.partition
+
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.reader.{ElementType, HTMLElement}
+import com.johnsnowlabs.tags.FastTest
+import org.apache.spark.sql.functions.col
+import org.scalatest.flatspec.AnyFlatSpec
+
+import scala.collection.mutable
+
+class PartitionTest extends AnyFlatSpec {
+
+  val txtDirectory = "src/test/resources/reader/txt"
+  val wordDirectory = "src/test/resources/reader/doc"
+  val excelDirectory = "src/test/resources/reader/xls"
+  val powerPointDirectory = "src/test/resources/reader/ppt"
+  val emailDirectory = "src/test/resources/reader/email"
+  val htmlDirectory = "src/test/resources/reader/html"
+  val pdfDirectory = "src/test/resources/reader/pdf"
+
+  "Partition" should "work with text content_type" taggedAs FastTest in {
+    val textDf = Partition(Map("content_type" -> "text/plain")).partition(txtDirectory)
+    textDf.show()
+
+    assert(!textDf.select(col("txt").getItem(0)).isEmpty)
+  }
+
+  it should "identify text file" taggedAs FastTest in {
+    val textDf = Partition().partition(s"$txtDirectory/simple-text.txt")
+    textDf.show()
+
+    assert(!textDf.select(col("txt").getItem(0)).isEmpty)
+  }
+
+  it should "work with word content_type" taggedAs FastTest in {
+    val wordDf = Partition(Map("content_type" -> "application/msword")).partition(wordDirectory)
+    wordDf.show()
+
+    assert(!wordDf.select(col("doc").getItem(0)).isEmpty)
+  }
+
+  it should "identify word file" taggedAs FastTest in {
+    val wordDf = Partition().partition(s"$wordDirectory/fake_table.docx")
+    wordDf.show()
+
+    assert(!wordDf.select(col("doc").getItem(0)).isEmpty)
+  }
+
+  it should "work with excel content_type" taggedAs FastTest in {
+    val excelDf =
+      Partition(Map("content_type" -> "application/vnd.ms-excel")).partition(excelDirectory)
+    excelDf.show()
+
+    assert(!excelDf.select(col("xls").getItem(0)).isEmpty)
+  }
+
+  it should "identify excel file" taggedAs FastTest in {
+    val excelDf = Partition().partition(s"$excelDirectory/vodafone.xlsx")
+    excelDf.show()
+
+    assert(!excelDf.select(col("xls").getItem(0)).isEmpty)
+  }
+
+  it should "work with email content_type" taggedAs FastTest in {
+    val emailDf = Partition(Map("content_type" -> "message/rfc822")).partition(emailDirectory)
+    emailDf.show()
+
+    assert(!emailDf.select(col("email").getItem(0)).isEmpty)
+  }
+
+  it should "wok with email file" taggedAs FastTest in {
+    val emailDf = Partition().partition(s"$emailDirectory/test-several-attachments.eml")
+    emailDf.show()
+
+    assert(!emailDf.select(col("email").getItem(0)).isEmpty)
+  }
+
+  it should "work with powerpoint content_type" taggedAs FastTest in {
+    val pptDf = Partition(Map("content_type" -> "application/vnd.ms-powerpoint"))
+      .partition(powerPointDirectory)
+    pptDf.show()
+
+    assert(!pptDf.select(col("ppt").getItem(0)).isEmpty)
+  }
+
+  it should "identify powerpoint file" taggedAs FastTest in {
+    val pptDf = Partition().partition(s"$powerPointDirectory/fake-power-point.pptx")
+    pptDf.show()
+
+    assert(!pptDf.select(col("ppt").getItem(0)).isEmpty)
+  }
+
+  it should "work with html content_type" taggedAs FastTest in {
+    val htmlDf = Partition(Map("content_type" -> "text/html")).partition(htmlDirectory)
+    htmlDf.show()
+
+    assert(!htmlDf.select(col("html").getItem(0)).isEmpty)
+  }
+
+  it should "identify html file" taggedAs FastTest in {
+    val htmlDf = Partition().partition(s"$htmlDirectory/fake-html.html")
+    htmlDf.show()
+
+    assert(!htmlDf.select(col("html").getItem(0)).isEmpty)
+  }
+
+  it should "work with an URL" taggedAs FastTest in {
+    val htmlDf = Partition().partition("https://www.wikipedia.org")
+    htmlDf.show()
+
+    assert(!htmlDf.select(col("html").getItem(0)).isEmpty)
+  }
+
+  it should "work with a set of URLS" taggedAs FastTest in {
+    val htmlDf =
+      Partition().partitionUrls(Array("https://www.wikipedia.org", "https://example.com/"))
+    htmlDf.show()
+
+    assert(!htmlDf.select(col("html").getItem(0)).isEmpty)
+  }
+
+  it should "identify a PDF file" taggedAs FastTest in {
+    val pdfDf = Partition().partition(s"$pdfDirectory/text_3_pages.pdf")
+    pdfDf.show()
+
+    assert(!pdfDf.select(col("text")).isEmpty)
+  }
+
+  it should "work with PDF content_type" taggedAs FastTest in {
+    val pdfDf = Partition(Map("content_type" -> "application/pdf")).partition(pdfDirectory)
+    pdfDf.show()
+
+    assert(!pdfDf.select(col("text")).isEmpty)
+  }
+
+  it should "work with text in memory" taggedAs FastTest in {
+    import ResourceHelper.spark.implicits._
+    val content =
+      """
+        |The big brown fox
+        |was walking down the lane.
+        |
+        |At the end of the lane,
+        |the fox met a bear.
+        |""".stripMargin
+
+    val textDf = Partition(Map("groupBrokenParagraphs" -> "true")).partitionText(content)
+    textDf.show()
+
+    val elements: Seq[HTMLElement] = textDf
+      .select("txt")
+      .as[Seq[HTMLElement]]
+      .collect()
+      .head
+
+    val expectedElements = Seq(
+      HTMLElement(
+        ElementType.NARRATIVE_TEXT,
+        "The big brown fox was walking down the lane.",
+        mutable.Map("paragraph" -> "0")),
+      HTMLElement(
+        ElementType.NARRATIVE_TEXT,
+        "At the end of the lane, the fox met a bear.",
+        mutable.Map("paragraph" -> "0")))
+
+    assert(elements == expectedElements)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/partition/PartitionTransformerTest.scala b/src/test/scala/com/johnsnowlabs/partition/PartitionTransformerTest.scala
new file mode 100644
index 00000000000000..39ac1d06b3662d
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/partition/PartitionTransformerTest.scala
@@ -0,0 +1,75 @@
+package com.johnsnowlabs.partition
+
+import com.johnsnowlabs.nlp.annotator.MarianTransformer
+import com.johnsnowlabs.nlp.annotators.SparkSessionTest
+import com.johnsnowlabs.nlp.annotators.cleaners.Cleaner
+import org.apache.spark.ml.Pipeline
+import org.scalatest.flatspec.AnyFlatSpec
+
+class PartitionTransformerTest extends AnyFlatSpec with SparkSessionTest {
+
+  val wordDirectory = "src/test/resources/reader/doc"
+
+  "PartitionTransformer" should "work in a RAG pipeline" in {
+    val partition = new PartitionTransformer()
+      .setContentPath(s"$wordDirectory/fake_table.docx")
+//      .setInputCols("doc")
+      .setOutputCol("partition")
+    //TODO: Should we allow the user to set the input column name?
+
+    val marian = MarianTransformer.pretrained()
+      .setInputCols("partition")
+      .setOutputCol("translation")
+      .setMaxInputLength(30)
+
+    val pipeline = new Pipeline()
+      .setStages(Array(partition, marian))
+
+    val pipelineModel = pipeline.fit(emptyDataSet)
+    val resultDf = pipelineModel.transform(emptyDataSet)
+    resultDf.select("doc", "partition", "translation").show(truncate = false)
+  }
+
+  it should "work with a Document input" in {
+    import spark.implicits._
+    val testDataSet = Seq("An example with DocumentAssembler annotator").toDS.toDF("text")
+
+    val partition = new PartitionTransformer()
+      .setInputCols("document")
+      .setOutputCol("partition")
+
+    val pipeline = new Pipeline()
+      .setStages(Array(documentAssembler, partition))
+
+    val pipelineModel = pipeline.fit(emptyDataSet)
+    val resultDf = pipelineModel.transform(testDataSet)
+    resultDf.show(truncate = false)
+  }
+
+  it should "work with a Cleaner input" in {
+    import spark.implicits._
+    val testDf = Seq("\\x88This text contains ®non-ascii characters!●").toDS.toDF("text")
+    testDf.show(truncate = false)
+
+    val cleaner = new Cleaner()
+      .setInputCols("document")
+      .setOutputCol("cleaned")
+      .setCleanerMode("clean_non_ascii_chars")
+
+    val partition = new PartitionTransformer()
+      .setInputCols("cleaned")
+      .setOutputCol("partition")
+
+    val pipeline = new Pipeline()
+      .setStages(Array(documentAssembler, cleaner, partition))
+
+    val pipelineModel = pipeline.fit(emptyDataSet)
+    val resultDf = pipelineModel.transform(testDf)
+    resultDf.show(truncate = false)
+  }
+
+  // Pipeline4: Partition("contentType" -> "application/msword", "chunkerStrategy" -> "basic") --> ChatGPTAPI or other LLM from HuggingFace
+
+  //TODO: Unit tests exceptions
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/reader/EmailReaderTest.scala b/src/test/scala/com/johnsnowlabs/reader/EmailReaderTest.scala
index cb04b68d5948be..6885e60c014f35 100644
--- a/src/test/scala/com/johnsnowlabs/reader/EmailReaderTest.scala
+++ b/src/test/scala/com/johnsnowlabs/reader/EmailReaderTest.scala
@@ -30,10 +30,11 @@ class EmailReaderTest extends AnyFlatSpec {
   "EmailReader" should "read a directory of eml files" taggedAs FastTest in {
     val emailReader = new EmailReader()
     val emailDf = emailReader.read(emailDirectory)
-    emailDf.select("email").show()
-    emailDf.printSchema()
+    emailDf.select("email").show(truncate = false)
+//    emailDf.printSchema()
 
-    assert(!emailDf.select(col("email").getItem(0)).isEmpty)
+//    assert(!emailDf.select(col("email").getItem(0)).isEmpty)
+//    assert(!emailDf.columns.contains("content"))
   }
 
   it should "read email file with attachments" taggedAs FastTest in {
@@ -56,11 +57,11 @@ class EmailReaderTest extends AnyFlatSpec {
       .filter($"elementType" === ElementType.NARRATIVE_TEXT)
       .count()
 
-    println(s"textCount = $textCount")
     assert(!emailDf.select(col("email").getItem(0)).isEmpty)
     assert(attachmentCount == 3)
     assert(titleCount == 1)
     assert(textCount == 2)
+    assert(!emailDf.columns.contains("content"))
   }
 
   it should "read email file with two text attachments" taggedAs FastTest in {
@@ -88,6 +89,7 @@ class EmailReaderTest extends AnyFlatSpec {
     assert(attachmentCount == 2)
     assert(titleCount == 1)
     assert(textCount == 2)
+    assert(!emailDf.columns.contains("content"))
   }
 
   it should "read attachment content when addAttachmentContent = true" taggedAs FastTest in {
@@ -115,6 +117,16 @@ class EmailReaderTest extends AnyFlatSpec {
     assert(attachmentCount == 2)
     assert(titleCount == 1)
     assert(textCount == 4)
+    assert(!emailDf.columns.contains("content"))
+  }
+
+  it should "store content" taggedAs FastTest in {
+    val emailReader = new EmailReader(storeContent = true)
+    val emailDf = emailReader.read(emailDirectory)
+    emailDf.show()
+
+    assert(!emailDf.select(col("email").getItem(0)).isEmpty)
+    assert(emailDf.columns.contains("content"))
   }
 
 }
diff --git a/src/test/scala/com/johnsnowlabs/reader/ExcelReaderTest.scala b/src/test/scala/com/johnsnowlabs/reader/ExcelReaderTest.scala
new file mode 100644
index 00000000000000..5704335d981b5e
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/reader/ExcelReaderTest.scala
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.tags.FastTest
+import org.apache.spark.sql.functions.{col, explode}
+import org.scalatest.flatspec.AnyFlatSpec
+
+class ExcelReaderTest extends AnyFlatSpec {
+
+  val docDirectory = "src/test/resources/reader/xls"
+
+  "ExcelReader" should "read an excel file" taggedAs FastTest in {
+    val excelReader = new ExcelReader()
+    val excelDf = excelReader.xls(s"$docDirectory/2023-half-year-analyses-by-segment.xlsx")
+    excelDf.select("xls").show(false)
+
+    assert(!excelDf.select(col("xls").getItem(0)).isEmpty)
+    assert(!excelDf.columns.contains("content"))
+  }
+
+  "ExcelReader" should "read a directory of excel files" taggedAs FastTest in {
+    val excelReader = new ExcelReader()
+    val excelDf = excelReader.xls(docDirectory)
+    excelDf.select("xls").show(false)
+
+    assert(!excelDf.select(col("xls").getItem(0)).isEmpty)
+    assert(!excelDf.columns.contains("content"))
+  }
+
+  "ExcelReader" should "read a directory of excel files with custom cell separator" taggedAs FastTest in {
+    val excelReader = new ExcelReader(cellSeparator = ";")
+    val excelDf = excelReader.xls(s"$docDirectory/vodafone.xlsx")
+    excelDf.select("xls").show(false)
+
+    assert(!excelDf.select(col("xls").getItem(0)).isEmpty)
+    assert(!excelDf.columns.contains("content"))
+  }
+
+  "ExcelReader" should "store content" taggedAs FastTest in {
+    val excelReader = new ExcelReader(storeContent = true)
+    val excelDf = excelReader.xls(docDirectory)
+    excelDf.select("xls").show(false)
+
+    assert(!excelDf.select(col("xls").getItem(0)).isEmpty)
+    assert(excelDf.columns.contains("content"))
+  }
+
+  it should "work for break pages" taggedAs FastTest in {
+    val excelReader = new ExcelReader(includePageBreaks = true)
+    val excelDf = excelReader.xls(s"$docDirectory/page-break-example.xlsx")
+    excelDf.select("xls").show(false)
+
+    val explodedDf = excelDf.withColumn("xls_exploded", explode(col("xls")))
+    val page1Df = explodedDf.filter(
+      col("xls_exploded.elementType") === "Title" &&
+        col("xls_exploded.content") === "Assets" &&
+        col("xls_exploded.metadata")("pageBreak") === "1")
+    val page2Df = explodedDf.filter(
+      col("xls_exploded.elementType") === "Title" &&
+        col("xls_exploded.content") === "Debts" &&
+        col("xls_exploded.metadata")("pageBreak") === "2")
+
+    assert(page1Df.count() > 0, "Expected at least one row with Title/Assets and pageBreak = 1")
+    assert(page2Df.count() > 0, "Expected at least one row with Title/Debts and pageBreak = 2")
+  }
+
+  it should "provide HTML version of the table" taggedAs FastTest in {
+    val excelReader = new ExcelReader(inferTableStructure = true)
+    val excelDf = excelReader.xls(s"$docDirectory/page-break-example.xlsx")
+    val htmlDf = excelDf
+      .withColumn("xls_exploded", explode(col("xls")))
+      .filter(col("xls_exploded.elementType") === "HTML")
+    excelDf.select("xls").show(false)
+
+    assert(!excelDf.select(col("xls").getItem(0)).isEmpty)
+    assert(!excelDf.columns.contains("content"))
+    assert(htmlDf.count() > 0, "Expected at least one row with HTML element type")
+  }
+
+  it should "append all cells data in one row" taggedAs FastTest in {
+    val excelReaderSubtable = new ExcelReader(appendCells = true)
+    val excelSubtableDf = excelReaderSubtable.xls(s"$docDirectory/xlsx-subtable-cases.xlsx")
+    val explodedSubtableExcelDf =
+      excelSubtableDf.withColumn("xls_exploded", explode(col("xls"))).select("xls_exploded")
+
+    val excelReader = new ExcelReader(appendCells = false)
+    val excelDf = excelReader.xls(s"$docDirectory/xlsx-subtable-cases.xlsx")
+    val explodedExcelDf =
+      excelDf.withColumn("xls_exploded", explode(col("xls"))).select("xls_exploded")
+
+    explodedSubtableExcelDf.select("xls_exploded").show(false)
+    explodedExcelDf.select("xls_exploded").show(false)
+
+    assert(explodedSubtableExcelDf.count() == 1, "Expected only one row with all info")
+    assert(explodedExcelDf.count() > 1, "Expected more than one row with all info")
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/reader/HTMLReaderTest.scala b/src/test/scala/com/johnsnowlabs/reader/HTMLReaderTest.scala
index 8c43f0ac996066..b3bc571e3be40a 100644
--- a/src/test/scala/com/johnsnowlabs/reader/HTMLReaderTest.scala
+++ b/src/test/scala/com/johnsnowlabs/reader/HTMLReaderTest.scala
@@ -23,10 +23,13 @@ class HTMLReaderTest extends AnyFlatSpec {
 
   val htmlFilesDirectory = "./src/test/resources/reader/html/"
 
-  it should "read html as dataframe" taggedAs FastTest in {
+  "HTMLReader" should "read html as dataframe" taggedAs FastTest in {
     val HTMLReader = new HTMLReader()
-    val result = HTMLReader.read(htmlFilesDirectory)
-    result.show()
+    val htmlDF = HTMLReader.read(htmlFilesDirectory)
+    htmlDF.show()
+
+    assert(!htmlDF.select(col("html").getItem(0)).isEmpty)
+    assert(!htmlDF.columns.contains("content"))
   }
 
   it should "read html as dataframe with params" taggedAs FastTest in {
@@ -35,6 +38,7 @@ class HTMLReaderTest extends AnyFlatSpec {
     htmlDF.show()
 
     assert(!htmlDF.select(col("html").getItem(0)).isEmpty)
+    assert(!htmlDF.columns.contains("content"))
   }
 
   it should "parse an html in real time" taggedAs FastTest in {
@@ -43,6 +47,7 @@ class HTMLReaderTest extends AnyFlatSpec {
     htmlDF.show()
 
     assert(!htmlDF.select(col("html").getItem(0)).isEmpty)
+    assert(!htmlDF.columns.contains("content"))
   }
 
   it should "parse URLS in real time" taggedAs FastTest in {
@@ -51,6 +56,26 @@ class HTMLReaderTest extends AnyFlatSpec {
     htmlDF.show()
 
     assert(!htmlDF.select(col("html").getItem(0)).isEmpty)
+    assert(!htmlDF.columns.contains("content"))
+  }
+
+  it should "store content" taggedAs FastTest in {
+    val HTMLReader = new HTMLReader(storeContent = true)
+    val htmlDF = HTMLReader.read(htmlFilesDirectory)
+    htmlDF.show()
+
+    assert(!htmlDF.select(col("html").getItem(0)).isEmpty)
+    assert(htmlDF.columns.contains("content"))
+  }
+
+  it should "work with headers" taggedAs FastTest in {
+    val HTMLReader =
+      new HTMLReader(headers = Map("User-Agent" -> "Mozilla/5.0", "Accept-Language" -> "es-ES"))
+    val htmlDF = HTMLReader.read("https://www.google.com")
+    htmlDF.show()
+
+    assert(!htmlDF.select(col("html").getItem(0)).isEmpty)
+    assert(!htmlDF.columns.contains("content"))
   }
 
 }
diff --git a/src/test/scala/com/johnsnowlabs/reader/PdfToTextTest.scala b/src/test/scala/com/johnsnowlabs/reader/PdfToTextTest.scala
new file mode 100644
index 00000000000000..ba00940d5c5a5d
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/reader/PdfToTextTest.scala
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.tags.FastTest
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.functions.col
+import org.scalatest.flatspec.AnyFlatSpec
+
+class PdfToTextTest extends AnyFlatSpec {
+
+  private val spark = ResourceHelper.spark
+  spark.conf.set("spark.sql.legacy.allowUntypedScalaUDF", "true")
+
+  "PdfToText" should "read PDF files" taggedAs FastTest in {
+    val pdfToText = new PdfToText().setStoreSplittedPdf(true)
+    val dummyDataFrame = spark.read.format("binaryFile").load("src/test/resources/reader/pdf")
+
+    val pipelineModel = new Pipeline()
+      .setStages(Array(pdfToText))
+      .fit(dummyDataFrame)
+
+    val pdfDf = pipelineModel.transform(dummyDataFrame)
+    pdfDf.show()
+
+    assert(pdfDf.count() > 0)
+  }
+
+  it should "not include content data when setStoreSplittedPdf is false" in {
+    val pdfToText = new PdfToText().setStoreSplittedPdf(false)
+    val dummyDataFrame = spark.read.format("binaryFile").load("src/test/resources/reader/pdf")
+
+    val pipelineModel = new Pipeline()
+      .setStages(Array(pdfToText))
+      .fit(dummyDataFrame)
+
+    val pdfDf = pipelineModel.transform(dummyDataFrame)
+    pdfDf.show()
+
+    assert(pdfDf.filter(col("content").isNotNull).count() == 0)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/reader/PowerPointTest.scala b/src/test/scala/com/johnsnowlabs/reader/PowerPointTest.scala
new file mode 100644
index 00000000000000..fb11f59114e8f2
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/reader/PowerPointTest.scala
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.tags.FastTest
+import org.apache.spark.sql.functions.{col, explode}
+import org.scalatest.flatspec.AnyFlatSpec
+
+class PowerPointTest extends AnyFlatSpec {
+
+  val docDirectory = "src/test/resources/reader/ppt"
+
+  "PowerPointReader" should "read a power point file" taggedAs FastTest in {
+    val powerPointReader = new PowerPointReader()
+    val pptDf = powerPointReader.ppt(s"$docDirectory/fake-power-point.pptx")
+    val narrativeTextDf = pptDf
+      .withColumn("ppt_exploded", explode(col("ppt")))
+      .filter(col("ppt_exploded.elementType") === ElementType.NARRATIVE_TEXT)
+    pptDf.select("ppt").show(false)
+
+    assert(!pptDf.select(col("ppt").getItem(0)).isEmpty)
+    assert(!pptDf.columns.contains("content"))
+    assert(narrativeTextDf.count() == 2)
+  }
+
+  "PowerPointReader" should "read a power point directory" taggedAs FastTest in {
+    val powerPointReader = new PowerPointReader()
+    val pptDf = powerPointReader.ppt(s"$docDirectory")
+    pptDf.select("ppt").show(false)
+
+    assert(!pptDf.select(col("ppt").getItem(0)).isEmpty)
+    assert(!pptDf.columns.contains("content"))
+  }
+
+  "PowerPointReader" should "read a power point file with table" taggedAs FastTest in {
+    val powerPointReader = new PowerPointReader()
+    val pptDf = powerPointReader.ppt(s"$docDirectory/fake-power-point-table.pptx")
+    pptDf.select("ppt").show(false)
+
+    assert(!pptDf.select(col("ppt").getItem(0)).isEmpty)
+    assert(!pptDf.columns.contains("content"))
+  }
+
+  "PowerPointReader" should "store content" taggedAs FastTest in {
+    val powerPointReader = new PowerPointReader(storeContent = true)
+    val pptDf = powerPointReader.ppt(docDirectory)
+    pptDf.show()
+
+    assert(!pptDf.select(col("ppt").getItem(0)).isEmpty)
+    assert(pptDf.columns.contains("content"))
+  }
+
+  it should "reax pptx file with tables including HTML form" taggedAs FastTest in {
+    val powerPointReader = new PowerPointReader(inferTableStructure = true)
+    val pptDf = powerPointReader.ppt(s"$docDirectory/fake-power-point-table.pptx")
+    val htmlDf = pptDf
+      .withColumn("ppt_exploded", explode(col("ppt")))
+      .filter(col("ppt_exploded.elementType") === ElementType.HTML)
+    pptDf.select("ppt").show(false)
+
+    assert(!pptDf.select(col("ppt").getItem(0)).isEmpty)
+    assert(!pptDf.columns.contains("content"))
+    assert(htmlDf.count() > 0, "Expected at least one row with HTML element type")
+  }
+
+  it should "read speaker notes in a power point file" taggedAs FastTest in {
+    val powerPointReader = new PowerPointReader(includeSlideNotes = true)
+    val pptDf = powerPointReader.ppt(s"$docDirectory/speaker-notes.pptx")
+    pptDf.select("ppt").show(false)
+    val narrativeTextDf = pptDf
+      .withColumn("ppt_exploded", explode(col("ppt")))
+      .filter(col("ppt_exploded.elementType") === ElementType.NARRATIVE_TEXT)
+
+    assert(!pptDf.select(col("ppt").getItem(0)).isEmpty)
+    assert(!pptDf.columns.contains("content"))
+    assert(narrativeTextDf.count() == 3)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/reader/SparkNLPReaderTest.scala b/src/test/scala/com/johnsnowlabs/reader/SparkNLPReaderTest.scala
new file mode 100644
index 00000000000000..6733186bd8643a
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/reader/SparkNLPReaderTest.scala
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.tags.FastTest
+import org.scalatest.flatspec.AnyFlatSpec
+
+class SparkNLPReaderTest extends AnyFlatSpec {
+
+  "pdf" should "read a PDF file and return a structured Dataframe" taggedAs FastTest in {
+    val pdfPath = "src/test/resources/reader/pdf"
+    val sparkNLPReader = new SparkNLPReader()
+    val pdfDf = sparkNLPReader.pdf(pdfPath)
+
+    assert(pdfDf.count() > 0)
+  }
+
+  it should "read a PDF file with params" taggedAs FastTest in {
+    val pdfPath = "src/test/resources/reader/pdf"
+    val params = new java.util.HashMap[String, String]()
+    params.put("storeSplittedPdf", "true")
+    val sparkNLPReader = new SparkNLPReader(params)
+    val pdfDf = sparkNLPReader.pdf(pdfPath)
+    pdfDf.show()
+
+    assert(pdfDf.count() > 0)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/reader/TextReaderTest.scala b/src/test/scala/com/johnsnowlabs/reader/TextReaderTest.scala
new file mode 100644
index 00000000000000..e5955fc9ee77e2
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/reader/TextReaderTest.scala
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2017-2025 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.tags.FastTest
+import org.apache.spark.sql.functions.col
+import org.scalatest.flatspec.AnyFlatSpec
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+
+import scala.collection.mutable
+
+class TextReaderTest extends AnyFlatSpec {
+
+  val txtDirectory = "src/test/resources/reader/txt/"
+
+  "Text Reader" should "read a directory of text files" taggedAs FastTest in {
+    val textReader = new TextReader()
+    val textDf = textReader.txt(s"$txtDirectory/simple-text.txt")
+    textDf.select("txt").show(false)
+
+    assert(!textDf.select(col("txt").getItem(0)).isEmpty)
+    assert(!textDf.columns.contains("content"))
+  }
+
+  "Text Reader" should "store content" taggedAs FastTest in {
+    val textReader = new TextReader(storeContent = true)
+    val textDf = textReader.txt(txtDirectory)
+    textDf.show()
+
+    assert(!textDf.select(col("txt").getItem(0)).isEmpty)
+    assert(textDf.columns.contains("content"))
+  }
+
+  it should "group broken paragraphs" taggedAs FastTest in {
+    import ResourceHelper.spark.implicits._
+
+    val textReader = new TextReader(groupBrokenParagraphs = true)
+    val content =
+      """
+        |The big brown fox
+        |was walking down the lane.
+        |
+        |At the end of the lane,
+        |the fox met a bear.
+        |""".stripMargin
+    val textDf = textReader.txtContent(content)
+    textDf.show(truncate = false)
+
+    val elements: Seq[HTMLElement] = textDf
+      .select("txt")
+      .as[Seq[HTMLElement]]
+      .collect()
+      .head
+
+    val expectedElements = Seq(
+      HTMLElement(
+        ElementType.NARRATIVE_TEXT,
+        "The big brown fox was walking down the lane.",
+        mutable.Map("paragraph" -> "0")),
+      HTMLElement(
+        ElementType.NARRATIVE_TEXT,
+        "At the end of the lane, the fox met a bear.",
+        mutable.Map("paragraph" -> "0")))
+
+    assert(elements == expectedElements)
+  }
+
+  it should "group broken paragraphs reading from file" taggedAs FastTest in {
+    import ResourceHelper.spark.implicits._
+    val textReader = new TextReader(groupBrokenParagraphs = true)
+    val textDf = textReader.txt(s"$txtDirectory/test-paragraph.txt")
+    textDf.show(truncate = false)
+
+    val elements: Seq[HTMLElement] = textDf
+      .select("txt")
+      .as[Seq[HTMLElement]]
+      .collect()
+      .head
+
+    val expectedElements = Seq(
+      HTMLElement(
+        ElementType.NARRATIVE_TEXT,
+        "The big brown fox was walking down the lane.",
+        mutable.Map("paragraph" -> "0")),
+      HTMLElement(
+        ElementType.NARRATIVE_TEXT,
+        "At the end of the lane, the fox met a bear.",
+        mutable.Map("paragraph" -> "0")))
+
+    assert(elements == expectedElements)
+  }
+
+  it should "paragraph split with custom regex" taggedAs FastTest in {
+    import ResourceHelper.spark.implicits._
+    val textReader =
+      new TextReader(groupBrokenParagraphs = true, paragraphSplit = """(\s*\n\s*){3}""")
+    val content = """The big red fox
+
+is walking down the lane.
+
+
+At the end of the lane
+
+the fox met a friendly bear."""
+    val textDf = textReader.txtContent(content)
+    textDf.show(truncate = false)
+
+    val elements: Seq[HTMLElement] = textDf
+      .select("txt")
+      .as[Seq[HTMLElement]]
+      .collect()
+      .head
+
+    val expectedElements = Seq(
+      HTMLElement(
+        ElementType.NARRATIVE_TEXT,
+        "The big red fox is walking down the lane.",
+        mutable.Map("paragraph" -> "0")),
+      HTMLElement(
+        ElementType.NARRATIVE_TEXT,
+        "At the end of the lane the fox met a friendly bear.",
+        mutable.Map("paragraph" -> "0")))
+
+    assert(elements == expectedElements)
+  }
+
+}
diff --git a/src/test/scala/com/johnsnowlabs/reader/WordReaderTest.scala b/src/test/scala/com/johnsnowlabs/reader/WordReaderTest.scala
index d98293cf595833..99afd2d4ccd042 100644
--- a/src/test/scala/com/johnsnowlabs/reader/WordReaderTest.scala
+++ b/src/test/scala/com/johnsnowlabs/reader/WordReaderTest.scala
@@ -31,12 +31,13 @@ class WordReaderTest extends AnyFlatSpec {
     val wordReader = new WordReader()
     val wordDf = wordReader.doc(docDirectory)
     wordDf.select("doc").show(false)
-
+    wordDf.printSchema()
     assert(!wordDf.select(col("doc").getItem(0)).isEmpty)
+    assert(!wordDf.columns.contains("content"))
   }
 
   "WordReader" should "read a docx file with page breaks" taggedAs FastTest in {
-    val wordReader = new WordReader()
+    val wordReader = new WordReader(includePageBreaks = true)
     val wordDf = wordReader.doc(s"$docDirectory/page-breaks.docx")
     wordDf.select("doc").show(false)
 
@@ -46,14 +47,20 @@ class WordReaderTest extends AnyFlatSpec {
       .count()
 
     assert(pageBreakCount == 5)
+    assert(!wordDf.columns.contains("content"))
   }
 
   "WordReader" should "read a docx file with tables" taggedAs FastTest in {
     val wordReader = new WordReader()
     val wordDf = wordReader.doc(s"$docDirectory/fake_table.docx")
+    val htmlDf = wordDf
+      .withColumn("doc_exploded", explode(col("doc")))
+      .filter(col("doc_exploded.elementType") === "HTML")
     wordDf.select("doc").show(false)
 
     assert(!wordDf.select(col("doc").getItem(0)).isEmpty)
+    assert(!wordDf.columns.contains("content"))
+    assert(htmlDf.count() == 0, "Expected no row with HTML element type")
   }
 
   "WordReader" should "read a docx file with images on it" taggedAs FastTest in {
@@ -62,6 +69,29 @@ class WordReaderTest extends AnyFlatSpec {
     wordDf.select("doc").show(false)
 
     assert(!wordDf.select(col("doc").getItem(0)).isEmpty)
+    assert(!wordDf.columns.contains("content"))
+  }
+
+  "WordReader" should "store content" taggedAs FastTest in {
+    val wordReader = new WordReader(storeContent = true)
+    val wordDf = wordReader.doc(s"$docDirectory")
+    wordDf.select("doc").show(false)
+
+    assert(!wordDf.select(col("doc").getItem(0)).isEmpty)
+    assert(wordDf.columns.contains("content"))
+  }
+
+  it should "read docx file with tables including HTML form" taggedAs FastTest in {
+    val wordReader = new WordReader(inferTableStructure = true)
+    val wordDf = wordReader.doc(s"$docDirectory/fake_table.docx")
+    val htmlDf = wordDf
+      .withColumn("doc_exploded", explode(col("doc")))
+      .filter(col("doc_exploded.elementType") === "HTML")
+    wordDf.select("doc").show(false)
+
+    assert(!wordDf.select(col("doc").getItem(0)).isEmpty)
+    assert(!wordDf.columns.contains("content"))
+    assert(htmlDf.count() > 0, "Expected at least one row with HTML element type")
   }
 
 }
diff --git a/src/test/scala/com/johnsnowlabs/reader/XMLReaderTest.scala b/src/test/scala/com/johnsnowlabs/reader/XMLReaderTest.scala
new file mode 100644
index 00000000000000..a75537803e61de
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/reader/XMLReaderTest.scala
@@ -0,0 +1,43 @@
+package com.johnsnowlabs.reader
+
+import com.johnsnowlabs.tags.FastTest
+import org.apache.spark.sql.functions.{array_contains, col, explode, map_keys}
+import org.scalatest.flatspec.AnyFlatSpec
+
+class XMLReaderTest extends AnyFlatSpec {
+
+  val xmlFilesDirectory = "./src/test/resources/reader/xml/"
+
+  "XMLReader" should "read xml as dataframe" taggedAs FastTest in {
+    val XMLReader = new XMLReader()
+    val xmlDF = XMLReader.read(s"$xmlFilesDirectory/test.xml")
+    xmlDF.show(truncate = false)
+
+    assert(!xmlDF.select(col("xml").getItem(0)).isEmpty)
+    assert(!xmlDF.columns.contains("content"))
+  }
+
+  it should "include tags in the output" taggedAs FastTest in {
+    val XMLReader = new XMLReader(xmlKeepTags = true)
+    val xmlDF = XMLReader.read(s"$xmlFilesDirectory/multi-level.xml")
+    xmlDF.show(truncate = false)
+
+    val explodedDf = xmlDF.withColumn("xml_exploded", explode(col("xml")))
+    val tagsDf = explodedDf.filter(col("xml_exploded.metadata")("tag") =!= "")
+
+    assert(tagsDf.count() > 0)
+  }
+
+  it should "output all nodes" taggedAs FastTest in {
+    val XMLReader = new XMLReader(onlyLeafNodes = false)
+    val xmlDF = XMLReader.read(s"$xmlFilesDirectory/multi-level.xml")
+    xmlDF.show(truncate = false)
+    val explodedDf = xmlDF.withColumn("xml_exploded", explode(col("xml")))
+
+    val noParentIdCount = explodedDf
+      .filter(!array_contains(map_keys(col("xml_exploded.metadata")), "parentId"))
+
+    assert(noParentIdCount.count() > 0)
+  }
+
+}