

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# 하이브리드 작업 생성
<a name="braket-jobs-first"></a>

 이 섹션에서는 Python 스크립트를 사용하여 하이브리드 작업을 생성하는 방법을 보여줍니다. 또는 선호하는 통합 개발 환경(IDE)이나 Braket 노트북 같은 로컬 Python 코드에서 하이브리드 작업을 생성하려면 [로컬 코드를 하이브리드 작업으로 실행](braket-hybrid-job-decorator.md)을 참조하세요.

**Topics**
+ [생성 및 실행](#braket-jobs-first-create)
+ [결과 모니터링](#braket-jobs-first-monitor-results)
+ [결과 저장](#braket-jobs-save-results)
+ [체크포인트 사용](#braket-jobs-checkpoints)
+ [로컬 코드를 하이브리드 작업으로 실행](braket-hybrid-job-decorator.md)
+ [하이브리드 작업에 API 사용](braket-jobs-api.md)
+ [로컬 모드로 하이브리드 작업 생성 및 디버깅](braket-jobs-local-mode.md)

## 생성 및 실행
<a name="braket-jobs-first-create"></a>

하이브리드 작업을 실행할 권한이 있는 역할이 있으면 바로 진행할 수 있습니다. 첫 번째 Braket 하이브리드 작업의 핵심은 *알고리즘 스크립트*입니다. 실행하려는 알고리즘을 정의하고 알고리즘의 일부인 고전 논리 및 양자 작업을 포함합니다. 알고리즘 스크립트 외에도 다른 종속성 파일을 제공할 수 있습니다. 알고리즘 스크립트와 해당 종속성을 합쳐서 *소스 모듈*이라고 합니다. *진입점*은 하이브리드 작업이 시작될 때 소스 모듈에서 실행할 첫 번째 파일 또는 함수를 정의합니다.

![\[콘솔 또는 노트북을 사용하여 양자 작업을 생성하고, 양자 디바이스에서 알고리즘 스크립트를 실행하고, 결과를 분석하는 워크플로를 보여주는 다이어그램입니다.\]](http://docs.aws.amazon.com/ko_kr/braket/latest/developerguide/images/braket-jobs-first-workflow.jpg)


먼저 5개의 벨 상태를 생성하고 해당 측정 결과를 출력하는 알고리즘 스크립트의 다음 기본 예제를 살펴보세요.

```
import os

from braket.aws import AwsDevice
from braket.circuits import Circuit


def start_here():

    print("Test job started!")

    # Use the device declared in the job script
    device = AwsDevice(os.environ["AMZN_BRAKET_DEVICE_ARN"])

    bell = Circuit().h(0).cnot(0, 1)
    for count in range(5):
        task = device.run(bell, shots=100)
        print(task.result().measurement_counts)

    print("Test job completed!")
```

이 파일을 Braket 노트북 또는 로컬 환경의 현재 작업 디렉터리에 *algorithm\$1script.py*라는 이름으로 저장합니다. algorithm\$1script.py 파일은 `start_here()`를 계획된 진입점으로 사용합니다.

그런 다음 algorithm\$1script.py 파일과 동일한 디렉터리에 Python 파일 또는 Python 노트북을 생성합니다. 이 스크립트는 하이브리드 작업을 시작하고 상태나 관심 대상 주요 결과 출력과 같은 모든 비동기 처리를 해결합니다. 최소한 이 스크립트는 하이브리드 작업 스크립트와 기본 디바이스를 지정해야 합니다.

**참고**  
노트북과 동일한 디렉터리에 Braket 노트북을 생성하거나 *algorithm\$1script.py* 파일과 같은 파일을 업로드하는 방법에 대한 자세한 내용은 [Amazon Braket Python SDK를 사용하여 첫 번째 회로 실행](braket-get-started-run-circuit.md)을 참조하세요.

이 기본적인 첫 번째 사례의 경우 시뮬레이터를 대상으로 합니다. 대상 양자 디바이스 유형, 시뮬레이터 또는 실제 QPU에 관계없이 다음 스크립트에서 `device`로 지정하는 디바이스는 하이브리드 작업을 예약하는 데 사용되며 알고리즘 스크립트에서 환경 변수 `AMZN_BRAKET_DEVICE_ARN`으로 사용할 수 있습니다.

**참고**  
하이브리드 작업 AWS 리전 의에서 사용할 수 있는 디바이스만 사용할 수 있습니다. Amazon Braket SDK는 이 AWS 리전을 자동으로 선택합니다. 예를 들어 us-east-1의 하이브리드 작업은 IonQ, SV1, DM1 및 TN1 디바이스를 사용할 수 있지만 Rigetti 디바이스는 사용할 수 없습니다.

시뮬레이터 대신 양자 컴퓨터를 선택하면, Braket은 하이브리드 작업을 예약하여 모든 양자 작업을 우선적으로 실행하도록 합니다.

```
from braket.aws import AwsQuantumJob
from braket.devices import Devices

job = AwsQuantumJob.create(
    Devices.Amazon.SV1,
    source_module="algorithm_script.py",
    entry_point="algorithm_script:start_here",
    wait_until_complete=True
)
```

파라미터 `wait_until_complete=True`는 작업이 실행 중인 실제 작업의 출력을 인쇄하도록 자세한 정보 표시 모드를 설정합니다. 다음 예제와 유사한 출력이 표시됩니다.

```
Initializing Braket Job: arn:aws:braket:us-west-2:111122223333:job/braket-job-default-123456789012
Job queue position: 1
Job queue position: 1
Job queue position: 1
..............
.
.
.
Beginning Setup
Checking for Additional Requirements
Additional Requirements Check Finished
Running Code As Process
Test job started!
Counter({'00': 58, '11': 42})
Counter({'00': 55, '11': 45})
Counter({'11': 51, '00': 49})
Counter({'00': 56, '11': 44})
Counter({'11': 56, '00': 44})
Test job completed!
Code Run Finished
2025-09-24 23:13:40,962 sagemaker-training-toolkit INFO     Reporting training SUCCESS
```

**참고**  
위치(로컬 디렉터리 또는 파일의 경로, 또는 tar.gz 파일의 S3 URI)를 전달하여 [AwsQuantumJob.create](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.aws.aws_quantum_job.html#braket.aws.aws_quantum_job.AwsQuantumJob.create) 메서드와 함께 사용자 지정 모듈을 사용할 수도 있습니다. 작업 예제는 [Amazon Braket 예제 Github 리포지토리](https://github.com/amazon-braket/amazon-braket-examples/tree/main)의 하이브리드 작업 폴더에서 [Parallelize\$1training\$1for\$1QML.ipynb](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) 파일을 참조하세요.

## 결과 모니터링
<a name="braket-jobs-first-monitor-results"></a>

또는, Amazon CloudWatch의 로그 출력에 액세스할 수 있습니다. 이렇게 하려면 작업 세부 정보 페이지의 왼쪽 메뉴에 있는 **로그 그룹** 탭으로 이동하여 로그 그룹 `aws/braket/jobs`를 선택한 다음, 작업 이름이 포함된 로그 스트림을 선택합니다. 위 예제에서는 `braket-job-default-1631915042705/algo-1-1631915190`입니다.

![\[Amazon Braket SDK Python 테스트에 대한 파일 경로 및 타임스탬프가 있는 로그 이벤트 목록을 보여주는 CloudWatch 로그 그룹입니다.\]](http://docs.aws.amazon.com/ko_kr/braket/latest/developerguide/images/braket-jobs-first-cw-log.png)


**하이브리드 작업** 페이지를 선택한 다음 **설정**을 선택하여 콘솔에서 하이브리드 작업의 상태를 볼 수도 있습니다.

![\[요약, 이벤트 시간, 소스 코드 및 인스턴스 구성, 중지 조건을 보여주는 Amazon Braket Hybrid Jobs 세부 정보입니다.\]](http://docs.aws.amazon.com/ko_kr/braket/latest/developerguide/images/braket-jobs-first-console-status.png)


하이브리드 작업은 실행되는 동안 Amazon S3에서 일부 아티팩트를 생성합니다. 기본 S3 버킷 이름은 `amazon-braket-<region>-<accountid>`이고 콘텐츠는 `jobs/<jobname>/<timestamp>` 디렉터리에 있습니다. Braket Python SDK를 사용하여 하이브리드 작업을 생성할 때 다른 `code_location`을 지정하여 이러한 아티팩트가 저장되는 S3 위치를 구성할 수 있습니다.

**참고**  
이 S3 버킷은 작업 스크립트 AWS 리전 와 동일한에 있어야 합니다.

`jobs/<jobname>/<timestamp>` 디렉터리에는 `model.tar.gz` 파일에 담긴 진입점 스크립트의 출력이 있는 하위 폴더가 포함되어 있습니다. 또한 `source.tar.gz` 파일에 알고리즘 스크립트 아티팩트가 포함된 `script`라고 하는 디렉터리도 있습니다. 실제 양자 작업의 결과는 `jobs/<jobname>/tasks`라는 디렉터리에 있습니다.

## 결과 저장
<a name="braket-jobs-save-results"></a>

하이브리드 작업 스크립트의 하이브리드 작업 객체와 Amazon S3의 출력 폴더(model.tar.gz라는 이름의 tar-zipped 파일)에서 사용할 수 있도록 알고리즘 스크립트에서 생성된 결과를 저장할 수 있습니다.

출력은 JavaScript Object Notation(JSON) 형식을 사용하여 파일에 저장해야 합니다. 넘파이 배열의 경우처럼 데이터가 텍스트로 쉽게 직렬화될 수 없는 경우, 피클링된 데이터 형식을 사용하여 직렬화하는 옵션을 전달할 수 있습니다. 자세한 내용은 [braket.jobs.data\$1persistence 모듈](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.jobs.data_persistence.html#braket.jobs.data_persistence.save_job_result)을 참조하세요.

하이브리드 작업의 결과를 저장하려면 \$1ADD로 주석이 달린 다음 줄을 algorithm\$1script.py 파일에 추가합니다.

```
import os

from braket.aws import AwsDevice
from braket.circuits import Circuit
from braket.jobs import save_job_result  # ADD


def start_here():

    print("Test job started!")

    device = AwsDevice(os.environ['AMZN_BRAKET_DEVICE_ARN'])

    results = []  # ADD

    bell = Circuit().h(0).cnot(0, 1)
    for count in range(5):
        task = device.run(bell, shots=100)
        print(task.result().measurement_counts)
        results.append(task.result().measurement_counts)  # ADD

        save_job_result({"measurement_counts": results})  # ADD

    print("Test job completed!")
```

그런 다음 \$1ADD로 주석이 달린 줄 **`print(job.result())`**를 추가하여 작업 스크립트의 작업 결과를 표시할 수 있습니다.

```
import time
from braket.aws import AwsQuantumJob

job = AwsQuantumJob.create(
    source_module="algorithm_script.py",
    entry_point="algorithm_script:start_here",
    device="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
)

print(job.arn)
while job.state() not in AwsQuantumJob.TERMINAL_STATES:
    print(job.state())
    time.sleep(10)

print(job.state())
print(job.result())   # ADD
```

이 예제에서는 자세한 정보 출력을 억제하기 위해 `wait_until_complete=True`를 제거했습니다. 디버깅을 위해 다시 추가할 수 있습니다. 이 하이브리드 작업을 실행하면 식별자와 `job-arn`을 출력한 다음 하이브리드 작업이 `COMPLETED` 상태가 될 때까지 10초마다 하이브리드 작업의 상태를 출력한 후에 벨 회로의 결과가 보여줍니다. 다음 예제를 참조하세요.

```
arn:aws:braket:us-west-2:111122223333:job/braket-job-default-123456789012
INITIALIZED
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
...
RUNNING
RUNNING
COMPLETED
{'measurement_counts': [{'11': 53, '00': 47},..., {'00': 51, '11': 49}]}
```

## 체크포인트 사용
<a name="braket-jobs-checkpoints"></a>

체크포인트를 사용하여 하이브리드 작업의 중간 반복을 저장할 수 있습니다. 이전 섹션의 알고리즘 스크립트 예제에서 체크포인트 파일을 생성하려면 \$1ADD로 주석이 달린 다음 줄을 추가하면 됩니다.

```
from braket.aws import AwsDevice
from braket.circuits import Circuit
from braket.jobs import save_job_checkpoint  # ADD
import os


def start_here():

    print("Test job starts!")

    device = AwsDevice(os.environ["AMZN_BRAKET_DEVICE_ARN"])

    # ADD the following code
    job_name = os.environ["AMZN_BRAKET_JOB_NAME"]
    save_job_checkpoint(checkpoint_data={"data": f"data for checkpoint from {job_name}"}, checkpoint_file_suffix="checkpoint-1")  # End of ADD

    bell = Circuit().h(0).cnot(0, 1)
    for count in range(5):
        task = device.run(bell, shots=100)
        print(task.result().measurement_counts)

    print("Test hybrid job completed!")
```

하이브리드 작업을 실행하면 기본 `/opt/jobs/checkpoints` 경로의 체크포인트 디렉터리 내 하이브리드 작업 아티팩트에 *<jobname>-checkpoint-1.json* 파일이 생성됩니다. 이 기본 경로를 변경하지 않는 한 하이브리드 작업 스크립트는 변경되지 않습니다.

이전 하이브리드 작업에서 생성된 체크포인트에서 하이브리드 작업을 로드하려는 경우 알고리즘 스크립트는 `from braket.jobs import load_job_checkpoint`를 사용합니다. 알고리즘 스크립트에 로드할 논리는 다음과 같습니다.

```
from braket.jobs import load_job_checkpoint

checkpoint_1 = load_job_checkpoint(
    "previous_job_name",
    checkpoint_file_suffix="checkpoint-1",
)
```

이 체크포인트를 로드한 후 `checkpoint-1`에 로드된 콘텐츠를 기반으로 논리를 계속 진행할 수 있습니다.

**참고**  
*checkpoint\$1file\$1suffix*는 체크포인트 생성 시 이전에 지정한 접미사와 일치해야 합니다.

오케스트레이션 스크립트는 \$1ADD로 주석이 달린 줄로 이전 하이브리드 작업의 `job-arn`을 지정해야 합니다.

```
from braket.aws import AwsQuantumJob

job = AwsQuantumJob.create(
    source_module="source_dir",
    entry_point="source_dir.algorithm_script:start_here",
    device="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
    copy_checkpoints_from_job="<previous-job-ARN>", #ADD
    )
```

# 로컬 코드를 하이브리드 작업으로 실행
<a name="braket-hybrid-job-decorator"></a>

Amazon Braket Hybrid Jobs는 Amazon EC2 컴퓨팅 리소스와 Amazon Braket Quantum Processing Unit(QPU) 액세스를 결합하여 하이브리드 양자-고전 알고리즘의 완전관리형 오케스트레이션을 제공합니다. 하이브리드 작업에서 생성된 양자 작업은 개별 양자 작업보다 대기열에서 우선순위를 가지므로, 양자 작업 대기열의 변동으로 인해 알고리즘이 중단되지 않습니다. 각 QPU는 별도의 하이브리드 작업 대기열을 유지하여 한 번에 하나의 하이브리드 작업만 실행되도록 보장합니다.

**Topics**
+ [로컬 Python 코드에서 하이브리드 작업 생성](#create-hybrid-job-from-local-python-code)
+ [추가 Python 패키지 및 소스 코드 설치](#install-python-packages-and-code)
+ [하이브리드 작업 인스턴스에 데이터 저장 및 로드](#save-load-data-into-instance)
+ [하이브리드 작업 데코레이터 모범 사례](#best-practices)

## 로컬 Python 코드에서 하이브리드 작업 생성
<a name="create-hybrid-job-from-local-python-code"></a>

로컬 Python 코드를 Amazon Braket Hybrid Jobs로 실행할 수 있습니다. 다음 코드 예제와 같이 `@hybrid_job` 데코레이터로 코드에 주석을 달아 이 작업을 수행할 수 있습니다. 사용자 지정 환경의 경우 Amazon Elastic Container Registry(ECR)의 [사용자 지정 컨테이너를 사용](braket-jobs-byoc.md)하도록 선택할 수 있습니다.

**참고**  
Python 3.12만 기본적으로 지원됩니다.

 `@hybrid_job` 데코레이터를 사용하여 함수에 주석을 달 수 있습니다. Braket은 데코레이터 내부의 코드를 Braket 하이브리드 작업 [알고리즘 스크립트](braket-jobs-first.md)로 변환합니다. 그런 다음 하이브리드 작업은 Amazon EC2 인스턴스의 데코레이터 내에서 함수를 간적접으로 호출합니다. `job.state()` 또는 Braket 콘솔을 통해 작업 진행 상황을 모니터링할 수 있습니다. 다음 코드 예제는 State Vector Simulator (SV1) device에서 다섯 개의 상태 시퀀스를 실행하는 방법을 보여줍니다.

```
from braket.aws import AwsDevice
from braket.circuits import Circuit, FreeParameter, Observable
from braket.devices import Devices
from braket.jobs.hybrid_job import hybrid_job
from braket.jobs.metrics import log_metric

device_arn = Devices.Amazon.SV1


@hybrid_job(device=device_arn)  # Choose priority device
def run_hybrid_job(num_tasks=1):
    device = AwsDevice(device_arn)  # Declare AwsDevice within the hybrid job

    # Create a parametric circuit
    circ = Circuit()
    circ.rx(0, FreeParameter("theta"))
    circ.cnot(0, 1)
    circ.expectation(observable=Observable.X(), target=0)

    theta = 0.0  # Initial parameter

    for i in range(num_tasks):
        task = device.run(circ, shots=100, inputs={"theta": theta})  # Input parameters
        exp_val = task.result().values[0]

        theta += exp_val  # Modify the parameter (possibly gradient descent)

        log_metric(metric_name="exp_val", value=exp_val, iteration_number=i)

    return {"final_theta": theta, "final_exp_val": exp_val}
```

일반적인 Python 함수와 마찬가지로 함수를 간접적으로 호출하여 하이브리드 작업을 생성합니다. 그러나 데코레이터 함수는 함수의 결과가 아닌 하이브리드 작업 핸들을 반환합니다. 완료 후 결과를 검색하려면 `job.result()`를 사용합니다.

```
job = run_hybrid_job(num_tasks=1)
result = job.result()
```

`@hybrid_job` 데코레이터의 디바이스 인수는 하이브리드 작업이 우선적으로 액세스할 수 있는 디바이스를 지정합니다. 이 경우 SV1 시뮬레이터입니다. QPU 우선순위를 얻으려면 함수 내에서 사용되는 디바이스 ARN이 데코레이터에 지정된 것과 일치하는지 확인해야 합니다. 편의를 위해 헬퍼 함수 `get_job_device_arn()`을 사용하여 `@hybrid_job`에 선언된 디바이스 ARN을 캡처할 수 있습니다.

**참고**  
각 하이브리드 작업은 Amazon EC2에서 컨테이너화된 환경을 생성하기 때문에 시작 시간이 최소 1분입니다. 따라서 단일 회로 또는 여러 회로의 배치와 같이 매우 짧은 워크로드의 경우 양자 작업을 사용하기에 충분할 수 있습니다.

**하이퍼파라미터** 

`run_hybrid_job()` 함수는 인수 `num_tasks`를 사용하여 생성된 양자 작업 수를 제어합니다. 하이브리드 작업은 이를 [하이퍼파라미터](braket-jobs-hyperparameters.md)로 자동으로 캡처합니다.

**참고**  
하이퍼파라미터는 Braket 콘솔에 문자열로 표시되며, 문자열은 2,500자로 제한됩니다.

**지표 및 로깅** 

`run_hybrid_job()` 함수 내에서 반복 알고리즘의 지표는 `log_metrics`를 사용하여 기록됩니다. 지표는 하이브리드 작업 탭 아래의 Braket 콘솔 페이지에 자동으로 플롯됩니다. [Braket 비용 추적기](braket-pricing.md)를 사용하면 하이브리드 작업 실행 중에 지표를 사용하여 거의 실시간으로 양자 작업 비용을 추적할 수 있습니다. 위 예제에서는 [결과 유형](braket-result-types.md)의 첫 번째 확률을 기록하는 지표 이름 “probability”를 사용합니다.

**결과 검색** 

하이브리드 작업이 완료되면 `job.result()`를 사용하여 하이브리드 작업 결과를 검색합니다. 반환 문의 모든 객체는 Braket에 의해 자동으로 캡처됩니다. 함수에서 반환하는 객체는 각 요소가 직렬화 가능한 튜플이어야 합니다. 예를 들어, 다음 코드는 작동하는 예제와 실패하는 예제를 보여줍니다.

```
import numpy as np


# Working example
@hybrid_job(device=Devices.Amazon.SV1)
def passing():
    np_array = np.random.rand(5)
    return np_array  # Serializable

# # Failing example
# @hybrid_job(device=Devices.Amazon.SV1)
# def failing():
#     return MyObject() # Not serializable
```

**작업 이름** 

기본적으로 이 하이브리드 작업의 이름은 함수 이름에서 추론됩니다. 최대 50자까지 사용자 지정 이름을 지정할 수도 있습니다. 예를 들어, 다음 코드에서 작업 이름은 "my-job-name"입니다.

```
@hybrid_job(device=Devices.Amazon.SV1, job_name="my-job-name")
def function():
    pass
```

**로컬 모드** 

[로컬 작업](braket-jobs-local-mode.md)은 데코레이터에 인수 `local=True`를 추가하여 생성됩니다. 그러면 랩톱과 같은 로컬 컴퓨팅 환경의 컨테이너화된 환경에서 하이브리드 작업이 실행됩니다. 로컬 작업에는 양자 작업에 대한 우선순위 대기열이 **없습니다**. 다중 노드 또는 MPI와 같은 고급 사례의 경우 로컬 작업이 필요한 Braket 환경 변수에 액세스할 수 있습니다. 다음 코드는 디바이스를 SV1 시뮬레이터로 사용하여 로컬 하이브리드 작업을 생성합니다.

```
@hybrid_job(device=Devices.Amazon.SV1, local=True)
def run_hybrid_job(num_tasks=1):
    return ...
```

다른 모든 하이브리드 작업 옵션도 지원됩니다. 옵션 목록은 [braket.jobs.quantum\$1job\$1creation 모듈](https://amazon-braket-sdk-python.readthedocs.io/en/stable/_apidoc/braket.jobs.quantum_job_creation.html)을 참조하세요.

## 추가 Python 패키지 및 소스 코드 설치
<a name="install-python-packages-and-code"></a>

원하는 Python 패키지를 사용하도록 런타임 환경을 사용자 지정할 수 있습니다. `requirements.txt` 파일, 패키지 이름 목록을 사용하거나 [자체 컨테이너를 사용할 수 있습니다(BYOC)](braket-jobs-byoc.md). 예를 들어 `requirements.txt` 파일에는 설치할 다른 패키지가 포함될 수 있습니다.

```
qiskit 
pennylane >= 0.31
mitiq == 0.29
```

`requirements.txt` 파일을 사용하여 런타임 환경을 사용자 지정하려면 다음 코드 예제를 참조하세요.

```
@hybrid_job(device=Devices.Amazon.SV1, dependencies="requirements.txt")
def run_hybrid_job(num_tasks=1):
    return ...
```

또는 다음과 같이 패키지 이름을 Python 목록으로 제공할 수 있습니다.

```
@hybrid_job(device=Devices.Amazon.SV1, dependencies=["qiskit", "pennylane>=0.31", "mitiq==0.29"])
def run_hybrid_job(num_tasks=1):
    return ...
```

추가 소스 코드는 다음 코드 예제와 같이 모듈 목록 또는 단일 모듈로 지정할 수 있습니다.

```
@hybrid_job(device=Devices.Amazon.SV1, include_modules=["my_module1", "my_module2"])
def run_hybrid_job(num_tasks=1):
    return ...
```

## 하이브리드 작업 인스턴스에 데이터 저장 및 로드
<a name="save-load-data-into-instance"></a>

**입력 훈련 데이터 지정**

하이브리드 작업을 생성할 때 Amazon Simple Storage Service(Amazon S3) 버킷을 지정하여 입력 훈련 데이터세트를 제공할 수 있습니다. 로컬 경로를 지정할 수도 있으며, 그러면 Braket이 자동으로 데이터를 `s3://<default_bucket_name>/jobs/<job_name>/<timestamp>/data/<channel_name>`의 Amazon S3에 업로드합니다. 로컬 경로를 지정하는 경우 채널 이름은 기본적으로 “input”으로 설정됩니다. 다음 코드는 로컬 경로 `data/file.npy`의 넘파이 파일을 보여줍니다.

```
import numpy as np


@hybrid_job(device=Devices.Amazon.SV1, input_data="data/file.npy")
def run_hybrid_job(num_tasks=1):
    data = np.load("data/file.npy")
    return ...
```

S3의 경우 `get_input_data_dir()` 헬퍼 함수를 사용해야 합니다.

```
import numpy as np
from braket.jobs import get_input_data_dir

s3_path = "s3://amazon-braket-us-east-1-123456789012/job-data/file.npy"


@hybrid_job(device=None, input_data=s3_path)
def job_s3_input():
    np.load(get_input_data_dir() + "/file.npy")


@hybrid_job(device=None, input_data={"channel": s3_path})
def job_s3_input_channel():
    np.load(get_input_data_dir("channel") + "/file.npy")
```

채널 값 및 S3 URI 또는 로컬 경로의 딕셔너리를 제공하여 여러 입력 데이터 소스를 지정할 수 있습니다.

```
import numpy as np
from braket.jobs import get_input_data_dir

input_data = {
    "input": "data/file.npy",
    "input_2": "s3://amzn-s3-demo-bucket/data.json"
}


@hybrid_job(device=None, input_data=input_data)
def multiple_input_job():
    np.load(get_input_data_dir("input") + "/file.npy")
    np.load(get_input_data_dir("input_2") + "/data.json")
```

**참고**  
입력 데이터가 크면(>1GB) 작업이 생성되기까지 대기 시간이 길어집니다. 이는 로컬 입력 데이터가 S3 버킷에 처음 업로드된 후 S3 경로가 작업 요청에 추가되기 때문입니다. 마지막으로, 작업 요청이 Braket 서비스에 제출됩니다.

**S3에 결과 저장**

데코레이션된 함수의 반환 문에 포함되지 않은 결과를 저장하려면 모든 파일 쓰기 작업에 올바른 디렉터리를 추가해야 합니다. 다음 예제에서는 넘파이 배열과 matplotlib 그림을 저장하는 방법을 보여줍니다.

```
import matplotlib.pyplot as plt
import numpy as np


@hybrid_job(device=Devices.Amazon.SV1)
def run_hybrid_job(num_tasks=1):
    result = np.random.rand(5)

    # Save a numpy array
    np.save("result.npy", result)

    # Save a matplotlib figure
    plt.plot(result)
    plt.savefig("fig.png")
    return ...
```

모든 결과는 `model.tar.gz`라는 파일로 압축됩니다. Python 함수 `job.result()`를 사용하거나 Braket 관리 콘솔의 하이브리드 작업 페이지에서 결과 폴더로 이동하여 결과를 다운로드할 수 있습니다.

**체크포인트에서 저장 및 재개**

장기 실행 하이브리드 작업의 경우 알고리즘의 중간 상태를 주기적으로 저장하는 것이 좋습니다. 기본 제공 `save_job_checkpoint()` 헬퍼 함수를 사용하거나 파일을 `AMZN_BRAKET_JOB_RESULTS_DIR` 경로에 저장할 수 있습니다. 후자의 경우 헬퍼 함수 `get_job_results_dir()`과 함께 사용할 수 있습니다.

다음은 하이브리드 작업 데코레이터를 사용하여 체크포인트를 저장하고 로드하는 최소 작업 예제입니다.

```
from braket.jobs import save_job_checkpoint, load_job_checkpoint, hybrid_job


@hybrid_job(device=None, wait_until_complete=True)
def function():
    save_job_checkpoint({"a": 1})


job = function()
job_name = job.name
job_arn = job.arn


@hybrid_job(device=None, wait_until_complete=True, copy_checkpoints_from_job=job_arn)
def continued_function():
    load_job_checkpoint(job_name)


continued_job = continued_function()
```

첫 번째 하이브리드 작업에서는 `save_job_checkpoint()`가 저장하려는 데이터가 포함된 딕셔너리와 함께 직접적으로 호출됩니다. 기본적으로 모든 값은 텍스트로 직렬화 가능해야 합니다. 넘파이 배열과 같은 더 복잡한 Python 객체를 체크포인트하려면 `data_format = PersistedJobDataFormat.PICKLED_V4`를 설정할 수 있습니다. 이 코드는 "checkpoints"라는 하위 폴더 아래의 하이브리드 작업 아티팩트에서 기본 이름 `<jobname>.json`으로 체크포인트 파일을 생성하고 덮어씁니다.

체크포인트에서 계속 진행하기 위해 새로운 하이브리드 작업을 생성하려면 `copy_checkpoints_from_job=job_arn`을 전달해야 합니다. 여기서 `job_arn`은 이전 작업의 하이브리드 작업 ARN입니다. 그런 다음 `load_job_checkpoint(job_name)`을 사용하여 체크포인트에서를 로드합니다.

## 하이브리드 작업 데코레이터 모범 사례
<a name="best-practices"></a>

**비동기성 수용**

데코레이터 주석으로 생성된 하이브리드 작업은 비동기적입니다. 즉, 고전 리소스와 양자 리소스를 사용할 수 있게 되면 실행됩니다. Braket Management Console 또는 Amazon CloudWatch를 사용하여 알고리즘의 진행 상황을 모니터링합니다. 실행할 알고리즘을 제출하면 Braket은 확장 가능한 컨테이너화된 환경에서 해당 알고리즘을 실행하고 알고리즘이 완료되면 결과가 검색됩니다.

**반복 변분 알고리즘 실행**

하이브리드 작업은 반복적인 양자-고전 알고리즘을 실행할 수 있는 도구를 제공합니다. 순수하게 양자 문제인 경우 [양자 작업](braket-submit-tasks.md) 또는 [양자 작업 배치](braket-batching-tasks.md)를 사용합니다. 특정 QPU에 대한 우선 액세스는 중간에 고전적 처리를 수행하면서 QPU에 대한 여러 번의 반복 직접 호출을 필요로 하는 장기 실행 변분 알고리즘에 가장 유용합니다.

**로컬 모드를 사용한 디버깅**

QPU에서 하이브리드 작업을 실행하기 전에 먼저 시뮬레이터 SV1에서를 실행하여 예상대로 실행되는지 확인하는 것이 좋습니다. 소규모 테스트의 경우 빠른 반복 및 디버깅을 위해 로컬 모드로 실행할 수 있습니다.

**[BYOC(Bring Your Own Container)](braket-jobs-byoc.md)를 통한 재현성 향상**

컨테이너화된 환경 내에서 소프트웨어와 해당 종속성을 캡슐화하여 재현 가능한 실험을 생성합니다. 컨테이너에 모든 코드, 종속성 및 설정을 패키징하면 잠재적인 충돌 및 버전 관리 문제를 방지할 수 있습니다.

**다중 인스턴스 분산 시뮬레이터**

많은 수의 회로를 실행하려면 기본 제공 MPI 지원을 사용하여 단일 하이브리드 작업 내의 여러 인스턴스에서 로컬 시뮬레이터를 실행하는 것이 좋습니다. 자세한 내용은 [임베디드 시뮬레이터](pennylane-embedded-simulators.md)를 참조하세요.

**파라메트릭 회로 사용**

하이브리드 작업에서 제출하는 파라메트릭 회로는 [파라메트릭 컴파일](braket-jobs-parametric-compilation.md)을 사용하여 특정 QPU에서 자동으로 컴파일되어 알고리즘의 런타임을 개선합니다.

**주기적인 체크포인트**

장기 실행 하이브리드 작업의 경우 알고리즘의 중간 상태를 주기적으로 저장하는 것이 좋습니다.

**추가 예제, 사용 사례 및 모범 사례는 [Amazon Braket 예제 GitHub](https://github.com/amazon-braket/amazon-braket-examples)를 참조하세요.**

# 하이브리드 작업에 API 사용
<a name="braket-jobs-api"></a>

API를 사용하여 Amazon Braket Hybrid Jobs에 직접 액세스하고 상호 작용할 수 있습니다. 그러나 API를 직접 사용할 때는 기본값 및 편의 메서드를 사용할 수 없습니다.

**참고**  
[Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python)를 사용하여 Amazon Braket Hybrid Jobs와 상호 작용하는 것이 좋습니다. 이 SDK는하이브리드 작업을 성공적으로 실행하는 데 도움이 되는 편의 기본값과 보호 기능을 제공합니다.

이 주제에서는 API 사용의 기본 사항을 다룹니다. API를 사용하기로 선택한 경우 이 접근 방식은 더 복잡할 수 있으며 하이브리드 작업이 실행되도록 하기 위해 여러 번의 반복에 대비해야 함을 염두에 두세요.

API를 사용하려면 계정에 `AmazonBraketFullAccess` 관리형 정책이 적용된 역할이 있어야 합니다.

**참고**  
`AmazonBraketFullAccess` 관리형 정책이 적용된 역할을 얻는 방법에 대한 자세한 내용은 [Amazon Braket 활성화](braket-enable-overview.md) 페이지를 참조하세요.

또한 **실행 역할**이 필요합니다. 이 역할은 서비스에 전달됩니다. **Amazon Braket 콘솔**을 사용하여 역할을 생성할 수 있습니다. **권한 및 설정** 페이지의 **실행 역할** 탭을 사용하여 하이브리드 작업에 대한 기본 역할을 생성합니다.

`CreateJob` API에서는 하이브리드 작업에 필요한 모든 파라미터를 지정해야 합니다. Python을 사용하려면 알고리즘 스크립트 파일을 input.tar.gz 파일과 같은 tar 번들로 압축하고 다음 스크립트를 실행합니다. 하이브리드 작업이 시작되는 경로, 파일 및 메서드를 지정하는 계정 정보 및 진입점과 일치하도록 꺾쇠 대괄호(`<>`) 안의 코드 부분을 업데이트합니다.

```
from braket.aws import AwsDevice, AwsSession
import boto3
from datetime import datetime

s3_client = boto3.client("s3")
client = boto3.client("braket")

project_name = "job-test"
job_name = project_name + "-" + datetime.strftime(datetime.now(), "%Y%m%d%H%M%S")
bucket = "amazon-braket-<your_bucket>"
s3_prefix = job_name

job_script = "input.tar.gz"
job_object = f"{s3_prefix}/script/{job_script}"
s3_client.upload_file(job_script, bucket, job_object)

input_data = "inputdata.csv"
input_object = f"{s3_prefix}/input/{input_data}"
s3_client.upload_file(input_data, bucket, input_object)

job = client.create_job(
    jobName=job_name,
    roleArn="arn:aws:iam::<your_account>:role/service-role/AmazonBraketJobsExecutionRole",  # https://docs.aws.amazon.com/braket/latest/developerguide/braket-manage-access.html#about-amazonbraketjobsexecution
    algorithmSpecification={
        "scriptModeConfig": {
            "entryPoint": "<your_execution_module>:<your_execution_method>",
            "containerImage": {"uri": "292282985366.dkr.ecr.us-west-1.amazonaws.com/amazon-braket-base-jobs:1.0-cpu-py37-ubuntu18.04"},   # Change to the specific region you are using
            "s3Uri": f"s3://{bucket}/{job_object}",
            "compressionType": "GZIP"
        }
    },
    inputDataConfig=[
        {
            "channelName": "hellothere",
            "compressionType": "NONE",
            "dataSource": {
                "s3DataSource": {
                    "s3Uri": f"s3://{bucket}/{s3_prefix}/input",
                    "s3DataType": "S3_PREFIX"
                }
            }
        }
    ],
    outputDataConfig={
        "s3Path": f"s3://{bucket}/{s3_prefix}/output"
    },
    instanceConfig={
        "instanceType": "ml.m5.large",
        "instanceCount": 1,
        "volumeSizeInGb": 1
    },
    checkpointConfig={
        "s3Uri":  f"s3://{bucket}/{s3_prefix}/checkpoints",
        "localPath": "/opt/omega/checkpoints"
    },
    deviceConfig={
        "priorityAccess": {
            "devices": [
                "arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3"
            ]
        }
    },
    hyperParameters={
        "hyperparameter key you wish to pass": "<hyperparameter value you wish to pass>",
    },
    stoppingCondition={
        "maxRuntimeInSeconds": 1200,
        "maximumTaskLimit": 10
    },
)
```

하이브리드 작업을 생성한 후에는 `GetJob` API 또는 콘솔을 통해 하이브리드 작업 세부 정보에 액세스할 수 있습니다. 이전 예제와 같이 `createJob` 코드를 실행한 Python 세션에서 하이브리드 작업 세부 정보를 가져오려면 다음 Python 명령을 사용합니다.

```
getJob = client.get_job(jobArn=job["jobArn"])
```

하이브리드 작업을 취소하려면 작업('JobArn')의 Amazon Resource Name을 사용하여 `CancelJob` API를 직접적으로 호출합니다.

```
cancelJob = client.cancel_job(jobArn=job["jobArn"])
```

`checkpointConfig` 파라미터를 사용하여 체크포인트를 `createJob` API의 일부로 지정할 수 있습니다.

```
    checkpointConfig = {
        "localPath" : "/opt/omega/checkpoints",
        "s3Uri": f"s3://{bucket}/{s3_prefix}/checkpoints"
    },
```

**참고**  
`checkpointConfig`의 localPath는 다음의 예약된 경로 `/opt/ml`, `/opt/braket`, `/tmp` 또는 `/usr/local/nvidia` 중 어느 것으로도 시작할 수 없습니다.

# 로컬 모드로 하이브리드 작업 생성 및 디버깅
<a name="braket-jobs-local-mode"></a>

새 하이브리드 알고리즘을 빌드할 때 로컬 모드를 사용하면 알고리즘 스크립트를 디버깅하고 테스트할 수 있습니다. 로컬 모드는 Amazon Braket Hybrid Jobs에서 사용하려는 코드를 실행할 수 있게 해주지만, 하이브리드 작업 실행을 위한 인프라 관리를 Braket에 의존하지 않아도 되는 기능입니다. 대신, Amazon Braket Notebook 인스턴스 또는 랩톱이나 데스크톱 컴퓨터와 같은 기본 클라이언트에서 로컬로 하이브리드 작업을 실행합니다.

로컬 모드에서는 여전히 양자 작업을 실제 디바이스로 전송할 수 있지만, 로컬 모드에서 실제 QPU를 대상으로 실행할 때 성능상의 이점을 얻을 수 없습니다.

로컬 모드를 사용하려면 프로그램 내 어디에서 발생하든, `LocalQuantumJob`을 `AwsQuantumJob`으로 수정합니다. 예를 들어 [첫 번째 하이브리드 작업 생성](braket-jobs-first.md)의 예제를 실행하려면 다음과 같이 코드에서 하이브리드 작업 스크립트를 편집합니다.

```
from braket.jobs.local import LocalQuantumJob

job = LocalQuantumJob.create(
    device="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
    source_module="algorithm_script.py",
    entry_point="algorithm_script:start_here",
)
```

**참고**  
이 기능을 사용하려면 Amazon Braket 노트북에 이미 사전 설치되어 있는 Docker를 로컬 환경에 설치해야 합니다. Docker 설치 지침은 [Get Docker](https://docs.docker.com/get-started/get-docker/) 페이지에서 확인할 수 있습니다. 또한 모든 파라미터가 로컬 모드에서 지원되는 것은 아닙니다.