model-compose 0.4.8__tar.gz → 0.4.9__tar.gz

{model_compose-0.4.8/src/model_compose.egg-info → model_compose-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.8
+Version: 0.4.9
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.8 → model_compose-0.4.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.8"
+version = "0.4.9"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.8 → model_compose-0.4.9}/src/mindor/core/component/context.py

@@ -1,6 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.core.utils.renderers import VariableRenderer, ImageValueRenderer
 from mindor.core.gateway import find_gateway_by_port
+from PIL import Image as PILImage
 
 class ComponentActionContext:
     def __init__(self, run_id: str, input: Dict[str, Any]):
@@ -16,7 +17,7 @@ class ComponentActionContext:
     async def render_variable(self, value: Any, ignore_files: bool = False) -> Any:
         return await self.renderer.render(value, ignore_files)
 
-    async def render_image(self, value: Any) -> Any:
+    async def render_image(self, value: Any) -> Optional[PILImage.Image]:
         return await ImageValueRenderer().render(await self.render_variable(value))
 
     def contains_variable_reference(self, key: str, value: Any) -> bool:

{model_compose-0.4.8 → model_compose-0.4.9}/src/mindor/core/component/services/__init__.py

@@ -8,3 +8,4 @@ from .vector_store import *
 from .workflow import *
 from .shell import *
 from .text_splitter import *
+from .image_processor import *

{model_compose-0.4.8 → model_compose-0.4.9}/src/mindor/core/component/services/datasets/datasets.py

@@ -6,6 +6,7 @@ from mindor.dsl.schema.action import DatasetsActionConfig, DatasetsActionMethod,
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ...context import ComponentActionContext
 from .providers import HuggingfaceDatasetsProvider, LocalDatasetsProvider
+from .utils import format_template_example
 
 if TYPE_CHECKING:
     from datasets import Dataset
@@ -30,6 +31,9 @@ class DatasetsAction:
         if self.config.method == DatasetsActionMethod.SELECT:
             return await self._select(context)
 
+        if self.config.method == DatasetsActionMethod.MAP:
+            return await self._map(context)
+
         raise ValueError(f"Unsupported datasets action method: {self.config.method}")
 
     async def _load(self, context: ComponentActionContext) -> Dataset:
@@ -64,6 +68,10 @@ class DatasetsAction:
         info      = await context.render_variable(self.config.info)
         split     = await context.render_variable(self.config.split)
 
+        for dataset in datasets:
+            if not isinstance(dataset, Dataset):
+                raise ValueError(f"Expected Dataset instance, but got {type(dataset).__name__}")
+
         return concatenate_datasets(
             datasets,
             info=info,
@@ -77,6 +85,9 @@ class DatasetsAction:
         indices = await context.render_variable(self.config.indices)
         columns = await context.render_variable(self.config.columns)
 
+        if not isinstance(dataset, Dataset):
+            raise ValueError(f"Expected Dataset instance, but got {type(dataset).__name__}")
+
         if axis == "rows":
             if indices is None:
                 raise ValueError("indices must be provided when axis='rows'")
@@ -89,6 +100,20 @@ class DatasetsAction:
 
         raise ValueError(f"Unsupported axis: {axis}")
 
+    async def _map(self, context: ComponentActionContext) -> Dataset:
+        dataset        = await context.render_variable(self.config.dataset)
+        template       = await context.render_variable(self.config.template)
+        output_column  = await context.render_variable(self.config.output_column)
+        remove_columns = await context.render_variable(self.config.remove_columns)
+
+        if not isinstance(dataset, Dataset):
+            raise ValueError(f"Expected Dataset instance, but got {type(dataset).__name__}")
+
+        def format_example(example):
+            return { output_column: format_template_example(template, example) }
+
+        return dataset.map(format_example, remove_columns=remove_columns)
+
 @register_component(ComponentType.DATASETS)
 class DatasetsComponent(ComponentService):
     def __init__(self, id: str, config: DatasetsActionConfig, global_configs: ComponentGlobalConfigs, daemon: bool):

model_compose-0.4.9/src/mindor/core/component/services/datasets/utils.py

@@ -0,0 +1,12 @@
+from typing import Dict, List, Any
+import re
+
+def format_template_example(template: str, example: Dict[str, Any]) -> str:
+    column_names = set(re.findall(r"\{(\w+)\}", template))
+    formatted = template
+
+    for column in column_names:
+        if column in example:
+            formatted = formatted.replace(f"{{{column}}}", str(example[column]))
+
+    return formatted

model_compose-0.4.9/src/mindor/core/component/services/image_processor.py

@@ -0,0 +1,210 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ImageProcessorComponentConfig
+from mindor.dsl.schema.action import ActionConfig, ImageProcessorActionConfig, ImageProcessorActionMethod, ImageScaleMode, FlipDirection
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+from PIL import Image as PILImage, ImageFilter, ImageEnhance
+
+class ImageProcessorAction:
+    def __init__(self, config: ImageProcessorActionConfig):
+        self.config: ImageProcessorActionConfig = config
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        result = await self._dispatch(context)
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+    async def _dispatch(self, context: ComponentActionContext) -> Any:
+        if self.config.method == ImageProcessorActionMethod.RESIZE:
+            return await self._resize(context)
+
+        if self.config.method == ImageProcessorActionMethod.CROP:
+            return await self._crop(context)
+
+        if self.config.method == ImageProcessorActionMethod.ROTATE:
+            return await self._rotate(context)
+
+        if self.config.method == ImageProcessorActionMethod.FLIP:
+            return await self._flip(context)
+
+        if self.config.method == ImageProcessorActionMethod.GRAYSCALE:
+            return await self._grayscale(context)
+
+        if self.config.method == ImageProcessorActionMethod.BLUR:
+            return await self._blur(context)
+
+        if self.config.method == ImageProcessorActionMethod.SHARPEN:
+            return await self._sharpen(context)
+
+        if self.config.method == ImageProcessorActionMethod.ADJUST_BRIGHTNESS:
+            return await self._adjust_brightness(context)
+
+        if self.config.method == ImageProcessorActionMethod.ADJUST_CONTRAST:
+            return await self._adjust_contrast(context)
+
+        if self.config.method == ImageProcessorActionMethod.ADJUST_SATURATION:
+            return await self._adjust_saturation(context)
+
+        raise ValueError(f"Unsupported image processing action method: {self.config.method}")
+
+    async def _resize(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image      = await context.render_image(self.config.image)
+        width      = await context.render_variable(self.config.width) if self.config.width else None
+        height     = await context.render_variable(self.config.height) if self.config.height else None
+        scale_mode = await context.render_variable(self.config.scale_mode)
+
+        if width is None and height is None:
+            raise ValueError("At least one of width or height must be specified for resize")
+
+        if image:
+            return self._resize_image(image, width, height, scale_mode)
+        
+        return None
+
+    async def _crop(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        x      = await context.render_variable(self.config.x)
+        y      = await context.render_variable(self.config.y)
+        width  = await context.render_variable(self.config.width)
+        height = await context.render_variable(self.config.height)
+
+        if image:
+            return image.crop(x, y, x + width, y + height)
+        
+        return None
+
+    async def _rotate(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        angle  = await context.render_variable(self.config.angle)
+        expand = await context.render_variable(self.config.expand)
+
+        if image:
+            return image.rotate(-angle, expand=expand, resample=PILImage.Resampling.BICUBIC)
+
+        return None
+
+    async def _flip(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image     = await context.render_image(self.config.image)
+        direction = await context.render_variable(self.config.direction)
+
+        if image:
+            if direction == FlipDirection.HORIZONTAL:
+                return image.transpose(PILImage.Transpose.FLIP_LEFT_RIGHT)
+
+            if direction == FlipDirection.VERTICAL:
+                return image.transpose(PILImage.Transpose.FLIP_TOP_BOTTOM)
+
+        return None
+
+    async def _grayscale(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image = await context.render_image(self.config.image)
+
+        if image:
+            return image.convert("L")
+
+        return None
+
+    async def _blur(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        radius = await context.render_variable(self.config.radius)
+
+        if image:
+            return image.filter(ImageFilter.GaussianBlur(radius=radius))
+
+    async def _sharpen(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        factor = await context.render_variable(self.config.factor)
+
+        if image:
+            return ImageEnhance.Sharpness(image).enhance(factor)
+
+        return FileNotFoundError
+
+    async def _adjust_brightness(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        factor = await context.render_variable(self.config.factor)
+
+        if image:
+            return ImageEnhance.Brightness(image).enhance(factor)
+
+        return None
+
+    async def _adjust_contrast(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        factor = await context.render_variable(self.config.factor)
+
+        if image:
+            return ImageEnhance.Contrast(image).enhance(factor)
+
+        return image
+
+    async def _adjust_saturation(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        factor = await context.render_variable(self.config.factor)
+
+        if image:
+            return ImageEnhance.Color(image).enhance(factor)
+
+        return None
+
+    def _resize_image(self, image: PILImage.Image, width: int, height: int, scale_mode: str) -> PILImage.Image:
+        original_width, original_height = image.size
+        target_width  = width  or original_width
+        target_height = height or original_height
+
+        if scale_mode == ImageScaleMode.FIT:
+            new_width, new_height = self._get_size_aspect_fit(target_width, target_height, original_width, original_height)
+            return image.resize((new_width, new_height), PILImage.Resampling.LANCZOS)
+
+        if scale_mode == ImageScaleMode.FILL:
+            new_width, new_height = self._get_size_aspect_fill(target_width, target_height, original_width, original_height)
+            image = image.resize((new_width, new_height), PILImage.Resampling.LANCZOS)
+
+            crop_box = self._get_center_crop_box(new_width, new_height, target_width, target_height)
+            return image.crop(crop_box)
+
+        if scale_mode == ImageScaleMode.STRETCH:
+            return image.resize((target_width, target_height), PILImage.Resampling.LANCZOS)
+
+        raise ValueError(f"Invalid scale_mode: {scale_mode}")
+
+    def _get_size_aspect_fit(self, target_width: int, target_height: int, original_width: int, original_height: int) -> Tuple[int, int]:
+        aspect_ratio = original_width / original_height
+
+        height = target_height
+        width  = height * aspect_ratio
+
+        if width > target_width:
+            width  = target_width
+            height = width / aspect_ratio
+
+        return (int(width), int(height))
+
+    def _get_size_aspect_fill(self, target_width: int, target_height: int, original_width: int, original_height: int) -> Tuple[int, int]:
+        aspect_ratio = original_width / original_height
+
+        height = target_height
+        width  = height * aspect_ratio
+
+        if width < target_width:
+            width  = target_width
+            height = width / aspect_ratio
+
+        return (int(width), int(height))
+
+    def _get_center_crop_box(self, image_width: int, image_height: int, target_width: int, target_height: int) -> Tuple[int, int, int, int]:
+        left   = (image_width  - target_width ) // 2
+        top    = (image_height - target_height) // 2
+        right  = left + target_width
+        bottom = top + target_height
+
+        return (left, top, right, bottom)
+
+@register_component(ComponentType.IMAGE_PROCESSOR)
+class ImageProcessorComponent(ComponentService):
+    def __init__(self, id: str, config: ImageProcessorComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await ImageProcessorAction(action).run(context)

{model_compose-0.4.8 → model_compose-0.4.9}/src/mindor/core/component/services/model/base/huggingface.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
-from mindor.dsl.schema.component import ModelComponentConfig, HuggingfaceModelConfig, DeviceMode
+from mindor.dsl.schema.component import ModelComponentConfig, PeftAdapterConfig, HuggingfaceModelConfig, DeviceMode
 from mindor.core.logger import logging
 from .common import ModelTaskService
 
@@ -16,36 +16,95 @@ class HuggingfaceModelTaskService(ModelTaskService):
 
     def _load_pretrained_model(self) -> PreTrainedModel:
         model_cls = self._get_model_class()
-        model = model_cls.from_pretrained(self.config.model, **self._get_model_params())
+        model = model_cls.from_pretrained(self._get_model_path(self.config), **self._get_model_params(self.config))
+
+        if len(self.config.peft_adapters or []) > 0:
+            model = self._load_peft_adapters(model, self.config.peft_adapters)
 
         if self.config.device_mode == DeviceMode.SINGLE:
             model = model.to(torch.device(self.config.device))
 
         return model
 
+    def _load_peft_adapters(self, base_model: PreTrainedModel, adapter_configs: List[PeftAdapterConfig]) -> PreTrainedModel:
+        from peft import PeftModel
+
+        names, weights = self._build_peft_adapter_lists(adapter_configs)
+        peft_model = PeftModel.from_pretrained(
+            base_model,
+            self._get_model_path(adapter_configs[0]),
+            adapter_name=names[0],
+            **self._get_model_params(adapter_configs[0])
+        )
+
+        for index in range(1, len(adapter_configs)):
+            peft_model.load_adapter(
+                self._get_model_path(adapter_configs[index]),
+                adapter_name=names[index],
+                **self._get_model_params(adapter_configs[index])
+            )
+
+        multiple_adapters = len(adapter_configs) > 1
+        has_non_unit_weight = any(abs(weight - 1.0) > 1e-12 for weight in weights)
+
+        if multiple_adapters or has_non_unit_weight:
+            # Use add_weighted_adapter for merging multiple PEFT adapters with weights
+            # Note: This operation can be slow for large models (e.g., 7B+)
+            logging.info(f"Merging {len(names)} PEFT adapters with weights {weights}. This may take a while...")
+            peft_model.add_weighted_adapter(names, weights=weights, adapter_name="blended_adapter")
+            peft_model.set_adapter("blended_adapter")
+            logging.info("PEFT adapters merging completed.")
+        else:
+            peft_model.set_adapter(names[0])
+
+        return peft_model
+
+    def _build_peft_adapter_lists(self, adapter_configs: List[PeftAdapterConfig]) -> Tuple[List[str], List[float]]:
+        names: List[str] = []
+        weights: List[float] = []
+
+        for index, config in enumerate(adapter_configs):
+            names.append(config.name or f"peft_adapter_{index}")
+            weights.append(config.weight)
+
+        return names, weights
+
     def _get_model_class(self) -> Type[PreTrainedModel]:
         raise NotImplementedError("Model class loader not implemented.")
 
-    def _get_model_params(self) -> Dict[str, Any]:
+    def _get_model_path(self, config: Union[ModelComponentConfig, PeftAdapterConfig]) -> str:
+        if isinstance(config.model, HuggingfaceModelConfig):
+            return config.model.repository
+
+        return config.model.path
+
+    def _get_model_params(self, config: Union[ModelComponentConfig, PeftAdapterConfig]) -> Dict[str, Any]:
         params: Dict[str, Any] = {}
 
-        if isinstance(self.config.model, HuggingfaceModelConfig):
-            if self.config.model.revision:
-                params["revision"] = self.config.model.revision
+        if isinstance(config.model, HuggingfaceModelConfig):
+            if config.model.filename:
+                params["filename"] = config.model.filename
+
+            if config.model.revision:
+                params["revision"] = config.model.revision
             
-            if self.config.model.cache_dir:
-                params["cache_dir"] = self.config.model.cache_dir
+            if config.model.cache_dir:
+                params["cache_dir"] = config.model.cache_dir
 
-            if self.config.model.local_files_only:
+            if config.model.local_files_only:
                 params["local_files_only"] = True
+            
+            if config.model.token:
+                params["token"] = config.model.token
 
-        if self.config.device_mode != DeviceMode.SINGLE:
-            params["device_map"] = self.config.device_mode.value
+        if not isinstance(config, PeftAdapterConfig):
+            if config.device_mode != DeviceMode.SINGLE:
+                params["device_map"] = config.device_mode.value
     
-        if self.config.precision is not None:
-            params["torch_dtype"] = getattr(torch, self.config.precision.value)
+        if config.precision is not None:
+            params["torch_dtype"] = getattr(torch, config.precision.value)
     
-        if self.config.low_cpu_mem_usage:
+        if config.low_cpu_mem_usage:
             params["low_cpu_mem_usage"] = True
 
         return params
@@ -62,8 +121,9 @@ class HuggingfaceLanguageModelTaskService(HuggingfaceModelTaskService):
         self.device: Optional[torch.device] = None
 
     def get_setup_requirements(self) -> Optional[List[str]]:
-        return [ 
+        return [
             "transformers>=4.21.0",
+            "peft>=0.5.0",
             "torch",
             "sentencepiece",
             "accelerate"
@@ -86,11 +146,21 @@ class HuggingfaceLanguageModelTaskService(HuggingfaceModelTaskService):
 
     def _load_pretrained_tokenizer(self) -> Optional[PreTrainedTokenizer]:
         tokenizer_cls = self._get_tokenizer_class()
+        tokenizer = tokenizer_cls.from_pretrained(self._get_model_path(self.config), **self._get_tokenizer_params())
 
-        if not tokenizer_cls:
-            return None
+        if tokenizer.pad_token is None:
+            logging.info("Tokenizer does not have a pad_token defined. Configuring pad_token automatically.")
+            self._configure_missing_pad_token(tokenizer)
 
-        return tokenizer_cls.from_pretrained(self.config.model, **self._get_tokenizer_params())
+        return tokenizer
+
+    def _configure_missing_pad_token(self, tokenizer: PreTrainedTokenizer) -> None:
+        if tokenizer.eos_token is not None:
+            tokenizer.pad_token = tokenizer.eos_token
+            logging.info(f"Set pad_token to eos_token: {tokenizer.eos_token}")
+        else:
+            tokenizer.add_special_tokens({ "pad_token": "[PAD]" })
+            logging.info("Added new pad_token: [PAD]")
 
     def _get_tokenizer_class(self) -> Optional[Type[PreTrainedTokenizer]]:
         return None
@@ -108,6 +178,9 @@ class HuggingfaceLanguageModelTaskService(HuggingfaceModelTaskService):
             if self.config.model.local_files_only:
                 params["local_files_only"] = True
 
+            if self.config.model.token:
+                params["token"] = self.config.model.token
+
         if not self.config.fast_tokenizer:
             params["use_fast"] = False
 
@@ -150,7 +223,7 @@ class HuggingfaceMultimodalModelTaskService(HuggingfaceModelTaskService):
         if not processor_cls:
             return None
 
-        return processor_cls.from_pretrained(self.config.model, **self._get_processor_params())
+        return processor_cls.from_pretrained(self._get_model_path(self.config), **self._get_processor_params())
 
     def _get_processor_class(self) -> Optional[Type[ProcessorMixin]]:
         return None
@@ -161,11 +234,14 @@ class HuggingfaceMultimodalModelTaskService(HuggingfaceModelTaskService):
         if isinstance(self.config.model, HuggingfaceModelConfig):
             if self.config.model.revision:
                 params["revision"] = self.config.model.revision
- 
+
             if self.config.model.cache_dir:
                 params["cache_dir"] = self.config.model.cache_dir
 
             if self.config.model.local_files_only:
                 params["local_files_only"] = True
 
+            if self.config.model.token:
+                params["token"] = self.config.model.token
+
         return params

{model_compose-0.4.8 → model_compose-0.4.9}/src/mindor/core/component/services/model/tasks/chat_completion/huggingface.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from mindor.dsl.schema.action import ModelActionConfig, ChatCompletionModelActionConfig
+from mindor.dsl.schema.action import ModelActionConfig, ChatCompletionModelActionConfig, ToolFunction
 from ...base import ModelTaskType, ModelDriver, register_model_task_service
 from ...base import HuggingfaceLanguageModelTaskService, ComponentActionContext
 from ..text_generation import HuggingfaceTextGenerationTaskAction
@@ -20,13 +20,23 @@ class HuggingfaceChatCompletionTaskAction(HuggingfaceTextGenerationTaskAction):
 
     async def _prepare_input(self, context: ComponentActionContext) -> Union[str, List[str]]:
         messages = await context.render_variable(self.config.messages)
+        tools    = await context.render_variable(self.config.tools)
+
+        tools = [ self._build_tool_definition(tool) for tool in tools ] if tools else None
 
         return self.tokenizer.apply_chat_template(
             messages,
             tokenize=False,
-            add_generation_prompt=True
+            add_generation_prompt=True,
+            **({ "tools": tools } if tools else {})
         )
 
+    def _build_tool_definition(self, tool: Dict[str, Any]) -> Dict[str, Any]:
+        return {
+            "type": "function",
+            "function": { k: v for k, v in tool.items() if v is not None }
+        }
+
 @register_model_task_service(ModelTaskType.CHAT_COMPLETION, ModelDriver.HUGGINGFACE)
 class HuggingfaceChatCompletionTaskService(HuggingfaceLanguageModelTaskService):
     async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:

{model_compose-0.4.8 → model_compose-0.4.9}/src/mindor/core/component/services/model/tasks/face_embedding/common.py

@@ -36,7 +36,7 @@ class FaceEmbeddingTaskAction:
         return await context.render_image(self.config.image)
 
     @abstractmethod
-    async def _embed(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
+    async def _embed(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[List[float]]:
         pass
 
     @abstractmethod

{model_compose-0.4.8 → model_compose-0.4.9}/src/mindor/core/component/services/model/tasks/face_embedding/insightface.py

@@ -8,7 +8,7 @@ from mindor.core.logger import logging
 from .common import FaceEmbeddingTaskService, FaceEmbeddingTaskAction
 from ...base import ComponentActionContext
 from PIL import Image as PILImage
-import asyncio, os
+import asyncio, os, shutil
 
 if TYPE_CHECKING:
     from insightface.app import FaceAnalysis
@@ -20,15 +20,14 @@ class InsightfaceFaceEmbeddingTaskAction(FaceEmbeddingTaskAction):
 
         self.model: FaceAnalysis = model
 
-    async def _embed(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[Tensor]:
+    async def _embed(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[List[float]]:
         import numpy as np
         import cv2
 
         embeddings = []
         for image in images:
             image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-            for face in self.model.get(image_cv):
-                embeddings.append(face.embedding)
+            embeddings.append([ face.embedding.tolist() for face in self.model.get(image_cv) ])
 
         return embeddings
 
@@ -55,35 +54,54 @@ class InsightfaceFaceEmbeddingTaskService(FaceEmbeddingTaskService):
     def _load_pretrained_model(self) -> FaceAnalysis:
         from insightface.app import FaceAnalysis
 
-        model = FaceAnalysis(**self._resolve_model_params())
+        params = self._resolve_model_params()
+
+        try:
+            model = FaceAnalysis(**params)
+        except:
+            self._fix_wrong_model_path(params)
+            model = FaceAnalysis(**params)
+
         model.prepare(ctx_id=self._get_device_id())
 
         return model
 
     def _resolve_model_params(self) -> Dict[str, Any]:
-        if isinstance(self.config.model, LocalModelConfig):
-            path = os.path.dirname(self.config.model.path)
-
-            if os.path.basename(path) != "models":
-                raise ValueError(f"Expected 'models' directory in path, got: {path}")
-
-            return { 
-                "name": os.path.basename(self.config.model.path),
-                "root": os.path.dirname(path)
-            }
-
-        if isinstance(self.config.model, str):
-            path = os.path.dirname(self.config.model)
+        if isinstance(self.config.model, (LocalModelConfig, str)):
+            if isinstance(self.config.model, LocalModelConfig):
+                # TODO: process local storage
+                path = self.config.model.path
+            else:
+                path = self.config.model
 
-            if os.path.basename(path) != "models":
-                raise ValueError(f"Expected 'models' directory in path, got: {path}")
+            root, name = self._prepare_model_path(path)
 
-            return { 
-                "name": os.path.basename(self.config.model),
-                "root": os.path.dirname(path)
-            }
+            return { "name": name, "root": root }
 
         raise ValueError(f"Unsupported model type: {type(self.config.model)}")
+    
+    def _prepare_model_path(self, path: str) -> Tuple[str, str]:
+        root = os.path.dirname(path)
+        name = os.path.basename(path)
+
+        if os.path.basename(root) != "models":
+            models_dir = os.path.join(root, "models")
+            if not os.path.exists(models_dir):
+                os.symlink(root, models_dir, target_is_directory=True)
+        else:
+            root = os.path.dirname(root)
+
+        return (root, name)
+    
+    def _fix_wrong_model_path(self, params: Dict[str, Any]) -> None:
+        root, name = params["root"], params["name"]
+        model_dir = os.path.join(root, "models", name)
+        wrong_model_dir = os.path.join(model_dir, name)
+
+        if os.path.isdir(wrong_model_dir):
+            for file in os.listdir(wrong_model_dir):
+                shutil.move(os.path.join(wrong_model_dir, file), os.path.join(model_dir, file))
+            os.rmdir(wrong_model_dir)
 
     def _get_device_id(self) -> int:
         return 0