aiauto-client 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

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

@@ -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', '')
@@ -65,7 +65,7 @@ class AIAutoController:
     def create_study(
         self,
         study_name: str,
-        direction: Optional[str] = None,
+        direction: Optional[str] = 'minimize',
         directions: Optional[List[str]] = None,
         sampler: Union[object, dict, None] = None,
         pruner: Union[object, dict, None] = None
@@ -88,10 +88,10 @@ class AIAutoController:
                     "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),
@@ -184,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": {
@@ -209,7 +214,7 @@ class StudyWrapper:
                     "useGpu": use_gpu
                 }
             }
-            
+
             self._controller.client.call_rpc("Optimize", request_data)
 
         except Exception as e:
@@ -218,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", ""),
@@ -240,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/serializer.py

@@ -6,14 +6,24 @@ from typing import Callable, Union, List, Optional
 def serialize(objective: Callable) -> str:
     try:
         return inspect.getsource(objective)
-    except Exception as e:
-        raise ValueError("objective는 모듈 최상위 def만 허용합니다(데코레이터/로컬/람다 불가)") from e
+    except (OSError, TypeError) as e:
+        raise ValueError(
+            "Serialize 실패 objective 함수는 파일로 저장되어야 합니다\n"
+            "REPL/Jupyter Notebook에서는 %%writefile magic을 사용해서 local 에 file 로 저장하세요\n\n"
+            "%%writefile objective.py\n"
+            "def objective(trial):\n"
+            "    # 함수 내용\n"
+            "    ...\n\n"
+            "그 다음:\n"
+            "from objective import objective\n"
+            "study.optimize(objective, ...)"
+        ) from e
 
 
 def build_requirements(file_path: Optional[str] = None, reqs: Optional[List[str]] = None) -> str:
     if file_path and reqs:
         raise ValueError("requirements_file과 requirements_list는 동시에 지정할 수 없습니다")
-    
+
     if file_path:
         with open(file_path, 'r') as f:
             return f.read()
@@ -26,20 +36,20 @@ def build_requirements(file_path: Optional[str] = None, reqs: Optional[List[str]
 def object_to_json(obj: Union[object, dict, None]) -> str:
     if obj is None:
         return ""
-    
+
     if isinstance(obj, dict):
         return json.dumps(obj)
-    
+
     cls = type(obj)
     module_name = cls.__module__
     class_name = cls.__name__
-    
+
     if not module_name.startswith('optuna.'):
         raise ValueError(f"optuna 코어 클래스만 지원합니다: {class_name}")
-    
+
     sig = inspect.signature(cls)
     kwargs = {}
-    
+
     for param_name, param in sig.parameters.items():
         if param_name == 'self':
             continue
@@ -47,9 +57,9 @@ def object_to_json(obj: Union[object, dict, None]) -> str:
             value = getattr(obj, param_name)
             if param.default != value:
                 kwargs[param_name] = value
-    
+
     return json.dumps({
         "module": module_name,
         "class": class_name,
         "kwargs": kwargs
-    })
+    })

aiauto_client-0.1.7.dist-info/METADATA

@@ -0,0 +1,472 @@
+Metadata-Version: 2.1
+Name: aiauto-client
+Version: 0.1.7
+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]): 리소스 요청 (기본값: {"cpu": "256m", "memory": "256Mi"})
+- `resources_limits` (Dict[str, str]): 리소스 제한 (기본값: {"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],
+)
+```
+
+## Jupyter Notebook 사용 시 주의사항
+
+Jupyter Notebook이나 Python REPL에서 정의한 함수는 Serialize 할 수 없습니다
+대신 `%%writefile` magic 울 사용하여 파일로 저장한 후 import 하세요.
+
+### Jupyter에서 objective 함수 작성 방법
+- objective 함수를 파일로 저장
+```python
+%%writefile my_objective.py
+import aiauto
+import optuna
+
+def objective(trial: optuna.trial.Trial):
+    """
+    이 함수는 외부 서버에서 실행됩니다.
+    모든 import는 함수 내부에 작성하세요.
+    """
+    import torch  # 함수 내부에서 import
+    
+    x = trial.suggest_float('x', -10, 10)
+    y = trial.suggest_float('y', -10, 10)
+    return (x - 2) ** 2 + (y - 3) ** 2
+```
+- 저장한 함수를 import해서 사용
+```python
+import aiauto
+from my_objective import objective
+
+ac = aiauto.AIAutoController('<token>')
+study = ac.create_study('test', 'minimize')
+study.optimize(objective, n_trials=10, parallelism=2)
+```
+
+## 빠른 시작
+
+### 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.7.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=KqQeH0xp4LQuZE6r8kzXQsWY6QgC3hqn8MSuWTt4QmU,1938
+aiauto_client-0.1.7.dist-info/METADATA,sha256=xy8ZGkJYOwMUgA_8J4ag2mepwBzGZQwsyIOkMgQ8Cpw,18450
+aiauto_client-0.1.7.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+aiauto_client-0.1.7.dist-info/top_level.txt,sha256=Sk2ctO9_Bf_tAPwq1x6Vfl6OuL29XzwMTO4F_KG6oJE,7
+aiauto_client-0.1.7.dist-info/RECORD,,

aiauto_client-0.1.5.dist-info/METADATA

@@ -1,102 +0,0 @@
-Metadata-Version: 2.1
-Name: aiauto-client
-Version: 0.1.5
-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.5.dist-info/RECORD

@@ -1,10 +0,0 @@
-aiauto/__init__.py,sha256=sF7sJaXg7-MqolSYLxsaXAir1dBzARhXLrHo7zLsupg,345
-aiauto/_config.py,sha256=DaRTIZlph9T3iuW-Cy4fkw8i3bXB--gMtW947SLZZNs,159
-aiauto/constants.py,sha256=UhDCLFoPE89XrHB3SEnZR3YUuzajgugMGX80KYx_qc0,939
-aiauto/core.py,sha256=BFKEF2wp3mjMFt5V7oGyZ531j_MIQBJNEiiOVhrKmzc,9549
-aiauto/http_client.py,sha256=t1gxeM5-d5bsVoFWgaNcTrt_WWUXuMuxge9gDlEqhoA,2086
-aiauto/serializer.py,sha256=_iPtEoqW8RTKOZ6UrC7CzOqoangpPYzeL7MQfIdmov8,1568
-aiauto_client-0.1.5.dist-info/METADATA,sha256=_tY0xtaoaz-ZimyBJSavhmApFa8p5oT9WuKDyHH7Hi0,3001
-aiauto_client-0.1.5.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-aiauto_client-0.1.5.dist-info/top_level.txt,sha256=Sk2ctO9_Bf_tAPwq1x6Vfl6OuL29XzwMTO4F_KG6oJE,7
-aiauto_client-0.1.5.dist-info/RECORD,,