model-compose 0.2.10__tar.gz → 0.2.12__tar.gz

{model_compose-0.2.10/src/model_compose.egg-info → model_compose-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.2.10
+Version: 0.2.12
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -20,8 +20,10 @@ Requires-Dist: pyngrok
 Requires-Dist: ulid
 Requires-Dist: gradio
 Requires-Dist: Pillow
-Requires-Dist: transformers
+Requires-Dist: transformers>=4.21.0
 Requires-Dist: torch
+Requires-Dist: sentencepiece
+Requires-Dist: accelerate
 Dynamic: license-file
 
 # model-compose: Declarative AI Model and Workflow Orchestrator

{model_compose-0.2.10 → model_compose-0.2.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.2.10"
+version = "0.2.12"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -21,8 +21,10 @@ dependencies = [
     "ulid", 
     "gradio",
     "Pillow",
-    "transformers",
-    "torch"
+    "transformers>=4.21.0",
+    "torch",
+    "sentencepiece",
+    "accelerate"
 ]
 
 [project.scripts]

model_compose-0.2.12/src/mindor/core/component/services/model/tasks/__init__.py

@@ -0,0 +1,5 @@
+from .text_generation import *
+from .summarization import *
+from .translation import *
+from .text_classification import *
+from .text_embedding import *

model_compose-0.2.12/src/mindor/core/component/services/model/tasks/summarization.py

@@ -0,0 +1,78 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, SummarizationModelActionConfig
+from mindor.core.logger import logging
+from ..base import ModelTaskService, ModelTaskType, register_model_task_service
+from ..base import ComponentActionContext
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin
+import torch
+
+class SummarizationTaskAction:
+    def __init__(self, config: SummarizationModelActionConfig, model: Union[PreTrainedModel, GenerationMixin], tokenizer: PreTrainedTokenizer):
+        self.config: SummarizationModelActionConfig = config
+        self.model: Union[PreTrainedModel, GenerationMixin] = model
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        text: Union[str, List[str]] = await context.render_variable(self.config.text)
+
+        max_input_length  = await context.render_variable(self.config.params.max_input_length)
+        max_output_length = await context.render_variable(self.config.params.max_output_length)
+        min_output_length = await context.render_variable(self.config.params.min_output_length)
+        num_beams         = await context.render_variable(self.config.params.num_beams)
+        length_penalty    = await context.render_variable(self.config.params.length_penalty)
+        early_stopping    = await context.render_variable(self.config.params.early_stopping)
+        do_sample         = await context.render_variable(self.config.params.do_sample)
+        batch_size        = await context.render_variable(self.config.params.batch_size)
+
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
+
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=max_output_length,
+                    min_length=min_output_length,
+                    num_beams=num_beams,
+                    length_penalty=length_penalty,
+                    early_stopping=early_stopping,
+                    do_sample=do_sample,
+                    pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                    eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
+                )
+
+            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            results.extend(outputs)
+        
+        result = results if len(results) > 1 else results[0]
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+@register_model_task_service(ModelTaskType.SUMMARIZATION)
+class SummarizationTaskService(ModelTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[Union[PreTrainedModel, GenerationMixin]] = None
+        self.tokenizer: Optional[PreTrainedTokenizer] = None
+
+    async def _serve(self) -> None:
+        try:
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.model = None
+        self.tokenizer = None
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await SummarizationTaskAction(action, self.model, self.tokenizer).run(context)

model_compose-0.2.12/src/mindor/core/component/services/model/tasks/text_classification.py

@@ -0,0 +1,78 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, TextClassificationModelActionConfig
+from mindor.core.logger import logging
+from ..base import ModelTaskService, ModelTaskType, register_model_task_service
+from ..base import ComponentActionContext
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer
+from transformers.modeling_outputs import SequenceClassifierOutput
+import torch.nn.functional as F
+import torch
+
+class TextClassificationTaskAction:
+    def __init__(self, config: TextClassificationModelActionConfig, model: PreTrainedModel, tokenizer: PreTrainedTokenizer):
+        self.config: TextClassificationModelActionConfig = config
+        self.model: PreTrainedModel = model
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+    async def run(self, context: ComponentActionContext, labels: Optional[List[str]]) -> Any:
+        text: Union[str, List[str]] = await context.render_variable(self.config.text)
+
+        return_probabilities = await context.render_variable(self.config.params.return_probabilities)
+        batch_size           = await context.render_variable(self.config.params.batch_size)
+
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
+
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", padding=True, truncation=True).to(self.model.device)
+
+            with torch.no_grad():
+                outputs: SequenceClassifierOutput = self.model(**inputs)
+                logits = outputs.logits  # shape: (batch_size, num_classes)
+                
+                predicted = []
+                if return_probabilities:
+                    probs = F.softmax(logits, dim=-1).cpu()
+                    for prob in probs:
+                        predicted_index = torch.argmax(prob).item()
+                        predicted.append({
+                            "label": labels[predicted_index] if labels else predicted_index,
+                            "probabilities": prob.tolist()
+                        })
+                else:
+                    predicted_indices = torch.argmax(logits, dim=-1).tolist()
+                    for predicted_index in predicted_indices:
+                        predicted.append(labels[predicted_index] if labels else predicted_index)
+
+            results.extend(predicted)
+
+        result = results if len(results) > 1 else results[0]
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+@register_model_task_service(ModelTaskType.TEXT_CLASSIFICATION)
+class TextClassificationTaskService(ModelTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[PreTrainedModel] = None
+        self.tokenizer: Optional[PreTrainedTokenizer] = None
+
+    async def _serve(self) -> None:
+        try:
+            self.model = AutoModelForSequenceClassification.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.model = None
+        self.tokenizer = None
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await TextClassificationTaskAction(action, self.model, self.tokenizer).run(context, self.config.labels)

{model_compose-0.2.10 → model_compose-0.2.12}/src/mindor/core/component/services/model/tasks/text_embedding.py

@@ -1,6 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ModelComponentConfig
 from mindor.dsl.schema.action import ModelActionConfig, TextEmbeddingModelActionConfig
+from mindor.core.logger import logging
 from ..base import ModelTaskService, ModelTaskType, register_model_task_service
 from ..base import ComponentActionContext
 from transformers import AutoModel, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer
@@ -15,29 +16,33 @@ class TextEmbeddingTaskAction:
         self.tokenizer: PreTrainedTokenizer = tokenizer
 
     async def run(self, context: ComponentActionContext) -> Any:
-        text = await context.render_variable(self.config.text)
+        text: Union[str, List[str]] = await context.render_variable(self.config.text)
 
-        # Model parameters
-        max_length = await context.render_variable(self.config.params.max_length)
-        pooling    = await context.render_variable(self.config.params.pooling)
-        normalize  = await context.render_variable(self.config.params.normalize)
+        max_input_length = await context.render_variable(self.config.params.max_input_length)
+        pooling          = await context.render_variable(self.config.params.pooling)
+        normalize        = await context.render_variable(self.config.params.normalize)
+        batch_size       = await context.render_variable(self.config.params.batch_size)
 
-        # Tokenizing
-        inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=max_length).to(self.model.device)
-        attention_mask: Tensor = inputs.get("attention_mask", None)
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
 
-        # Forward pass through the model
-        with torch.no_grad():
-            outputs: BaseModelOutput = self.model(**inputs)
-            last_hidden_state = outputs.last_hidden_state  # (batch_size, seq_len, hidden_size)
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+            attention_mask: Tensor = inputs.get("attention_mask", None)
 
-        # Apply pooling strategy (mean, cls, max)
-        embedding = self._pool_hidden_state(last_hidden_state, attention_mask, pooling)
+            with torch.no_grad():
+                outputs: BaseModelOutput = self.model(**inputs)
+                last_hidden_state = outputs.last_hidden_state  # (batch_size, seq_len, hidden_size)
 
-        if normalize:
-            embedding = torch.nn.functional.normalize(embedding, p=2, dim=1)
+            embeddings = self._pool_hidden_state(last_hidden_state, attention_mask, pooling)
 
-        result = embedding.squeeze().tolist()
+            if normalize:
+                embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+
+            results.extend(embeddings.cpu().tolist())
+
+        result = results if len(results) > 1 else results[0]
         context.register_source("result", result)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
@@ -72,8 +77,13 @@ class TextEmbeddingTaskService(ModelTaskService):
         self.tokenizer: Optional[PreTrainedTokenizer] = None
 
     async def _serve(self) -> None:
-        self.model = AutoModel.from_pretrained(self.config.model).to(torch.device(self.config.device))
-        self.tokenizer = AutoTokenizer.from_pretrained(self.config.model)
+        try:
+            self.model = AutoModel.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
 
     async def _shutdown(self) -> None:
         self.model = None

{model_compose-0.2.10 → model_compose-0.2.12}/src/mindor/core/component/services/model/tasks/text_generation.py

@@ -1,6 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ModelComponentConfig
 from mindor.dsl.schema.action import ModelActionConfig, TextGenerationModelActionConfig
+from mindor.core.logger import logging
 from ..base import ModelTaskService, ModelTaskType, register_model_task_service
 from ..base import ComponentActionContext
 from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin
@@ -13,32 +14,37 @@ class TextGenerationTaskAction:
         self.tokenizer: PreTrainedTokenizer = tokenizer
 
     async def run(self, context: ComponentActionContext) -> Any:
-        prompt: str = await context.render_variable(self.config.prompt)
+        prompt: Union[str, List[str]] = await context.render_variable(self.config.prompt)
 
-        # Model parameters
-        max_length           = await context.render_variable(self.config.params.max_length)
+        max_output_length    = await context.render_variable(self.config.params.max_output_length)
         num_return_sequences = await context.render_variable(self.config.params.num_return_sequences)
         temperature          = await context.render_variable(self.config.params.temperature)
         top_k                = await context.render_variable(self.config.params.top_k)
         top_p                = await context.render_variable(self.config.params.top_p)
+        batch_size           = await context.render_variable(self.config.params.batch_size)
 
-        # Tokenizing
-        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
-
-        # Text generation
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_length=max_length,
-                num_return_sequences=num_return_sequences,
-                temperature=temperature,
-                top_k=top_k,
-                top_p=top_p,
-                do_sample=True
-            )
-
-        # Decoding output
-        result = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+        prompts: List[str] = [ prompt ] if isinstance(prompt, str) else prompt
+        results = []
+
+        for index in range(0, len(prompts), batch_size):
+            batch_prompts = prompts[index:index + batch_size]
+            inputs = self.tokenizer(batch_prompts, return_tensors="pt").to(self.model.device)
+
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=max_output_length,
+                    num_return_sequences=num_return_sequences,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p,
+                    do_sample=True
+                )
+
+            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            results.extend(outputs)
+
+        result = results if len(results) > 1 else results[0] 
         context.register_source("result", result)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
@@ -52,8 +58,13 @@ class TextGenerationTaskService(ModelTaskService):
         self.tokenizer: Optional[PreTrainedTokenizer] = None
 
     async def _serve(self) -> None:
-        self.model = AutoModelForCausalLM.from_pretrained(self.config.model).to(torch.device(self.config.device))
-        self.tokenizer = AutoTokenizer.from_pretrained(self.config.model)
+        try:
+            self.model = AutoModelForCausalLM.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
 
     async def _shutdown(self) -> None:
         self.model = None

model_compose-0.2.12/src/mindor/core/component/services/model/tasks/translation.py

@@ -0,0 +1,75 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, TranslationModelActionConfig
+from mindor.core.logger import logging
+from ..base import ModelTaskService, ModelTaskType, register_model_task_service
+from ..base import ComponentActionContext
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin
+import torch
+
+class TranslationTaskAction:
+    def __init__(self, config: TranslationModelActionConfig, model: Union[PreTrainedModel, GenerationMixin], tokenizer: PreTrainedTokenizer):
+        self.config: TranslationModelActionConfig = config
+        self.model: Union[PreTrainedModel, GenerationMixin] = model
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        text: Union[str, List[str]] = await context.render_variable(self.config.text)
+
+        max_input_length  = await context.render_variable(self.config.params.max_input_length)
+        max_output_length = await context.render_variable(self.config.params.max_output_length)
+        min_output_length = await context.render_variable(self.config.params.min_output_length)
+        num_beams         = await context.render_variable(self.config.params.num_beams)
+        length_penalty    = await context.render_variable(self.config.params.length_penalty)
+        batch_size        = await context.render_variable(self.config.params.batch_size)
+
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
+
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=max_output_length,
+                    min_length=min_output_length,
+                    num_beams=num_beams,
+                    length_penalty=length_penalty,
+                    do_sample=False,
+                    pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                    eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
+                )
+
+            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            results.extend(outputs)
+        
+        result = results if len(results) > 1 else results[0]
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+@register_model_task_service(ModelTaskType.TRANSLATION)
+class TranslationTaskService(ModelTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[Union[PreTrainedModel, GenerationMixin]] = None
+        self.tokenizer: Optional[PreTrainedTokenizer] = None
+
+    async def _serve(self) -> None:
+        try:
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.model = None
+        self.tokenizer = None
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await TranslationTaskAction(action, self.model, self.tokenizer).run(context)

{model_compose-0.2.10 → model_compose-0.2.12}/src/mindor/core/workflow/workflow.py

@@ -6,7 +6,6 @@ from mindor.core.utils.time import TimeTracker
 from mindor.core.logger import logging
 from .context import WorkflowContext
 from .job import Job, create_job
-from datetime import datetime
 import asyncio
 
 class JobGraphValidator:

model_compose-0.2.12/src/mindor/dsl/schema/action/impl/model/impl/__init__.py

@@ -0,0 +1,6 @@
+from .common import *
+from .text_generation import *
+from .summarization import *
+from .translation import *
+from .text_classification import *
+from .text_embedding import *

model_compose-0.2.12/src/mindor/dsl/schema/action/impl/model/impl/summarization.py

@@ -0,0 +1,18 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonModelActionConfig
+
+class SummarizationParamsConfig(BaseModel):
+    max_input_length: Union[int, str] = Field(default=1024, description="Maximum number of tokens per input text.")
+    max_output_length: Union[int, str] = Field(default=256, description="The maximum number of tokens to generate.")
+    min_output_length: Union[int, str] = Field(default=30, description="The minimum number of tokens to generate.")
+    num_beams: Union[int, str] = Field(default=4, description="Number of beams to use for beam search.")
+    length_penalty: Union[float, str] = Field(default=2.0, description="Length penalty applied during beam search.")
+    early_stopping: bool = Field(default=True, description="Whether to stop the beam search when all beams finish generating.")
+    do_sample: bool = Field(default=True, description="Whether to use sampling.")
+    batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
+
+class SummarizationModelActionConfig(CommonModelActionConfig):
+    text: Union[str, List[str]] = Field(..., description="Input text to summarize.")
+    params: SummarizationParamsConfig = Field(default_factory=SummarizationParamsConfig, description="Summarization configuration parameters.")

model_compose-0.2.12/src/mindor/dsl/schema/action/impl/model/impl/text_classification.py

@@ -0,0 +1,12 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonModelActionConfig
+
+class TextClassificationParamsConfig(BaseModel):
+    return_probabilities: Union[bool, str] = Field(default=False, description="Whether to return class probabilities for each prediction.")
+    batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
+
+class TextClassificationModelActionConfig(CommonModelActionConfig):
+    text: Union[str, List[str]] = Field(..., description="Input text to classify.")
+    params: TextClassificationParamsConfig = Field(default_factory=TextClassificationParamsConfig, description="Text classification configuration parameters.")

{model_compose-0.2.10 → model_compose-0.2.12}/src/mindor/dsl/schema/action/impl/model/impl/text_embedding.py

@@ -4,11 +4,11 @@ from pydantic import model_validator
 from .common import CommonModelActionConfig
 
 class TextEmbeddingParamsConfig(BaseModel):
+    max_input_length: Union[int, str] = Field(default=512, description="Maximum number of tokens per input text.")
     pooling: Literal[ "mean", "cls", "max" ] = Field(default="mean", description="Pooling strategy used to aggregate token embeddings.")
-    normalize: bool = Field(default=True, description="Whether to apply L2 normalization to the output embeddings.")
-    batch_size: int = Field(default=1, description="Number of input texts to process in a single batch.")
-    max_length: int = Field(default=512, description="Maximum number of tokens per input text.")
+    normalize: Union[bool, str] = Field(default=True, description="Whether to apply L2 normalization to the output embeddings.")
+    batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
 class TextEmbeddingModelActionConfig(CommonModelActionConfig):
-    text: str = Field(..., description="Input text to be embedded.")
+    text: Union[str, List[str]] = Field(..., description="Input text to be embedded.")
     params: TextEmbeddingParamsConfig = Field(default_factory=TextEmbeddingParamsConfig, description="Configuration parameters for embedding generation.")

model_compose-0.2.12/src/mindor/dsl/schema/action/impl/model/impl/text_generation.py

@@ -0,0 +1,16 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonModelActionConfig
+
+class TextGenerationParamsConfig(BaseModel):
+    max_output_length: Union[int, str] = Field(default=1024, description="The maximum number of tokens to generate.")
+    num_return_sequences: Union[int, str] = Field(default=1, description="The number of generated sequences to return.")
+    temperature: Union[float, str] = Field(default=1.0, description="Sampling temperature; higher values produce more random results.")
+    top_k: Union[int, str] = Field(default=50, description="Top-K sampling; restricts sampling to the top K tokens.")
+    top_p: Union[int, str] = Field(default=0.9, description="Top-p (nucleus) sampling; restricts sampling to tokens with cumulative probability >= top_p.")
+    batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
+
+class TextGenerationModelActionConfig(CommonModelActionConfig):
+    prompt: Union[str, List[str]] = Field(..., description="Input prompt to generate text from.")
+    params: TextGenerationParamsConfig = Field(default_factory=TextGenerationParamsConfig, description="Text generation configuration parameters.")

model_compose-0.2.12/src/mindor/dsl/schema/action/impl/model/impl/translation.py

@@ -0,0 +1,16 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonModelActionConfig
+
+class TranslationParamsConfig(BaseModel):
+    max_input_length: Union[int, str] = Field(default=1024, description="Maximum number of tokens per input text.")
+    max_output_length: Union[int, str] = Field(default=256, description="The maximum number of tokens to generate.")
+    min_output_length: Union[int, str] = Field(default=10, description="The minimum number of tokens to generate.")
+    num_beams: Union[int, str] = Field(default=4, description="Number of beams to use for beam search.")
+    length_penalty: Union[float, str] = Field(default=1.0, description="Length penalty applied during beam search.")
+    batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
+
+class TranslationModelActionConfig(CommonModelActionConfig):
+    text: Union[str, List[str]] = Field(..., description="Input text to translate.")
+    params: TranslationParamsConfig = Field(default_factory=TranslationParamsConfig, description="Translation configuration parameters.")

{model_compose-0.2.10 → model_compose-0.2.12}/src/mindor/dsl/schema/action/impl/model/model.py

@@ -4,5 +4,8 @@ from .impl import *
 
 ModelActionConfig = Union[
     TextGenerationModelActionConfig,
+    SummarizationModelActionConfig,
+    TranslationModelActionConfig,
+    TextClassificationModelActionConfig,
     TextEmbeddingModelActionConfig,
 ]

model_compose-0.2.12/src/mindor/dsl/schema/component/impl/model/impl/__init__.py

@@ -0,0 +1,6 @@
+from .common import *
+from .text_generation import *
+from .summarization import *
+from .translation import *
+from .text_classification import *
+from .text_embedding import *

{model_compose-0.2.10 → model_compose-0.2.12}/src/mindor/dsl/schema/component/impl/model/impl/common.py

@@ -8,11 +8,11 @@ from .types import ModelTaskType
 
 class CommonModelComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.MODEL]
-    task: ModelTaskType = Field(..., description="")
-    model: str = Field(..., description="")
+    task: ModelTaskType = Field(..., description="Type of task the model performs.")
+    model: str = Field(..., description="Model name or path.")
     device: str = Field(default="cpu", description="Computation device to use.")
-    cache_dir: Optional[str] = Field(default=None, description="")
-    actions: Dict[str, ModelActionConfig] = Field(default_factory=dict)
+    cache_dir: Optional[str] = Field(default=None, description="Directory to cache the model and tokenizer files.")
+    fast_tokenizer: bool = Field(default=True, description="Whether to use the fast tokenizer if available.")
 
     @model_validator(mode="before")
     def inflate_single_action(cls, values: Dict[str, Any]):
@@ -21,3 +21,6 @@ class CommonModelComponentConfig(CommonComponentConfig):
             if any(k in values for k in action_keys):
                 values["actions"] = { "__default__": { k: values.pop(k) for k in action_keys if k in values } }
         return values
+
+class ClassificationModelComponentConfig(CommonModelComponentConfig):
+    labels: Optional[List[str]] = Field(default=None, description="List of class labels for classification tasks.")

model_compose-0.2.12/src/mindor/dsl/schema/component/impl/model/impl/summarization.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import SummarizationModelActionConfig
+from .common import CommonModelComponentConfig, ModelTaskType
+
+class SummarizationModelComponentConfig(CommonModelComponentConfig):
+    task: Literal[ModelTaskType.SUMMARIZATION]
+    actions: Dict[str, SummarizationModelActionConfig] = Field(default_factory=dict)

model_compose-0.2.12/src/mindor/dsl/schema/component/impl/model/impl/text_classification.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import TextClassificationModelActionConfig
+from .common import ClassificationModelComponentConfig, ModelTaskType
+
+class TextClassificationModelComponentConfig(ClassificationModelComponentConfig):
+    task: Literal[ModelTaskType.TEXT_CLASSIFICATION]
+    actions: Dict[str, TextClassificationModelActionConfig] = Field(default_factory=dict, description="")

{model_compose-0.2.10 → model_compose-0.2.12}/src/mindor/dsl/schema/component/impl/model/impl/text_embedding.py

@@ -1,7 +1,9 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field
 from pydantic import model_validator
+from mindor.dsl.schema.action import TextEmbeddingModelActionConfig
 from .common import CommonModelComponentConfig, ModelTaskType
 
 class TextEmbeddingModelComponentConfig(CommonModelComponentConfig):
     task: Literal[ModelTaskType.TEXT_EMBEDDING]
+    actions: Dict[str, TextEmbeddingModelActionConfig] = Field(default_factory=dict)

{model_compose-0.2.10 → model_compose-0.2.12}/src/mindor/dsl/schema/component/impl/model/impl/text_generation.py

@@ -1,7 +1,9 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field
 from pydantic import model_validator
+from mindor.dsl.schema.action import TextGenerationModelActionConfig
 from .common import CommonModelComponentConfig, ModelTaskType
 
 class TextGenerationModelComponentConfig(CommonModelComponentConfig):
     task: Literal[ModelTaskType.TEXT_GENERATION]
+    actions: Dict[str, TextGenerationModelActionConfig] = Field(default_factory=dict)

model_compose-0.2.12/src/mindor/dsl/schema/component/impl/model/impl/translation.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import TranslationModelActionConfig
+from .common import CommonModelComponentConfig, ModelTaskType
+
+class TranslationModelComponentConfig(CommonModelComponentConfig):
+    task: Literal[ModelTaskType.TRANSLATION]
+    actions: Dict[str, TranslationModelActionConfig] = Field(default_factory=dict)