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

{model_compose-0.2.11/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.11
+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,7 +20,7 @@ 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

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

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

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

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

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

@@ -16,7 +16,6 @@ class SummarizationTaskAction:
     async def run(self, context: ComponentActionContext) -> Any:
         text: Union[str, List[str]] = await context.render_variable(self.config.text)
 
-        # Model parameters
         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)
@@ -24,28 +23,32 @@ class SummarizationTaskAction:
         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)
 
-        # Tokenizing
-        inputs = self.tokenizer(text, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
 
-        # Text Summarization
-        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)
-            )
+        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)
 
-        # Decoding output
-        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            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 = outputs if isinstance(text, list) else outputs[0] 
+        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

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.11 → model_compose-0.2.12}/src/mindor/core/component/services/model/tasks/text_embedding.py

@@ -16,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_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", max_length=max_input_length, padding=True, truncation=True).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

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

@@ -16,32 +16,35 @@ class TextGenerationTaskAction:
     async def run(self, context: ComponentActionContext) -> Any:
         prompt: Union[str, List[str]] = await context.render_variable(self.config.prompt)
 
-        # Model parameters
         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)
+        prompts: List[str] = [ prompt ] if isinstance(prompt, str) else prompt
+        results = []
 
-        # Text generation
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_length=max_output_length,
-                num_return_sequences=num_return_sequences,
-                temperature=temperature,
-                top_k=top_k,
-                top_p=top_p,
-                do_sample=True
-            )
+        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)
 
-        # Decoding output
-        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        
-        result = outputs if isinstance(prompt, list) else outputs[0] 
+            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

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

@@ -16,33 +16,36 @@ class TranslationTaskAction:
     async def run(self, context: ComponentActionContext) -> Any:
         text: Union[str, List[str]] = await context.render_variable(self.config.text)
 
-        # Model parameters
         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)
 
-        # Tokenizing
-        inputs = self.tokenizer(text, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
 
-        # Text Translation
-        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)
-            )
+        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)
 
-        # Decoding output
-        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            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 = outputs if isinstance(text, list) else outputs[0] 
+        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

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

@@ -2,4 +2,5 @@ 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.11 → 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: int = Field(default=512, description="Maximum number of tokens per input text.")
+    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.")
+    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.11 → model_compose-0.2.12}/src/mindor/dsl/schema/action/impl/model/model.py

@@ -6,5 +6,6 @@ ModelActionConfig = Union[
     TextGenerationModelActionConfig,
     SummarizationModelActionConfig,
     TranslationModelActionConfig,
+    TextClassificationModelActionConfig,
     TextEmbeddingModelActionConfig,
 ]

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

@@ -2,4 +2,5 @@ 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.11 → model_compose-0.2.12}/src/mindor/dsl/schema/component/impl/model/impl/common.py

@@ -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/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.12/src/mindor/dsl/schema/component/impl/model/impl/types.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ModelTaskType(str, Enum):
+    TEXT_GENERATION     = "text-generation"
+    SUMMARIZATION       = "summarization"
+    TRANSLATION         = "translation"
+    TEXT_CLASSIFICATION = "text-classification" 
+    TEXT_EMBEDDING      = "text-embedding"

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

@@ -7,6 +7,7 @@ ModelComponentConfig = Annotated[
         TextGenerationModelComponentConfig,
         SummarizationModelComponentConfig,
         TranslationModelComponentConfig,
+        TextClassificationModelComponentConfig,
         TextEmbeddingModelComponentConfig,
     ],
     Field(discriminator="task")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.2.11
+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,7 +20,7 @@ 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

{model_compose-0.2.11 → model_compose-0.2.12}/src/model_compose.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ src/mindor/core/component/services/model/base.py
 src/mindor/core/component/services/model/model.py
 src/mindor/core/component/services/model/tasks/__init__.py
 src/mindor/core/component/services/model/tasks/summarization.py
+src/mindor/core/component/services/model/tasks/text_classification.py
 src/mindor/core/component/services/model/tasks/text_embedding.py
 src/mindor/core/component/services/model/tasks/text_generation.py
 src/mindor/core/component/services/model/tasks/translation.py
@@ -105,6 +106,7 @@ src/mindor/dsl/schema/action/impl/model/model.py
 src/mindor/dsl/schema/action/impl/model/impl/__init__.py
 src/mindor/dsl/schema/action/impl/model/impl/common.py
 src/mindor/dsl/schema/action/impl/model/impl/summarization.py
+src/mindor/dsl/schema/action/impl/model/impl/text_classification.py
 src/mindor/dsl/schema/action/impl/model/impl/text_embedding.py
 src/mindor/dsl/schema/action/impl/model/impl/text_generation.py
 src/mindor/dsl/schema/action/impl/model/impl/translation.py
@@ -124,6 +126,7 @@ src/mindor/dsl/schema/component/impl/model/model.py
 src/mindor/dsl/schema/component/impl/model/impl/__init__.py
 src/mindor/dsl/schema/component/impl/model/impl/common.py
 src/mindor/dsl/schema/component/impl/model/impl/summarization.py
+src/mindor/dsl/schema/component/impl/model/impl/text_classification.py
 src/mindor/dsl/schema/component/impl/model/impl/text_embedding.py
 src/mindor/dsl/schema/component/impl/model/impl/text_generation.py
 src/mindor/dsl/schema/component/impl/model/impl/translation.py

{model_compose-0.2.11 → model_compose-0.2.12}/src/model_compose.egg-info/requires.txt

@@ -11,7 +11,7 @@ pyngrok
 ulid
 gradio
 Pillow
-transformers
+transformers>=4.21.0
 torch
 sentencepiece
 accelerate

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

@@ -1,17 +0,0 @@
-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: int = Field(default=1024, description="Maximum number of tokens per input text.")
-    max_output_length: int = Field(default=256, description="The maximum number of tokens to generate.")
-    min_output_length: int = Field(default=30, description="The minimum number of tokens to generate.")
-    num_beams: int = Field(default=4, description="")
-    length_penalty: float = Field(default=2.0, description="")
-    early_stopping: bool = Field(default=True, description="")
-    do_sample: bool = Field(default=True, description="Whether to use sampling.")
-
-class SummarizationModelActionConfig(CommonModelActionConfig):
-    text: str = Field(..., description="")
-    params: SummarizationParamsConfig = Field(default_factory=SummarizationParamsConfig, description="Summarization configuration parameters.")

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

@@ -1,15 +0,0 @@
-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: int = Field(default=1024, description="The maximum number of tokens to generate.")
-    num_return_sequences: int = Field(default=1, description="The number of generated sequences to return.")
-    temperature: float = Field(default=1.0, description="Sampling temperature; higher values produce more random results.")
-    top_k: int = Field(default=50, description="Top-K sampling; restricts sampling to the top K tokens.")
-    top_p: float = Field(default=1.0, description="Top-p (nucleus) sampling; restricts sampling to tokens with cumulative probability >= top_p.")
-
-class TextGenerationModelActionConfig(CommonModelActionConfig):
-    prompt: str = Field(..., description="")
-    params: TextGenerationParamsConfig = Field(default_factory=TextGenerationParamsConfig, description="Text generation configuration parameters.")

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

@@ -1,15 +0,0 @@
-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: int = Field(default=1024, description="Maximum number of tokens per input text.")
-    max_output_length: int = Field(default=256, description="The maximum number of tokens to generate.")
-    min_output_length: int = Field(default=10, description="The minimum number of tokens to generate.")
-    num_beams: int = Field(default=4, description="")
-    length_penalty: float = Field(default=1.0, description="")
-
-class TranslationModelActionConfig(CommonModelActionConfig):
-    text: str = Field(..., description="")
-    params: TranslationParamsConfig = Field(default_factory=TranslationParamsConfig, description="Translation configuration parameters.")

model_compose-0.2.11/src/mindor/dsl/schema/component/impl/model/impl/types.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-class ModelTaskType(str, Enum):
-    TEXT_GENERATION = "text-generation"
-    SUMMARIZATION   = "summarization"
-    TRANSLATION     = "translation"
-    TEXT_EMBEDDING  = "text-embedding"