aiauto-client 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

aiauto/__init__.py

@@ -1,5 +1,4 @@
 from .core import AIAutoController, TrialController, CallbackTopNArtifact, StudyWrapper
-from .api import create_study
 from ._config import AIAUTO_API_TARGET
 from .constants import RUNTIME_IMAGES
 
@@ -10,7 +9,6 @@ __all__ = [
     'TrialController', 
     'CallbackTopNArtifact',
     'StudyWrapper',
-    'create_study',
     'AIAUTO_API_TARGET',
     'RUNTIME_IMAGES',
 ]

aiauto/constants.py

@@ -9,20 +9,15 @@ RUNTIME_IMAGES = [
     "ghcr.io/astral-sh/uv:python3.10-bookworm-slim",
     "ghcr.io/astral-sh/uv:python3.11-bookworm-slim",
     "ghcr.io/astral-sh/uv:python3.12-bookworm-slim",
-    
+
     # GPU Images (PyTorch)
     "pytorch/pytorch:2.1.0-cuda11.8-cudnn8-runtime",
     "pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime",
     "pytorch/pytorch:2.4.0-cuda12.4-cudnn9-runtime",
-    
+
     # GPU Images (TensorFlow)
     "tensorflow/tensorflow:2.15.0-gpu",
-    "tensorflow/tensorflow:2.15.0-gpu-jupyter",
-    
-    # JAX Images
-    "nvcr.io/nvidia/jax:23.10-py3",
-    "nvcr.io/nvidia/jax:24.04-py3",
-    
+
     # Custom/Legacy images
-    "ghcr.io/01ai/zipline:latest",  # Custom zipline trading library
-]
+    "registry.gitlab.com/01ai/eng/aiauto/aiauto/zipline-prepared:main-v00.00.01-amd64-11ca2c41-250901",
+]

aiauto/core.py

@@ -3,7 +3,7 @@ import tempfile
 from typing import Union, Optional, List, Dict, Callable
 import optuna
 from .http_client import ConnectRPCClient
-from .serializer import serialize, build_requirements
+from .serializer import serialize, build_requirements, object_to_json
 from ._config import AIAUTO_API_TARGET
 
 
@@ -25,15 +25,15 @@ class AIAutoController:
         # EnsureWorkspace 호출해서 journal_grpc_storage_proxy_host_external 받아와서 storage 초기화
         try:
             response = self.client.call_rpc("EnsureWorkspace", {})
-            
+
             # 받아온 journal_grpc_storage_proxy_host_external로 storage 초기화
             host_external = response.get('journalGrpcStorageProxyHostExternal', '')
             if not host_external:
                 raise RuntimeError("No storage host returned from EnsureWorkspace")
-            
+
             host, port = host_external.split(':')
             self.storage = optuna.storages.GrpcStorageProxy(host=host, port=int(port))
-            
+
             # Store the internal host for CRD usage (if needed later)
             self.storage_host_internal = response.get('journalGrpcStorageProxyHostInternal', '')
             self.dashboard_url = response.get('dashboardUrl', '')
@@ -62,6 +62,46 @@ class AIAutoController:
     def get_artifact_tmp_dir(self):
         return self.tmp_dir
 
+    def create_study(
+        self,
+        study_name: str,
+        direction: Optional[str] = 'minimize',
+        directions: Optional[List[str]] = None,
+        sampler: Union[object, dict, None] = None,
+        pruner: Union[object, dict, None] = None
+    ) -> 'StudyWrapper':
+        """Create a new study using the controller's token."""
+        if not direction and not directions:
+            raise ValueError("Either 'direction' or 'directions' must be specified")
+
+        if direction and directions:
+            raise ValueError("Cannot specify both 'direction' and 'directions'")
+
+        try:
+            # Prepare request data for CreateStudy
+            request_data = {
+                "spec": {
+                    "studyName": study_name,
+                    "direction": direction or "",
+                    "directions": directions or [],
+                    "samplerJson": object_to_json(sampler),
+                    "prunerJson": object_to_json(pruner)
+                }
+            }
+
+            # Call CreateStudy RPC
+            response = self.client.call_rpc("CreateStudy", request_data)
+
+            # Return StudyWrapper
+            return StudyWrapper(
+                study_name=response.get("studyName", study_name),
+                storage=self.storage,
+                controller=self
+            )
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to create study: {e}") from e
+
 
 class TrialController:
     def __init__(self, trial: optuna.trial.Trial):
@@ -144,15 +184,20 @@ class StudyWrapper:
     def optimize(
         self,
         objective: Callable,
-        n_trials: int,
-        parallelism: int,
+        n_trials: int = 10,
+        parallelism: int = 2,
         requirements_file: Optional[str] = None,
         requirements_list: Optional[List[str]] = None,
-        resources_requests: Optional[Dict[str, str]] = None,
-        resources_limits: Optional[Dict[str, str]] = None,
-        runtime_image: Optional[str] = None,
+        resources_requests: Optional[Dict[str, str]] = {"cpu": "256m", "memory": "256Mi"},
+        resources_limits: Optional[Dict[str, str]] = {"cpu": "256m", "memory": "256Mi"},
+        runtime_image: Optional[str] = 'ghcr.io/astral-sh/uv:python3.8-bookworm-slim',
         use_gpu: bool = False
     ) -> None:
+        if runtime_image is None or runtime_image == "":
+            if use_gpu:
+                runtime_image = "pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime"
+            else:
+                runtime_image = "ghcr.io/astral-sh/uv:python3.8-bookworm-slim"
         try:
             request_data = {
                 "objective": {
@@ -169,7 +214,7 @@ class StudyWrapper:
                     "useGpu": use_gpu
                 }
             }
-            
+
             self._controller.client.call_rpc("Optimize", request_data)
 
         except Exception as e:
@@ -178,10 +223,10 @@ class StudyWrapper:
     def get_status(self) -> dict:
         try:
             response = self._controller.client.call_rpc(
-                "GetStatus", 
+                "GetStatus",
                 {"studyName": self.study_name}
             )
-            
+
             # Convert camelCase to snake_case for backward compatibility
             return {
                 "study_name": response.get("studyName", ""),
@@ -200,4 +245,4 @@ class StudyWrapper:
             raise RuntimeError(f"Failed to get status: {e}") from e
 
     def __repr__(self) -> str:
-        return f"StudyWrapper(study_name='{self.study_name}', storage={self._storage})"
+        return f"StudyWrapper(study_name='{self.study_name}', storage={self._storage})"

aiauto_client-0.1.6.dist-info/METADATA

@@ -0,0 +1,439 @@
+Metadata-Version: 2.1
+Name: aiauto-client
+Version: 0.1.6
+Summary: AI Auto HPO (Hyperparameter Optimization) Client Library
+Author-email: AIAuto Team <ainode@zeroone.ai>
+Project-URL: Homepage, https://dashboard.aiauto.pangyo.ainode.ai
+Project-URL: Repository, https://dashboard.aiauto.pangyo.ainode.ai
+Project-URL: Documentation, https://dashboard.aiauto.pangyo.ainode.ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: optuna>=3.0.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: grpcio>=1.48.0
+Requires-Dist: grpcio-status>=1.48.0
+
+# AIAuto - Hyperparameter Optimization Client Library
+
+AIAuto는 Kubernetes 기반의 분산 HPO(Hyperparameter Optimization) 시스템을 위한 클라이언트 라이브러리입니다.
+사용자 python lib <-> Next.js 서버 사이 Connect RPC (HTTP/1.1) 통신 담당
+
+## 설치
+- `pip install aiauto-client optuna`
+
+## API 레퍼런스
+
+### create_study 파라미터
+- `study_name` (str): Study 이름
+- `direction` (str): 단일 목적 최적화 방향 ("minimize" 또는 "maximize")
+- `directions` (List[str]): 다중 목적 최적화 방향 리스트 (direction과 상호 배타적)
+- `sampler` (object/dict): Optuna sampler 객체 또는 dict (선택적)
+- `pruner` (object/dict): Optuna pruner 객체 또는 dict (선택적)
+
+**주의**: `direction`과 `directions`는 둘 중 하나만 지정해야 합니다.
+
+### optimize 파라미터
+- `objective` (Callable): Trial을 인자로 받는 목적 함수
+- `n_trials` (int): 총 trial 수
+- `parallelism` (int): 동시 실행 Pod 수 (기본값: 2)
+- `requirements_file` (str): requirements.txt 파일 경로 (requirements_list와 상호 배타적)
+- `requirements_list` (List[str]): 패키지 리스트 (requirements_file과 상호 배타적)
+- `resources_requests` (Dict[str, str]): K8s 리소스 요청 (기본값: {"cpu": "256m", "memory": "256Mi"})
+- `resources_limits` (Dict[str, str]): K8s 리소스 제한 (기본값: {"cpu": "256m", "memory": "256Mi"})
+- `runtime_image` (str): 커스텀 런타임 이미지 (None이면 자동 선택)
+- `use_gpu` (bool): GPU 사용 여부 (기본값: False)
+
+**주의**: `requirements_file`과 `requirements_list`는 둘 중 하나만 지정해야 합니다.
+
+## 지원 런타임 이미지 확인
+```python
+import aiauto
+
+# 사용 가능한 이미지 확인
+for image in aiauto.RUNTIME_IMAGES:
+    print(image)
+```
+
+## 실행 흐름
+### token 발급 # TODO
+- `https://dashboard.aiauto.pangyo.ainode.ai` 에 접속하여 ainode 에 로그인 한 후
+- `https://dashboard.aiauto.pangyo.ainode.ai/token` 으로 이동하여 aiauto 의 token 을 발급
+- 아래 코드 처럼 발급한 token 을 넣어 AIAutoController singleton 객체를 초기화, OptunaWorkspace 를 활성화 시킨다
+```python
+import aiauto
+
+ac = aiauto.AIAutoController('<token>')
+```
+- `https://dashboard.aiauto.pangyo.ainode.ai/workspace` 에서 생성된 OptunaWorkspace 와 optuna-dashboard 링크를 확인할 수 있음
+- 아래 코드 처럼 study 를 생성하면 `https://dashboard.aiauto.pangyo.ainode.ai/study` 에서 확인할 수 있고 optuna-dashboard 링크에서도 확인 가능 
+```python
+study_wrapper = ac.create_study(
+    study_name='test',
+    direction='maximize',  # or 'minimize'
+)
+```
+- 아래 코드 처럼 생성한 study 애서 objective 함수를 작성하여 넘겨주면 optimize 를 호출하면 `https://dashboard.aiauto.pangyo.ainode.ai/trialbatch` 에서 확인할 수 있고 optuna-dashboard 링크에서도 확인 가능
+```python
+study_wrapper.optimize(
+    objective=func_with_parameter_trial,
+    n_trials=4,
+    parallelism=2,
+    use_gpu=False,
+    runtime_image=aiauto.RUNTIME_IMAGES[0],
+)
+```
+
+## 빠른 시작
+
+### 1. 간단한 예제 (수학 함수 최적화)
+
+```python
+import optuna
+import aiauto
+
+
+# `https://dashboard.aiauto.pangyo.ainode.ai` 에 접속하여 ainode 에 로그인 한 후 aiauto 의 token 을 발급
+# AIAutoController singleton 객체를 초기화 하여, OptunaWorkspace 를 활성화 시킨다 (토큰은 한 번만 설정)
+ac = aiauto.AIAutoController('<token>')
+# `https://dashboard.aiauto.pangyo.ainode.ai/workspace` 에서 생성된 OptunaWorkspace 와 optuna-dashboard 링크를 확인할 수 있음
+
+# StudyWrapper 생성
+study_wrapper = ac.create_study(
+    study_name="simple_optimization",
+    direction="minimize"
+    # sampler=optuna.samplers.TPESampler(),  # optuna 에서 제공하는 sampler 그대로 사용 가능, 참고 https://optuna.readthedocs.io/en/stable/reference/samplers/index.html
+)
+# `https://dashboard.aiauto.pangyo.ainode.ai/study` 에서 생성된 study 확인 가능
+
+# objective 함수 정의
+def objective(trial: optuna.trial.Trial):
+    """실제 실행은 사용자 로컬 컴퓨터가 아닌 서버에서 실행 될 함수"""
+    x = trial.suggest_float('x', -10, 10)
+    y = trial.suggest_float('y', -10, 10)
+    return (x - 2) ** 2 + (y - 3) ** 2
+
+# 사용자 모델 학습 or 최적화 실행 (서버에서 병렬 실행)
+study_wrapper.optimize(
+    objective,
+    n_trials=100,
+    parallelism=4  # 동시 실행 Pod 수
+)
+# `https://dashboard.aiauto.pangyo.ainode.ai/workspace` 에서 생성된 optuna-dashboard 링크에서 결과 확인 가능
+```
+
+### 2. PyTorch 모델 최적화 (Single Objective)
+
+```python
+import optuna
+import aiauto
+
+
+# `https://dashboard.aiauto.pangyo.ainode.ai` 에 접속하여 ainode 에 로그인 한 후 aiauto 의 token 을 발급
+# AIAutoController singleton 객체를 초기화 하여, OptunaWorkspace 를 활성화 시킨다 (토큰은 한 번만 설정)
+ac = aiauto.AIAutoController('<token>')
+# `https://dashboard.aiauto.pangyo.ainode.ai/workspace` 에서 생성된 OptunaWorkspace 와 optuna-dashboard 링크를 확인할 수 있음
+
+# StudyWrapper 생성
+study_wrapper = ac.create_study(
+    study_name="pytorch_optimization",
+    direction="minimize",
+    # sampler=optuna.samplers.TPESampler(),  # optuna 에서 제공하는 sampler 그대로 사용 가능, 참고 https://optuna.readthedocs.io/en/stable/reference/samplers/index.html
+    pruner=optuna.pruners.PatientPruner(  # optuna 에서 제공하는 pruner 그대로 사용 가능, 참고 https://optuna.readthedocs.io/en/stable/reference/pruners.html
+        optuna.pruners.MedianPruner(),
+        patience=4,
+    ),
+)
+# `https://dashboard.aiauto.pangyo.ainode.ai/study` 에서 생성된 study 확인 가능
+
+# objective 함수 정의
+# https://docs.pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html 참고
+def objective(trial: optuna.trial.Trial):
+    """
+    실제 실행은 사용자 로컬 컴퓨터가 아닌 서버에서 실행 될 함수
+    모든 import는 함수 내부에 존재해야 함
+    """
+    import torch
+    from torch import nn, optim
+    from torch.utils.data import DataLoader, random_split, Subset
+    from torchvision import transforms, datasets
+    import torch.nn.functional as F
+
+    # 하이퍼파라미터 샘플링
+    lr = trial.suggest_float('learning_rate', 1e-5, 1e-1, log=True)
+    momentom = trial.suggest_float('momentom', 0.1, 0.99)
+    batch_size = trial.suggest_categorical('batch_size', [16, 32, 64, 128])
+    epochs = trial.suggest_int('epochs', 10, 100, step=10)
+    
+    # 모델 정의
+    class Net(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.conv1 = nn.Conv2d(3, 6, 5)
+            self.pool = nn.MaxPool2d(2, 2)
+            self.conv2 = nn.Conv2d(6, 16, 5)
+            self.fc1 = nn.Linear(16 * 5 * 5, 120)
+            self.fc2 = nn.Linear(120, 84)
+            self.fc3 = nn.Linear(84, 10)
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = torch.flatten(x, 1) # flatten all dimensions except batch
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x 
+    
+    # 모델 정의 및 학습 (GPU 자동 사용)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model = Net().to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentom)
+    
+    # 데이터 로드
+    train_set = datasets.CIFAR10(
+        root="/tmp/cifar10_data",  # Pod의 임시 디렉토리 사용
+        train=True,
+        download=True,
+        transform=[
+            transforms.ToTensor(),
+            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+        ],
+    )
+    train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=2)
+
+    test_set = datasets.CIFAR10(
+        root="/tmp/cifar10_data",  # Pod의 임시 디렉토리 사용
+        train=False,
+        download=True,
+        transform=[
+            transforms.ToTensor(),
+            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+        ],
+    )
+    test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=True, num_workers=2)
+    
+    # 학습
+    min_epochs_for_pruning = max(50, epochs // 5)  # 최소 50 epoch 또는 전체의 1/5 후부터 pruning
+    total_loss = 0.0
+    for epoch in range(epochs):  # loop over the dataset multiple times
+        running_loss = 0.0
+        model.train()
+        for i, (inputs, targets) in enumerate(train_loader, 0):
+            inputs, targets = inputs.to(device), targets.to(device)
+            # zero the parameter gradients
+            optimizer.zero_grad()
+            # forward + backward + optimize
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+    
+            # print statistics
+            running_loss += loss.item()
+            if i % 2000 == 1999:    # print every 2000 mini-batches
+                print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
+        
+        # intermediate result 보고 및 초기 중단 검사 - 최소 epochs 후 부터만 pruning
+        trial.report(running_loss, epoch)
+        total_loss += running_loss
+        if epoch >= min_epochs_for_pruning and trial.should_prune():
+            raise optuna.TrialPruned()
+        
+    return total_loss
+
+# GPU Pod에서 실행
+study_wrapper.optimize(
+    objective,
+    n_trials=100,
+    parallelism=4,
+    use_gpu=True,  # GPU 사용
+    requirements_list=['torch', 'torchvision']  # Pod에서 자동 설치
+)
+```
+
+### 3. Multi-Objective 최적화 (Accuracy + FLOPS)
+
+```python
+import optuna
+import aiauto
+
+
+# `https://dashboard.aiauto.pangyo.ainode.ai` 에 접속하여 ainode 에 로그인 한 후 aiauto 의 token 을 발급
+# AIAutoController singleton 객체를 초기화 하여, OptunaWorkspace 를 활성화 시킨다 (토큰은 한 번만 설정)
+ac = aiauto.AIAutoController('<token>')
+# `https://dashboard.aiauto.pangyo.ainode.ai/workspace` 에서 생성된 OptunaWorkspace 와 optuna-dashboard 링크를 확인할 수 있음
+
+# StudyWrapper 생성
+study_wrapper = ac.create_study(
+    study_name="pytorch_multiple_optimization",
+    direction=["minimize", "minimize"],  # loss minimize, FLOPS minimize
+    # sampler=optuna.samplers.TPESampler(),  # optuna 에서 제공하는 sampler 그대로 사용 가능, 참고 https://optuna.readthedocs.io/en/stable/reference/samplers/index.html
+)
+# `https://dashboard.aiauto.pangyo.ainode.ai/study` 에서 생성된 study 확인 가능
+
+# objective 함수 정의
+# https://docs.pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html 참고
+def objective(trial: optuna.trial.Trial):
+    """
+    실제 실행은 사용자 로컬 컴퓨터가 아닌 서버에서 실행 될 함수
+    모든 import는 함수 내부에 존재해야 함
+    """
+    import torch
+    from torch import nn, optim
+    from torch.utils.data import DataLoader, random_split, Subset
+    from torchvision import transforms, datasets
+    import torch.nn.functional as F
+    from fvcore.nn import FlopCountAnalysis
+
+    # 하이퍼파라미터 샘플링
+    lr = trial.suggest_float('learning_rate', 1e-5, 1e-1, log=True)
+    momentom = trial.suggest_float('momentom', 0.1, 0.99)
+    batch_size = trial.suggest_categorical('batch_size', [16, 32, 64, 128])
+    epochs = trial.suggest_int('epochs', 10, 100, step=10)
+
+    # 모델 정의
+    class Net(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.conv1 = nn.Conv2d(3, 6, 5)
+            self.pool = nn.MaxPool2d(2, 2)
+            self.conv2 = nn.Conv2d(6, 16, 5)
+            self.fc1 = nn.Linear(16 * 5 * 5, 120)
+            self.fc2 = nn.Linear(120, 84)
+            self.fc3 = nn.Linear(84, 10)
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = torch.flatten(x, 1) # flatten all dimensions except batch
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+        # 모델 정의 및 학습 (GPU 자동 사용)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model = Net().to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentom)
+
+    # 데이터 로드
+    train_set = datasets.CIFAR10(
+        root="/tmp/cifar10_data",  # Pod의 임시 디렉토리 사용
+        train=True,
+        download=True,
+        transform=[
+            transforms.ToTensor(),
+            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+        ],
+    )
+    train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=2)
+
+    test_set = datasets.CIFAR10(
+        root="/tmp/cifar10_data",  # Pod의 임시 디렉토리 사용
+        train=False,
+        download=True,
+        transform=[
+            transforms.ToTensor(),
+            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+        ],
+    )
+    test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=True, num_workers=2)
+
+    # 학습
+    total_loss = 0.0
+    # multiple objective 는 pruning 미지원
+    for epoch in range(epochs):  # loop over the dataset multiple times
+        running_loss = 0.0
+        model.train()
+        for i, (inputs, targets) in enumerate(train_loader, 0):
+            inputs, targets = inputs.to(device), targets.to(device)
+            # zero the parameter gradients
+            optimizer.zero_grad()
+            # forward + backward + optimize
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+
+            # print statistics
+            running_loss += loss.item()
+            if i % 2000 == 1999:    # print every 2000 mini-batches
+                print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
+
+        # multiple objective 는 pruning 미지원
+    
+    # FLOPS 계산
+    dummy_input = torch.randn(1, 3, 32, 32).to(device)
+    flops = FlopCountAnalysis(model, (dummy_input,)).total()
+        
+    return total_loss, flops
+
+# GPU Pod에서 실행
+study_wrapper.optimize(
+    objective,
+    n_trials=100,
+    parallelism=4,
+    use_gpu=True,  # GPU 사용
+    requirements_list=['torch', 'torchvision', 'fvcore']  # Pod에서 자동 설치
+)
+```
+
+### 4. Ask/Tell 패턴 및 Optuna 자체의 Study
+
+```python
+import optuna
+import aiauto
+
+# `https://dashboard.aiauto.pangyo.ainode.ai` 에 접속하여 ainode 에 로그인 한 후 aiauto 의 token 을 발급
+# AIAutoController singleton 객체를 초기화 하여, OptunaWorkspace 를 활성화 시킨다 (토큰은 한 번만 설정)
+ac = aiauto.AIAutoController('<token>')
+# `https://dashboard.aiauto.pangyo.ainode.ai/workspace` 에서 생성된 OptunaWorkspace 와 optuna-dashboard 링크를 확인할 수 있음 
+
+# Study 생성
+study_wrapper = ac.create_study(
+    study_name="test",
+    direction='minimize',
+    # sampler=optuna.samplers.TPESampler(),  # optuna 에서 제공하는 sampler 그대로 사용 가능, 참고 https://optuna.readthedocs.io/en/stable/reference/samplers/index.html
+    # pruner=optuna.pruners.PatientPruner(  # optuna 에서 제공하는 pruner 그대로 사용 가능, 참고 https://optuna.readthedocs.io/en/stable/reference/pruners.html
+    #     optuna.pruners.MedianPruner(),
+    #     patience=4,
+    # )
+)
+# `https://dashboard.aiauto.pangyo.ainode.ai/study` 에서 생성된 study 확인 가능
+
+# 실제 optuna.Study 객체 획득 (로컬에서 ask/tell 가능)
+study = study_wrapper.get_study()
+
+# Ask/Tell 패턴으로 최적화
+trial = study.ask()
+
+# 파라미터 최적화
+x = trial.suggest_float('x', -10, 10)
+y = trial.suggest_float('y', -10, 10)
+
+# 사용자 모델 학습 or 최적화 실행 (서버에서 병렬 실행)
+ret = (x - 2) ** 2 + (y - 3) ** 2
+
+# 결과 보고
+study.tell(trial, ret)
+# `https://dashboard.aiauto.pangyo.ainode.ai/workspace` 에서 생성된 optuna-dashboard 링크에서 결과 확인 가능
+```
+
+# lib build
+```bash
+make build push
+```

aiauto_client-0.1.6.dist-info/RECORD

@@ -0,0 +1,10 @@
+aiauto/__init__.py,sha256=sF7sJaXg7-MqolSYLxsaXAir1dBzARhXLrHo7zLsupg,345
+aiauto/_config.py,sha256=DaRTIZlph9T3iuW-Cy4fkw8i3bXB--gMtW947SLZZNs,159
+aiauto/constants.py,sha256=rBibGOQHHrdkwaai92-3I8-N0cu-B4CoCoQbG9-Cl8k,821
+aiauto/core.py,sha256=DQW9uvVNqP9J9s1IFx969upw10NQLHJMNsudHnauk6A,9840
+aiauto/http_client.py,sha256=t1gxeM5-d5bsVoFWgaNcTrt_WWUXuMuxge9gDlEqhoA,2086
+aiauto/serializer.py,sha256=_iPtEoqW8RTKOZ6UrC7CzOqoangpPYzeL7MQfIdmov8,1568
+aiauto_client-0.1.6.dist-info/METADATA,sha256=FOC7h1MkE6dlPa7urKnWX2sIUqe3Ac40TJNC1JgFzu4,17487
+aiauto_client-0.1.6.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+aiauto_client-0.1.6.dist-info/top_level.txt,sha256=Sk2ctO9_Bf_tAPwq1x6Vfl6OuL29XzwMTO4F_KG6oJE,7
+aiauto_client-0.1.6.dist-info/RECORD,,

aiauto/api.py

@@ -1,46 +0,0 @@
-from typing import Optional, List, Union
-from .serializer import object_to_json
-from .core import StudyWrapper, AIAutoController
-
-
-def create_study(
-    study_name: str,
-    token: str,
-    direction: Optional[str] = None,
-    directions: Optional[List[str]] = None,
-    sampler: Union[object, dict, None] = None,
-    pruner: Union[object, dict, None] = None
-) -> StudyWrapper:
-    if not direction and not directions:
-        raise ValueError("Either 'direction' or 'directions' must be specified")
-
-    if direction and directions:
-        raise ValueError("Cannot specify both 'direction' and 'directions'")
-
-    try:
-        # Initialize controller (which ensures workspace)
-        controller = AIAutoController(token)
-        
-        # Prepare request data for CreateStudy
-        request_data = {
-            "spec": {
-                "studyName": study_name,
-                "direction": direction or "",
-                "directions": directions or [],
-                "samplerJson": object_to_json(sampler),
-                "prunerJson": object_to_json(pruner)
-            }
-        }
-        
-        # Call CreateStudy RPC
-        response = controller.client.call_rpc("CreateStudy", request_data)
-        
-        # Return StudyWrapper
-        return StudyWrapper(
-            study_name=response.get("studyName", study_name),
-            storage=controller.storage,
-            controller=controller
-        )
-
-    except Exception as e:
-        raise RuntimeError(f"Failed to create study: {e}") from e

aiauto_client-0.1.4.dist-info/METADATA

@@ -1,102 +0,0 @@
-Metadata-Version: 2.1
-Name: aiauto-client
-Version: 0.1.4
-Summary: AI Auto HPO (Hyperparameter Optimization) Client Library
-Author-email: AIAuto Team <ainode@zeroone.ai>
-Project-URL: Homepage, https://aiauto.cloude.ainode.ai
-Project-URL: Repository, https://aiauto.cloude.ainode.ai
-Project-URL: Documentation, https://aiauto.cloude.ainode.ai
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: optuna>=3.0.0
-Requires-Dist: requests>=2.25.0
-Requires-Dist: grpcio>=1.48.0
-Requires-Dist: grpcio-status>=1.48.0
-
-# AIAuto - Hyperparameter Optimization Client Library
-
-AIAuto는 Kubernetes 기반의 분산 HPO(Hyperparameter Optimization) 시스템을 위한 클라이언트 라이브러리입니다.
-사용자 python lib <-> Next.js 서버 사이 gRPC 통신 담당
-
-## lib build
-- `make build push` 
-  
-## 설치
-- `uv add aiauto-client`
-
-## 빠른 시작
-
-### Study 생성 및 Ask/Tell 패턴
-```python
-import aiauto
-
-# StudyWrapper 생성 (JWT 토큰 필요)
-studyWrapper = aiauto.create_study(
-    study_name='my_optimization',
-    token='your_jwt_token',
-    direction='maximize'
-)
-
-# 실제 optuna.Study 객체 획득 (로컬에서 ask/tell 가능)
-study = studyWrapper.get_study()
-
-# Ask/Tell 패턴으로 최적화
-trial = study.ask()
-params = trial.params
-
-# 사용자 모델 학습
-accuracy = train_model(params)
-
-# 결과 보고
-study.tell(trial, accuracy)
-```
-
-### 분산 최적화 (Pod 실행)
-```python
-import aiauto
-
-def objective(trial):
-    tc = aiauto.TrialController(trial)
-    
-    # 하이퍼파라미터 샘플링
-    lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
-    batch_size = trial.suggest_int('batch_size', 16, 128)
-    
-    # 모델 학습 로직
-    accuracy = train_model(lr, batch_size)
-    
-    tc.log(f'lr: {lr}, batch_size: {batch_size}, accuracy: {accuracy}')
-    
-    return accuracy
-
-# StudyWrapper 생성
-studyWrapper = aiauto.create_study(
-    study_name='distributed_optimization',
-    token='your_jwt_token',
-    direction='maximize'
-)
-
-# 분산 최적화 실행 (Kubernetes Pod에서 실행)
-studyWrapper.optimize(
-    objective=objective,
-    n_trials=100,
-    parallelism=4,
-    requirements_list=['torch==2.0.0', 'torchvision==0.15.0']
-)
-
-# 실시간 상태 모니터링
-status = studyWrapper.get_status()
-print(f"Active: {status['count_active']}, Completed: {status['count_completed']}")
-```

aiauto_client-0.1.4.dist-info/RECORD

@@ -1,11 +0,0 @@
-aiauto/__init__.py,sha256=TgD2ZvIHb7oKJb-HjUl3WfXXtuWLien0sybSy9onjL8,395
-aiauto/_config.py,sha256=DaRTIZlph9T3iuW-Cy4fkw8i3bXB--gMtW947SLZZNs,159
-aiauto/api.py,sha256=hzoVZMwKtH2EaAM1bY67grp6cenltCl8kdG8YHPegvk,1517
-aiauto/constants.py,sha256=UhDCLFoPE89XrHB3SEnZR3YUuzajgugMGX80KYx_qc0,939
-aiauto/core.py,sha256=dF-J8jxRP_FkQtxYYsrgza8OQHNzoPLN1cjYeUaqX1s,8076
-aiauto/http_client.py,sha256=t1gxeM5-d5bsVoFWgaNcTrt_WWUXuMuxge9gDlEqhoA,2086
-aiauto/serializer.py,sha256=_iPtEoqW8RTKOZ6UrC7CzOqoangpPYzeL7MQfIdmov8,1568
-aiauto_client-0.1.4.dist-info/METADATA,sha256=g86ft1ph8ebOUxQRafbgsYvxdlHRygOxvuS3vpSbfgQ,3001
-aiauto_client-0.1.4.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-aiauto_client-0.1.4.dist-info/top_level.txt,sha256=Sk2ctO9_Bf_tAPwq1x6Vfl6OuL29XzwMTO4F_KG6oJE,7
-aiauto_client-0.1.4.dist-info/RECORD,,