취미로 만든 파이썬 버전 관리 시스템 I Coded Pit 소개 

TensorFlow Transform 프로덕션에서 매끄러운 데이터 준비를 위한 필수 가이드

<img src="/TIL/assets/img/2024-07-09-VisualizingModelPerformanceAGuidetoPlottingConfusionMatricesinPythonCode_0.png" />

안녕하세요! 이 기사에서는 머신러닝 모델을 평가하는데 있어서 혼동 행렬의 중요성에 대해 살펴보겠습니다. 혼동 행렬이 무엇이며, 어떻게 작동하는지, 그리고 분류 모델의 성능을 평가하는 데 왜 중요한지에 대한 자세한 설명을 제공할 것입니다. 게다가, 우리는 혼동 행렬을 그리는 Python 함수를 살펴보고, 결과를 효과적으로 해석하는 방법에 대한 통찰을 제공할 것입니다.

## 혼동 행렬 소개

혼동 행렬은 분류 알고리즘의 성능을 평가하는 데 사용되는 표입니다. 예측된 레이블을 실제 레이블과 비교하여 모델이 얼마나 잘 수행되고 있는지 명확하게 보여줍니다. 이 행렬은 모델이 어떤 종류의 오류를 범하고 있는지 이해하는 데 특히 유용하며, 개선할 부분을 식별하는 데 도움이 됩니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 혼동 행렬의 구조

이진 분류 문제의 혼동 행렬은 일반적으로 다음과 같은 모습을 갖습니다:

![Confusion Matrix](/TIL/assets/img/2024-07-09-VisualizingModelPerformanceAGuidetoPlottingConfusionMatricesinPythonCode_1.png)

다중 클래스 분류 문제의 경우, 행렬은 더 많은 클래스를 수용하도록 확장됩니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 정확도: 정확도 점수 이상의 자세한 정확도 정보를 제공합니다.
- 오류 분석: 오류 유형(거짓 양성 및 거짓 음성)을 식별하는 데 도움이 됩니다.
- 모델 개선: 오분류를 이해함으로써 모델을 개선하는 데 유용한 통찰을 제공합니다.

## Python으로 혼동 행렬 플로팅

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

def plot_confusion_matrix(cm, class_labels=None, normalize=False, figsize=(10, 10)):
    """
    레이블 및 백분율로 혼동 행렬을 플로팅합니다.

    Args:
        cm (numpy.ndarray): 혼동 행렬.
        class_labels (list, optional): 클래스에 대한 사용자 정의 레이블. 기본값은 None입니다.
        normalize (bool, optional): 백분율을 위해 혼동 행렬을 정규화할지 여부. 기본값은 False입니다.
        figsize (tuple, optional): 도표의 크기. 기본값은 (10, 10)입니다.

    Returns:
        None
    """
    n_classes = cm.shape[0]

    # 플로팅을 위한 도표 및 축 생성
    fig, ax = plt.subplots(figsize=figsize)

    # 혼동 행렬 시각화를 위한 컬러맵 생성
    cax = ax.matshow(cm, cmap=plt.cm.Blues)  # 다른 컬러맵을 사용할 수 있습니다

    # 플롯에 컬러바 추가
    fig.colorbar(cax)

    # 축 레이블 (선택사항)
    if class_labels is not None:
        labels = class_labels
    else:
        labels = np.arange(cm.shape[0])

    # 축 레이블 및 제목 설정
    ax.set(
        title="혼동 행렬",
        xlabel="예측된 레이블",
        ylabel="실제 레이블",
        xticks=np.arange(n_classes),
        yticks=np.arange(n_classes),
        xticklabels=labels,
        yticklabels=labels,
    )

    # 가독성을 높이기 위해 x축 레이블 회전
    ax.xaxis.set_label_position("bottom")
    ax.xaxis.tick_bottom()

    # 레이블 크기 조정
    plt.setp(ax.xaxis.get_majorticklabels(), size=20)
    plt.setp(ax.yaxis.get_majorticklabels(), size=20)
    ax.title.set_size(20)

    # 텍스트 색상 임계값 계산
    threshold = (cm.max() + cm.min()) / 2.

    # 필요한 경우 혼동 행렬 정규화
    if normalize:
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]

    # 혼동 행렬의 각 요소를 순회하고 텍스트 주석 추가
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        # 값 및 백분율 표시 (선택사항)
        text = f"{cm[i, j]:.2f}" if normalize else f"{cm[i, j]}"

        # 임계값에 기반한 텍스트 색상 설정
        color = "white" if cm[i, j] > threshold else "black"

        # 중앙 정렬 및 적절한 크기로 텍스트 주석 추가
        ax.text(
            j,
            i,
            text,
            ha="center",
            va="center",
            color=color,
            fontsize=15,
        )

    # 혼동 행렬 플롯 표시
    plt.show()
```

Plot Confusion Matrix 함수 사용 방법



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 혼동 행렬 생성: 플로팅하기 전에 모델의 예측과 실제 레이블을 이용해 혼동 행렬을 생성해야 합니다. 이를 위해 sklearn.metrics.confusion_matrix를 사용할 수 있습니다.

```js
from sklearn.metrics import confusion_matrix

y_pred = model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
```

2. 혼동 행렬 플로팅: 생성된 행렬로 plot_confusion_matrix 함수를 호출하세요.

```js
plot_confusion_matrix(cm, (class_labels = ["Class 0", "Class 1"]), (normalize = True));
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

혼동 행렬은 분류 모델의 성능을 평가하는 강력한 도구입니다. 이들은 모델이 얼마나 잘 수행되고 있는지에 대한 포괄적인 관점을 제공하며 개선이 필요한 부분을 강조합니다. 혼동 행렬을 시각화함으로써, 모델의 동작에 대한 더 깊은 통찰력을 얻고 미래 개선을 위한 정보를 파악할 수 있습니다.

본 문서에서는 혼동 행렬을 플로팅하는 Python 함수를 제공하고 사용 방법을 설명했습니다. 이 함수를 워크플로에 통합함으로써, 모델의 예측을 효과적으로 분석하고 해석할 수 있어 더 나은 정확도의 머신 러닝 모델에 이르게 될 것입니다.

모델 성능 시각화 Python 코드로 혼동 행렬 그리는 방법 가이드

<img src="/TIL/assets/img/2024-07-09-PortfolioOptimizationwithPyBroker_0.png" />

포트폴리오 최적화는 포트폴리오 내 자산을 특정 목표를 충족시키기 위해 할당하는 방법입니다. 예를 들어, 이는 리스크를 최소화하고 수익을 극대화하는 목표로 자산 포트폴리오를 구성하는 데 사용할 수 있습니다.

포트폴리오 최적화는 정기적으로 주식 포트폴리오를 리밸런싱하는 유용한 기술일 수 있습니다. 이 접근 방식을 통해 우리는 포트폴리오의 원하는 목표를 달성하기 위해 가장 최적의 방법으로 주식을 매수하고 매도할 수 있습니다.

이 글에서는 Python과 PyBroker를 사용하여 매월 초에 포트폴리오를 리밸런싱하는 거래 전략을 시뮬레이션하는 방법을 살펴볼 것입니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 설정

거래 전략을 시뮬레이션하기 위해서는 Python에서 백테스팅 프레임워크를 사용할 수 있습니다. 우리는 트레이딩 전략을 개발하기 위한 오픈소스 Python 프레임워크인 PyBroker을 사용할 것입니다. PyBroker을 사용하기 위해 아래의 명령어를 터미널에 입력하여 라이브러리를 설치할 수 있습니다:

```js
pip install -U lib-pybroker
```

그 다음으로, 우리가 PyBroker에서 구현할 전략을 위해 포트폴리오 최적화를 수행할 수 있는 Riskfolio-Lib을 설치해봅시다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```shell
pip install -U riskfolio-lib
```

위의 패키지를 설치한 후, 필요한 라이브러리를 import하여 새 노트북을 만들어봅시다:

```shell
import pandas as pd
import pybroker as pyb
import riskfolio as rp
from datetime import datetime
from pybroker import ExecContext, Strategy, YFinance
```

또한 PyBroker에서 데이터 캐싱을 활성화할 수도 있습니다. 이렇게 하면 Yahoo Finance로부터 다운로드된 히스토리컬 데이터가 캐싱되어 전략을 테스트할 수 있습니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
pyb.enable_data_source_cache("rebalancing");
```

## Positions Rebalancing

우리는 PyBroker를 사용하여 매달 처음에 길이만 있는 포트폴리오를 동일한 포지션 사이징을 사용하여 리밸런싱(rebalancing)하는 간단한 전략을 작성해 보겠습니다. 말하자면, 매월 초에 우리 전략은 포트폴리오의 각 주식이 대략적으로 동일한 할당을 갖도록 충분한 주식을 매수하거나 매도할 것입니다.

먼저, 주식의 목표 할당에 도달하기 위해 주식의 충분한 주식을 매수하거나 매도할 수 있는 함수를 구현하는 것으로 시작합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```python
def set_target_shares(
    ctxs: dict[str, ExecContext],  # 종목 심볼 -> 실행 컨텍스트
    targets: dict[str, float]      # 종목 심볼 -> 목표 가중치
):
    for symbol, target in targets.items():
        ctx = ctxs[symbol]
        # 목표 가중치를 사용하여 목표 주식수 계산
        target_shares = ctx.calc_target_shares(target)
        pos = ctx.long_pos()
        # 현재 해당 종목의 매수 포지션이 없는 경우 매수
        if pos is None:
            ctx.buy_shares = target_shares
        # 아니면, 목표치에 도달할 만큼 주식을 매수
        elif pos.shares < target_shares:
            ctx.buy_shares = target_shares - pos.shares
        # 현재 할당이 목표 수준을 초과하는 경우, 충분한 주식 매도
        elif pos.shares > target_shares:
            ctx.sell_shares = pos.shares - target_shares
```

현재 할당이 목표 수준을 초과하면 해당 자산의 필요 주식을 판매하고, 현재 할당이 목표 수준 미만이면 해당 자산의 필요 주식을 구매하는 함수입니다.

다음으로 매월 초에 각 주식을 동일 비중으로 타겟팅하는 리밸런싱 함수를 작성합니다:

```python
def rebalance(ctxs: dict[str, ExecContext]):
    if start_of_month(ctxs):
        target = 1 / len(ctxs)  # 동일 가중치
        set_target_shares(ctxs, {symbol: target for symbol in ctxs.keys()})
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

그럼 이제 새로운 달의 시작을 감지하는 도우미 함수를 구현해 봅시다:

```js
def start_of_month(ctxs: dict[str, ExecContext]) -> bool:
    dt = tuple(ctxs.values())[0].dt
    if dt.month != pyb.param('current_month'):
        pyb.param('current_month', dt.month)
        return True
    return False
```

이제 이러한 함수들을 사용하여 다섯 가지 주식 포트폴리오를 위한 리밸런싱 전략을 백테스트할 수 있습니다.

```js
strategy = Strategy(YFinance(), (start_date = "1/1/2018"), (end_date = "1/1/2023"));
strategy.add_execution(None, ["TSLA", "NFLX", "AAPL", "NVDA", "AMZN"]);
strategy.set_after_exec(rebalance);
result = strategy.backtest();
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

백테스트를 실행한 후에는 주문 목록을 확인할 수 있습니다:

```js
result.orders;
```

```js
     type symbol date        shares  limit_price  fill_price  fees
id
1    buy  NFLX   2018-01-03  99      NaN          203.86      0.0
2    buy  AAPL   2018-01-03  464     NaN           43.31      0.0
3    buy  TSLA   2018-01-03  935     NaN           21.36      0.0
4    buy  AMZN   2018-01-03  336     NaN           59.84      0.0
5    buy  NVDA   2018-01-03  376     NaN           52.18      0.0
... ... ... ... ... ... ... ...
292  sell NFLX   2022-12-02   15     NaN         315.99       0.0
293  sell NVDA   2022-12-02   97     NaN         166.89       0.0
294  buy  AAPL   2022-12-02   27     NaN         146.82       0.0
295  buy  TSLA   2022-12-02   70     NaN         193.68       0.0
296  buy  AMZN   2022-12-02   41     NaN          94.57       0.0
```

그리고 우리의 전략을 평가하기 위한 성능 지표를 확인할 수 있습니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
result.metrics_df;
```

```js
trade_count                 207.000000
initial_market_value     100000.000000
end_market_value         320498.810000
total_pnl                305804.840000
total_return_pct            305.804840
max_drawdown            -332039.770000
max_drawdown_pct            -52.068777
```

## 포트폴리오 최적화 사용

포트폴리오에서 각 주식을 동일한 포지션 크기로 할당하는 대신, 포트폴리오 최적화를 사용하여 각 주식의 할당을 결정해 보겠습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

Riskfolio-Lib을 사용하여 포트폴리오에서 각 주식에 할당해야 하는 금액을 최소화하여 리스크를 계산할 수 있어요. 이것은 각 주식과 연관된 과거 리스크를 측정함으로써 할 수 있어요.

조건부 가치위험(CVaR)은 각 주식의 위험을 평가하는 한 가지 방법이에요. 특정 확률 수준 이상의 최악의 시나리오에서 예상 손실을 제공해요. 예를 들어, CVaR은 95% 신뢰 수준을 고려할 때 시나리오 중 최악의 5%에서의 평균 손실을 추정할 수 있어요.

아래에서는 작년의 수익률을 사용하여 CVaR을 최소화하고 포트폴리오에 할당하기 위해 RiskFolio-Lib을 사용했어요.

```js
pyb.param('lookback', 252)  # 작년의 수익률 사용 -> 252 바.

def calculate_returns(ctxs: dict[str, ExecContext], lookback: int):
    prices = {}
    for ctx in ctxs.values():
        prices[ctx.symbol] = ctx.adj_close[-lookback:]
    df = pd.DataFrame(prices)
    return df.pct_change().dropna()

def optimization(ctxs: dict[str, ExecContext]):
    if start_of_month(ctxs):
        Y = calculate_returns(ctxs, lookback)
        port = rp.Portfolio(returns=Y)
        port.assets_stats(method_mu='hist', method_cov='hist', d=0.94)
        # CVaR을 최소화한 후 목표 가중치 얻기.
        w = port.optimization(
            model='Classic',
            rm='CVaR',
            obj='MinRisk',
            rf=0,      # 무위험 이자율.
            l=0,       # 리스크 회피 계수.
            hist=True  # 과거 시나리오 사용.
        )
        targets = {
            symbol: w.T[symbol].values[0]
            for symbol in ctxs.keys()
        }
        set_target_shares(ctxs, targets)
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

Riskfolio-Lib의 공식 문서에서 더 많은 정보와 예제를 찾을 수 있어요. 이제 전략의 백테스팅으로 넘어가 볼까요?

```js
strategy.set_after_exec(optimization);
result = strategy.backtest((warmup = pyb.param("lookback")));
```

여기서는 새 전략의 성과 지표를 확인해 봅시다:

```js
trade_count                     100.000000
initial_market_value         100000.000000
end_market_value             201318.070000
total_pnl                    139465.420000
total_return_pct                139.465420
max_drawdown                -106042.150000
max_drawdown_pct                -35.190829
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

흥미로운 내용이에요! 이 전략을 사용한 수익률이 평균 포지션 사이즈와 비교했을 때 적은 것을 볼 수 있어요 (139% vs 305%), 그런데 최대 손실액은 낮았다는 것도 알 수 있어요 (35% vs 52%). CVaR을 최소화하는 것이 포트폴리오의 전체 수익률을 크게 줄였다는 점을 고려해봤을 때, 이에 따라 포트폴리오의 하락폭도 크게 감소했어요!

그리고 이 글로 마무리 지을게요! 이제 여러분도 포트폴리오 최적화를 자신만의 거래 전략에 사용하는데 충분히 장비가 되었을 거에요. 또한 https://www.pybroker.com에서 PyBroker 사용에 대한 더 많은 튜토리얼을 찾아볼 수 있어요. 모든 코드는 Github 저장소에서 확인할 수 있어요.

읽어 주셔서 감사합니다!

PyBroker를 사용한 포트폴리오 최적화 방법

오늘은 Greg Kamradt의 "The LangChain Cookbook - 7 Core Concepts"의 나머지 챕터들을 끝까지 리뷰하겠습니다!

- Indexes - 문서를 LLM이 작업하기 쉽도록 구조화하는 것

- 문서 로더

원본 코드의 이 부분은 변경 없이 작동했습니다. 그러나 다양한 문서 로더에 대한 참조 링크가 깨져 있어서 해당 로더를 검색했습니다. 현재 지원되는 문서 로더 목록은 아래와 같습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# URL 및 웹페이지

unstructured 모듈을 설치해야 합니다.

```js
!pip install unstructured
```

만약 이 모듈이 설치되어 있다면, 원래 코드가 작동될 것입니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

아래와 같은 표를 Markdown 형식으로 변경해주세요.

| Header One | Header Two |
| ---------- | ---------- |
| Item One   | Item Two   |



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

faiss를 설치해야 합니다. CPU만 사용하는 경우 다음과 같이 설치할 수 있습니다:

```js
!pip install faiss-cpu
```

(Nvidia GPU를 사용하는 머신의 경우, 다음 명령을 사용할 수 있습니다: !pip install faiss-gpu)

다음으로, OpenAIEmbeddings의 import 문을 블로그 포스트 Part 2에서 한 것처럼 변경하겠습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
#langchain.embeddings에서는 OpenAIEmbeddings를 사용합니다.
from langchain_openai import OpenAIEmbeddings
```

저는 `get_relevant_documents` 대신 `invoke`를 사용했습니다.

```js
# docs = retriever.get_relevant_documents("저자가 건설하고 싶어했던 것의 종류는 무엇인가요?")
docs = retriever.invoke("저자가 건설하고 싶어했던 것의 종류는 무엇인가요?")
```

이 두 가지 변경으로 원래 코드가 작동하게 되었고, 벡터 저장소를 사용하여 LLM에서 응답을 받을 수 있었습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# VectorStores

이것도 아래와 같이 OpenAIEmbeddings 클래스의 import 소스를 변경함으로써 쉽게 작동합니다.

```js
#from langchain.embeddings import OpenAIEmbeddings
from langchain_openai import OpenAIEmbeddings
```

# Memory



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

원래 코드는 그대로 작동합니다. Langchain의 다양한 메모리 유형 목록에 대한 링크가 깨져 있어 찾아보았습니다. 아래에서 확인할 수 있습니다.

# 체인

SimpleSequentialChain 및 LLMChain이 사용되지 않게 되어 전체적으로 많은 변경을 해야 했습니다. 아래 정보에 따르면 LLMChain 대신 RunnableSequence를 사용하라고 나와 있어서 이 안내에 따르기로 결정했습니다.

두 개 이상의 RunnableSequence를 결합하는 방법을 찾지 못해 당황했습니다. LangChain 문서를 살펴본 결과 아래와 같이 "다중 체인"이라는 문서를 발견했습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

여기에 작성된 샘플을 참고하여, StrOutputParser를 통해 두 ChatPromptTemplate을 결합해보려고 했고, Cookbook처럼 작동하는 체인을 생성할 수 있었습니다.

```js
from operator import itemgetter

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

prompt1 = ChatPromptTemplate.from_template(
"""사용자가 제안한 지역의 고전 요리를 생각해 내는 것이 당신의 일입니다.
% 사용자 위치
{user_location}

당신의 응답:
"""
)

prompt2 = ChatPromptTemplate.from_template(
"""한 끼 식사가 주어지면, 그 요리를 집에서 어떻게 만들 수 있는 간단한 레시피를 제시해 주세요.
% 요리
{user_meal}

당신의 응답:
"""
)

model = ChatOpenAI(temperature=0, openai_api_key=openai_api_key)

chain1 = prompt1 | model | StrOutputParser()
chain2 = {"user_meal": chain1} | prompt2 | model | StrOutputParser()

chain2.invoke({"user_location": "Paris"})
```

ChatPromptTemplate를 모델과 StrOutputParser에 연결하여 객체를 생성했습니다. Prompt1을 모델에 입력하고 출력 AIMessage를 StrOutputParser를 통해 문자열로 변환했습니다. 이 체인1의 출력에서 "user_meal": "chain1 출력"과 같은 PromptTemplate의 입력을 만들고, prompt2에 연결하여 모델 → StrOutputParser로 연결합니다. 완성된 체인에 "Paris"를 user_location으로 입력했을 때 결과는 다음과 같습니다:

‘집에서 Coq au Vin을 만들려면, 큰 냄비에 베이컨을 볶아주세요. 베이컨을 꺼내고 베이컨 기름에 닭 조각을 볶아주세요. 다진 양파와 버섯을 넣고 레드 와인과 치킨 육수를 부어주세요. 약 1시간 정도 닭이 익고 소스가 농도가 될 때까지 강한 불에서 조리해주세요. 베이글이나 감자 퓨레 위에 또는 후식으로 인기 많은 Crusty Bread와 함께 뜨거운 상태로 제공하세요. 집에서 만든 Coq au Vin을 즐기세요!’



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

chain1의 출력물은 "Coq au Vin"입니다. 그 입력을 사용하여 chain2는 "Coq au Vin"을 어떻게 만드는지 설명합니다. Coq au Vin은 나에게는 전혀 익숙하지 않았던 요리였지만, 빨갛게 푹 구운 수탉 요리인 것 같습니다... 그 요리 이름이 전혀 익숙하지 않아서 사용자 위치로 오사카를 입력해보았더니:

```js
chain2.invoke({ user_location: "Osaka" });
```

아래와 같이 오떼노미야키를 만드는 방법을 안내해주었습니다. 이를 통해 드디어 제대로 작동하고 있다는 느낌이 들었습니다.

'집에서 오떼노미야키를 만들려면, 그릇에 밀가루 1컵, 갈아 만든 야무 1컵, 달걀 2개, 다진 양배추 1컵을 섞어주세요. 돼지고기, 새우 또는 채소와 같은 자신의 선택한 토핑을 추가하세요. 팬이나 비스듬한 팬을 예열하고 형태를 부여하여 배터를 담구면을 붓세요. 각 면이 황금색이 될 때까지 며칠씩 조리하세요. 오떼노미야키를 달콤하고 매콤한 소스, 마요네즈, 윗부분에 가는 안주 살짝 뿌려서 내세요. 만들어진 오떼노미야키를 즐기세요!'



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 요약 체인

Cookbook의 코드 부분은 변경 없이 작동했기 때문에 넘어갈게요.

# 에이전트

먼저, google-search-results 모듈을 설치해야 했어요.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
!pip install google-search-results
```

아래 링크에서 SERP_API_KEY를 얻었습니다.

키를 SERP_API_KEY 환경 변수에 저장했습니다.

```js
from dotenv import load_dotenv
import os

load_dotenv()

serp_api_key=os.getenv('SERP_API_KEY', 'your_api_key')
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

가장 큰 변화는 initialize_agent 함수가 사용되지 않게 되어서 Agent를 호출하는 방법을 근본적으로 변경해야 했다는 것이었습니다.

```js
from langchain.agents import load_tools
# from langchain.agents import initialize_agent
from langchain.llms import OpenAI
import json
from langchain import hub
from langchain.agents import AgentExecutor, create_react_agent

llm = OpenAI(temperature=0, openai_api_key=openai_api_key)
toolkit = load_tools(["serpapi"], llm=llm, serpapi_api_key=serp_api_key)
# agent = initialize_agent(toolkit, llm, agent="zero-shot-react-description", verbose=True, return_intermediate_steps=True)
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(model, toolkit, prompt)
agent_executor = AgentExecutor(agent=agent, tools=toolkit, verbose=True)
agent_executor.invoke({"input":"what was the first album of the"
                    " band that Natalie Bergman is a part of?"})
```

원래 코드는 "zero-shot-react-description"이라는 메모리가 없는 ReAct 프레임워크 에이전트의 인스턴스를 생성했기 때문에, 아래 정보를 참고하여 코드를 다시 작성했습니다.

ReAct라는 용어는 익숙하지 않았지만 아래 설명대로 보면, 추론과 행동을 연결하고 이를 통해 얻은 피드백을 사용하여 다음 추론 단계로 넘어가는 에이전트 구성 방식인 것 같습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 샘플에 사용된 프롬프트는 LangSmith에서 공개된 프롬프트이며, 해당 프롬프트의 내용을 아래에서 확인할 수 있었습니다.

이 에이전트를 상세 모드로 실행할 때 아래와 같은 추론 프로세스가 실행되고 있다는 것을 확인할 수 있었습니다.

![이미지](/TIL/assets/img/2024-07-09-LLMStudyDiaryComprehensiveReviewofLangChainPart4_0.png)

최종 답변은 다음과 같았습니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
{'input': '나탈리 베르그먼이 소속된 밴드의 첫 앨범은 무엇인가요?',
'output': 'Wild Belle'}
```

원래 질문은 "나탈리 베르그먼이 속한 밴드의 첫 앨범은 무엇인가요?"였습니다. 다시 말해서 "나탈리 베르그먼이 속한 밴드의 첫 앨범의 이름을 알려주세요"였습니다. 그러나 최종 답변은 그녀가 속한 밴드의 이름이 나왔습니다. 로그를 보니, 에이전트가 문제를 이해하지 못한 것으로 보입니다.

카름 레이 안사생님은 유튜브 비디오에서 에이전트 기술이 아직 발전 중이라고 언급했습니다. 그러나 Langchain을 사용할 때 이러한 추론이 어떻게 진행되는지 로그를 확인하는 것이 유용할 수 있을 것 같으므로, 앞으로 다양한 에이전트를 살펴보는 기회를 더 만들고 싶습니다.

이를 통해 카름 레이 안사생님의 "The LangChain Cookbook — 7 Core Concepts"의 모든 레시피를 마지막 레시피를 포함하여 제가 작업하며 성공적으로 수행했습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

때로는 너무 많은 것이 더 이상 사용되지 않아서 포기해야 한다고 생각했던 적이 있었지만, 모든 샘플이 성공적으로 작동되었어요.

이 과정에서 살펴보지 못한 관련된 여러 가지 사항들이 있어서, 그것들을 모두 조사하고 다른 샘플들을 탐구하여 가능하다면 다른 노트에서 소개하고 싶어요.

독서해 주셔서 감사합니다!

네 목차 블로그 시리즈 끝까지 읽어 주셔서 감사합니다. 이 게시물들이 유익하고 통찰력있었기를 바랍니다. 여러분의 지속적인 관심은 저에게 AI 및 언어 기술에 대한 지식을 공유하는 동기가 되었어요.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

현재 시리즈를 마침하지만, AI 및 언어 기술에 대한 여정은 아직 끝나지 않았습니다. 이 블로그에 대한 질문이나 OpenAI API, LLM 또는 LangChain과 관련된 개발 프로젝트에 관심이 있다면 저에게 연락해 주세요.

Goldrush Computing에서는 일본어 원어민을 보유한 일본 기업으로서의 전문성을 자랑합니다. 우리는 일본어와 문화에 맞춘 프롬프트 및 RAG 시스템을 개발하는 것에 특화되어 있습니다. 일본 시장용 AI 솔루션을 최적화하거나 일본어 애플리케이션을 개발하려는 경우, 저희는 도와드릴 준비가 되어 있습니다. 일본에 특화된 AI 최적화가 필요한 협업이나 프로젝트가 있다면 망설이지 말고 연락해 주세요.

아래 이메일 주소로 직접 연락해 주세요!

```js
mizutori@goldrushcomputing.com
```

LangChain 심층 분석  Part 4 최신 LLM 스터디 다이어리

서버 전송 이벤트(Server-Sent Events, SSE)는 서버가 싱글 HTTP 연결을 통해 웹 클라이언트에 실시간 업데이트를 푸시할 수 있는 서버 푸시 기술입니다. 대시보드, 알림 또는 실시간 분석과 같이 실시간 업데이트가 필요한 애플리케이션에 특히 유용합니다.

![SSE](/TIL/assets/img/2024-07-09-Server-SentEventSSEinFastAPIApplications_0.png)

## SSE 소개

- SSE는 서버가 초기 클라이언트 연결을 설정하자마자 브라우저 클라이언트로 데이터 전송을 시작할 수 있는 표준입니다.
- 웹소켓과 달리 SSE는 양방향 통신이 아닌 단방향이며, 서버에서 클라이언트로 데이터가 흐릅니다.
- 이로써 SSE는 서버가 클라이언트로 업데이트를 푸시해야 하는 경우에 더 간단한 대안이 됩니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 왜 SSE를 사용해야 하나요?

SSE는 다음과 같은 시나리오에서 유용합니다:

- 실시간 업데이트: 실시간 업데이트를 클라이언트에 푸시해야 하는 애플리케이션들, 예를 들어 실시간 스포츠 점수, 주식 시장 업데이트, 또는 채팅 애플리케이션 등.
- 서버 모니터링 및 대시보드: 실시간 모니터링 대시보드는 SSE를 활용하여 클라이언트가 서버를 계속 폴링할 필요 없이 메트릭 및 상태를 업데이트할 수 있습니다.
- 알림: 서버에서 보내는 알림을 SSE로 효율적으로 관리할 수 있어서, 클라이언트 측에서 지속적으로 폴링할 필요가 줄어듭니다.
- 스트리밍 데이터: 대용량 데이터 세트나 로그를 실시간으로 스트리밍하는 것을 SSE로 간단하게 구현할 수 있습니다.

# FastAPI에서 SSE 구현하기



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

FastAPI은 속도와 사용 편의성으로 유명하며, sse-starlette 라이브러리와 통합하여 SSE를 구현하는 데 잘 작동합니다. 다음은 설정 방법입니다.

# 예제 구현

## 단계 1: 필요한 라이브러리 설치

먼저, FastAPI와 sse-starlette를 설치하세요:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
pip install fastapi sse-starlette
```

## Step 2: FastAPI 애플리케이션 생성

```js
from fastapi import FastAPI
from sse_starlette.sse import EventSourceResponse
import asyncio

app = FastAPI()
async def event_generator():
    while True:
        await asyncio.sleep(1)
        yield {"data": "This is a server-sent event!"}
@app.get("/events")
async def sse_endpoint():
    return EventSourceResponse(event_generator())
```

이 예시에서 event_generator는 매 초마다 새 이벤트를 생성하는 비동기 생성자입니다. sse_endpoint 엔드포인트는 EventSourceResponse를 사용하여 SSE 연결을 처리합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## FastAPI에서 SSE 사용 사례

- 대시보드용 실시간 업데이트:

  - SSE는 모니터링 시스템이나 실시간 분석 대시보드와 같은 실시간 메트릭을 표시하는 애플리케이션에 복잡한 WebSocket 관리 없이 업데이트를 푸시하는 간단한 방법을 제공합니다.

- 실시간 알림:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 사용자에게 이벤트 알림이 필요한 애플리케이션(메신저 앱이나 알림 시스템과 같은)은 SSE를 사용하여 이러한 업데이트를 신속하게 전달할 수 있습니다.

- 스트리밍 로그:

- SSE는 실시간 로그나 기타 스트리밍 데이터를 표시해야 하는 애플리케이션에 잘 맞는 가벼운 솔루션입니다.

## SSE의 장점:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 간편함: SSE는 웹소켓에 비해 구현과 관리가 간단합니다.
- 자동 재연결: 브라우저가 자동으로 재연결을 처리하여 SSE가 실시간 업데이트에 강력합니다.
- HTTP 호환성: SSE는 표준 HTTP/2 연결을 통해 작동하므로 기존 인프라와 작업하기 쉽습니다.

## SSE 대안:

- 웹소켓:

- 양방향 통신: 양방향 통신이 필요한 경우 웹소켓을 선호합니다.
- 낮은 지연 시간: 웹소켓은 SSE보다 낮은 지연 시간을 제공하여 온라인 게임과 같이 매우 상호작용적인 애플리케이션에 적합합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- Long Polling:

- 호환성: Long polling은 오래된 브라우저와 호환되며 WebSockets이나 SSE를 지원하지 않는 경우에 사용할 수 있습니다.
- 오버헤드: 반복된 요청으로 인해 SSE나 WebSockets에 비해 더 많은 오버헤드를 도입합니다.

# SSE의 현실 세계에서의 사용 사례

서버-전송 이벤트 (SSE)는 실시간 업데이트를 필요로하는 현실 세계 애플리케이션에서 널리 사용되고 있습니다. 여기에 몇 가지 주목할 만한 예시가 있습니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 라이브 스포츠 스코어
- 주식 시장 및 금융 데이터
- 소셜 미디어 플랫폼 등등..

우리는 ESPN이나 BBC Sports와 같이 제공되는 라이브 스포츠 스코어 업데이트 애플리케이션의 예시를 더 자세히 살펴보겠습니다.

진행 중인 축구 경기에 대한 실시간 업데이트를 제공하는 라이브 스포츠 스코어 애플리케이션을 상상해보세요. 이 애플리케이션은 골 득점 및 경기 통계와 같은 업데이트를 제공해야 합니다. 이곳이 [GitHub 링크](GitHub Link).

## SSE 구현



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 서버 측 구현:

아래 파일은 경기 개요를 포함하고 있습니다.

```js
// scores.py

[
  {
    time: "00:01",
    scores: "1:0",
    event: "Goal! Team A scores!",
  },
  {
    time: "00:05",
    scores: "1:1",
    event: "Goal! Team B scores!",
  },
  {
    time: "00:10",
    scores: "2:1",
    event: "Goal! Team A scores again!",
  },
];
```

- 서버는 경기 데이터의 실시간 피드를 유지하며 SSE를 사용하여 연결된 클라이언트에게 전송합니다.
- 어떤 이벤트(골, 교체 등)가 발생할 때마다, 서버는 이 업데이트를 모든 연결된 클라이언트에게 푸시합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# main.py

from fastapi import FastAPI
from sse_starlette.sse import EventSourceResponse
import asyncio
import json

app = FastAPI()

async def event_generator():
with open("scores.json", "r") as file:
scores = json.load(file)
for score in scores:
await asyncio.sleep(5)  
 yield f"Match Summary: {json.dumps(score)}\n\n"

@app.get("/live-scores")
async def live_scores_endpoint():
return EventSourceResponse(event_generator())

# Adding CORS middleware

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)

Client-Side Implementation:

- 웹 응용 프로그램인 클라이언트는 서버와 SSE 연결을 설정하고 업데이트를 수신합니다.

```html


<!DOCTYPE html>
<html>
  <head>
    <title>Live Sports Scores</title>
  </head>
  <body>
    <h1>Live Football Scores</h1>
    <div id="score-updates"></div>

    <script>
      const eventSource = new EventSource("http://127.0.0.1:8000/live-scores");

      eventSource.onmessage = function (event) {
        const newElement = document.createElement("div");
        newElement.innerHTML = event.data;
        document.getElementById("score-updates").appendChild(newElement);
      };

      eventSource.onerror = function (event) {
        console.error("EventSource failed:", event);
        eventSource.close();
      };
    </script>
  </body>
</html>
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 참고

- https://fastapi.tiangolo.com/
- https://pypi.org/project/sse-starlette/

# 결론

sse-starlette를 사용하면 FastAPI 애플리케이션에 SSE를 통합하는 것이 간편하고 효율적입니다. 실시간 대시보드, 알림 시스템 또는 데이터 스트리밍 애플리케이션을 개발 중이든, SSE는 견고하고 간편한 해결책을 제공합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

읽어 주셔서 감사합니다! 만일 어떠한 오류를 발견하시거나 개선 제안이 있으시다면 아래 댓글에 공유해 주세요.

이 글이 마음에 들었다면 👏 버튼을 눌러 다른 사람들이 발견할 수 있도록 도와주세요. GitHub에서 제 프로필을 팔로우하고 LinkedIn에서 저와 연결해도 괜찮아요.

FastAPI 애플리케이션에서 Server-Sent EventSSE 사용 방법

![Python One Billion Row Challenge](/TIL/assets/img/2024-07-09-PythonOneBillionRowChallengeFrom10Minutesto4Seconds_0.png)

요즘에는 프로그래밍 언어가 10억 행의 데이터를 통합하는 속도에 대한 문제가 주목을 받고 있습니다. 성능이 가장 우수하지 않은 Python은 당연히 특히 현재 최상위 성능을 발휘하는 Java 구현이 단 몇 초(1.535초)만에 처리 가능하다는 점에서 거의 기회가 없습니다!

도전의 근본적인 규칙은 외부 라이브러리를 사용하지 않는 것입니다. 오늘의 목표는 규칙을 준수한 후에 외부 라이브러리와 더 적합한 파일 형식을 사용했을 때 결과가 어떻게 나오는지 살펴보는 것입니다.

모든 스크립트를 5회 실행하여 결과를 평균화했습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

하드웨어로는 12개 CPU 코어와 36 GB RAM이 장착된 16인치 M1 Pro MacBook Pro를 사용하고 있습니다. 코드를 실행할 경우 결과가 다를 수 있지만, 구현 사이에는 비슷한 백분율 차이를 볼 수 있을 것입니다.

## 코드

- GitHub 저장소 — Python으로 10억 행 도전

# 10억 행 도전이란 무엇인가요?



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

1 Billion Row Challenge (1BRC)의 아이디어는 간단합니다 - .txt 파일을 통해 10억 행의 데이터를 처리하는 것입니다.

1억 행 파이썬 처리 도전  10분에서 4초로 줄이는 방법

## Python for devops v1.2 - 구버전/지원 중단된 런타임을 사용 중인 AWS 람다 함수의 업그레이드를 위한 Python 스크립트 작성하기.

![이미지](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_0.png)

저의 블로그 시리즈 Python for DevOps의 두 번째 블로그 포스트입니다. 여기서는 실제 데브옵스 사용 사례를 탐구하면서 Python 스크립트를 작성해봅니다.

Python for devops 첫 번째 부분 - SQS 큐 암호화 자동화



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 시나리오

보안 팀으로부터 수백 개의 Lambda 함수가 Python 3.8 및 Node.js 14x와 같은 지원되지 않는 런타임을 실행 중이라는 불만을 받았다고 가정해 봅시다. AWS는 Lambda 함수의 오래된 런타임을 자동으로 업데이트하지 않습니다.

이 모든 Lambda 함수를 수동으로 업데이트하는 것은 고통스러울 수 있습니다. 책임감 있는 Devops 엔지니어로서, 이러한 수동 작업을 피하고 이러한 작업을 자동화하기 위한 재사용 가능한 Python 스크립트를 작성하고 싶어 합니다.

# 블로그 포스트에서 다룰 내용은 무엇인가요?



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 블로그 포스트에서는 람다 런타임 업데이트를 자동화하는 방법을 가르쳐 드리겠습니다. 우리의 스크립트는 원하는 Python 버전을 인수로 받아 이전 버전을 사용 중인 람다를 나열한 후 런타임을 원하는 버전으로 업그레이드할 것입니다.

## 따를 단계들

- Lambda를 위한 boto3 클라이언트 생성.
- AWS 계정의 해당 지역 내 모든 람다 함수를 나열.
- 람다 함수의 런타임 가져오기.
- 람다 런타임이 원하는 버전보다 낮은지 유효성 검사.
- 람다 런타임을 원하는 버전으로 업그레이드.
- 스크립트를 작성하는 동안 최선의 실천 방법을 준수할 것입니다.

# 선행 조건:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 지역 머신에서 AWS 자격 증명을 구성하려면 aws configure 명령을 실행하세요. 최근 블로그 게시물의 지침을 따라 주세요.
- AWS CLI 명령을 실행하여 이전 버전의 Python 런타임에서 실행되는 몇 가지 샘플 람다 함수를 만드세요.

# Python 스크립트 개발을 진행하기 전에 사전 설정을 해봅시다 — 데모 람다 함수 생성.

## 1. 배포 패키지 준비

- 람다 함수 코드를 위한 디렉터리를 만드세요.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
mkdir my-lambda-function
cd my-lambda-function
```

- 람다 함수 코드를 생성하세요 (예: lambda_function.py)

```js
def lambda_handler(event, context):
    return "Hello, World!"
```

- 디렉토리 내용을 압축하세요



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```bash
zip -r deployment-package.zip .
```

## 2. Create a Lambda Execution Role

- Create a trust policy (e.g., trust-policy.json)

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- IAM 역할을 생성하세요

```js
aws iam create-role --role-name MyLambdaExecutionRole --assume-role-policy-document file://trust-policy.json
```

![연결된 이미지](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_1.png)

- 역할에 AWSLambdaBasicExecutionRole 정책을 연결하세요



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

aws iam attach-role-policy --role-name MyLambdaExecutionRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

## 3. 람다 함수 배포하기

- 람다 함수를 만드는 AWS CLI 명령어는 다음과 같이 보일 것입니다.

aws lambda create-function \
 --function-name MyPython38Function \
 --runtime python3.8 \
 --role arn:aws:iam::YOUR_ACCOUNT_ID:role/YOUR_LAMBDA_EXECUTION_ROLE \
 --handler lambda_function.lambda_handler \
 --zip-file fileb://path/to/your/deployment/package.zip



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 이제 IAM 역할과 배포 패키지를 사용하여 3개의 람다 함수를 배포할 예정입니다.

```js
aws lambda create-function \
    --function-name medium-blog-lambda1 \
    --runtime python3.8 \
    --role arn:aws:iam::366130468123:role/MyLambdaExecutionRole \
    --handler lambda_function.lambda_handler \
    --zip-file fileb://my-lambda-function/deployment-package.zip \
    --timeout 15 \
    --memory-size 128
```

아래와 같이 3개의 람다 함수가 생성됩니다.

![이미지](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_2.png)



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이제 파이썬 스크립트 작성을 시작할 준비가 끝났어요.

파이썬 코드를 작성하기 전에, 최고의 방법을 따라 파이썬 환경을 설정해보겠어요.

## 파이썬 가상 환경 만들기

```js
# 가상 파이썬 환경 만들기
python3 -m venv medium_blog

# 가상 환경 활성화하기
source medium_blog/bin/activate
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- requirements.txt 파일을 생성하고 해당 파일에 의존성을 넣어주세요.

boto3는 Python 라이브러리로, Python을 사용하여 AWS 리소스와 통신할 수 있게 해줍니다.

# requirements.txt

boto3

- 의존성을 설치해주세요



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
pip install -r requirements.txt
```

# 이제 설정을 완료했으니, 파이썬 스크립트를 작성해 볼까요?

우리는 코드를 작은 부분, 즉 함수로 나누어 각 함수가 한 가지 작업을 수행하도록 할 수 있어요.

참고: 블로그 포스트의 전체 코드는 제 공개 GitHub에 올릴 예정이에요.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 1. Python 모듈을 가져와 boto3를 사용하여 람다 클라이언트를 만듭니다

![lambda client](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_3.png)

## 2. 모든 람다를 나열하는 함수 — 람다 함수 목록을 반환합니다.

![list lambdas](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_4.png)



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 기능은 lambda_client를 사용하여 Lambda 함수 목록을 가져와 반환합니다.

list_functions()[“Functions”] 대신 list_functions().get(“Functions”, None)을 사용하여 응답에 “Functions” 키가 없을 때 KeyError를 방지할 수 있습니다. 이렇게 하면 코드가 기본값인 None을 반환하므로 더 견고하고 런타임 오류를 방지할 수 있습니다.

## 3. 람다 런타임 가져오기.

<img src="/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_5.png" />



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 함수는 lambda_json_list에 있는 딕셔너리에서 FunctionName과 Runtime을 추출하고(Runtime 값이 없는 경우에는 컨테이너 기반 람다 함수의 경우), 이름과 런타임을 포함하는 튜플의 목록을 반환합니다.

4. 원하는 런타임과 런타임을 비교하고 런타임이 원하는 것보다 낮으면 True를 반환합니다.

![이미지](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_6.png)

버전 클래스는 packaging.version 모듈에서 사용되며 버전 문자열을 구문 분석하고 비교하는 데 사용됩니다. 이 함수에서는 현재 런타임 버전이 지정된 버전보다 이전 버전인지 확인합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 5. 비교 함수가 True 값을 반환하면 람다 런타임을 업데이트합니다.

![Lambda Runtime Update](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_7.png)

이 함수는 람다 함수를 새로운 런타임으로 업데이트합니다.

예외 처리를 위해 try/except 블록을 사용했습니다. 이를 통해 예기치 않은 오류를 관리하고 대응할 수 있습니다. try 블록 내에서 위험한 작업을 시도하고 그에 따른 예외를 except에서 처리하여 프로그램이 오류로 인해 충돌하지 않고 우아하게 회복될 수 있도록 합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 6. 조각들을 함께 모으기

![이미지](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_8.png)

## 7. 스크립트 실행하기

![이미지](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_9.png)



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

위의 코드 스니펫을 모두 `update_lambda_runtimes.py` 파일에 붙여넣고 아래 명령어를 실행하여 스크립트를 실행합니다.

```js
python update_lambda_runtimes.py
```

`__name__`이 `'__main__'`인 상태에서 스크립트를 실행할 때만 `run()` 함수가 실행되도록 하여 스크립트를 실행합니다.

스크립트의 유용성을 높이기 위해 명령줄 인수를 받을 수 있도록 활성화해야 합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

![Automatic Outdated AWS Lambda Runtime Updates](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_10.png)

이 함수는 Python에서 argparse 모듈을 사용하여 명령줄 인자 파서를 만듭니다. 스크립트 실행 시 제공해야 할 인수인 python_version (단축 형식 -a)을 기대합니다.

## 명령줄 인수를 사용하여 스크립트 실행

![Automatic Outdated AWS Lambda Runtime Updates Example](/TIL/assets/img/2024-07-09-AutomateOutdatedAWSLambdaRuntimeUpdates_11.png)



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```python
python update_lambda_runtimes.py --python-version python3.9
```

블로그 게시물의 전체 코드는 제 공개 GitHub 리포지토리에서 찾을 수 있습니다. 다음 링크를 사용하여 액세스하세요.

## 무엇을 더 해야 할까요?

- 로깅 사용하기.
- 코드 문서화 및 타입 힌트 사용하기.
- NodeJS, Go 등 다른 런타임을 포함하는 스크립트 확장하기.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

저와 LinkedIn에서 연락하세요: [https://www.linkedin.com/in/akhilesh-mishra-0ab886124/](https://www.linkedin.com/in/akhilesh-mishra-0ab886124/)

구버전 AWS Lambda 런타임 자동 업데이트 방법

# 먼저, FastAPI에 대한 간결한 소개부터 시작해보겠습니다.

FastAPI는 Python으로 API를 구축하기 위한 현대적인 웹 프레임워크입니다. Sebastián Ramírez가 만들었으며, 빠르고 사용하기 쉽며 기능이 풍부하여 인기를 얻고 있습니다.

FastAPI는 여러 이유로 눈에 띕니다:

- 속도: 사용 가능한 Python 프레임워크 중 가장 빠릅니다.
- 사용 편의성: Python의 타입 힌트 덕분에 코드 작성이 직관적이고 명확합니다.
- 대화형 문서: Swagger UI 및 ReDoc와 같은 도구를 사용하여 대화형 API 문서를 자동으로 생성합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

FastAPI은 웹 부분에 Starlette(Starlette은 Python에서 비동기 웹 서비스를 구축하기에 이상적인 가벼운 ASGI 프레임워크/도구)를 기반으로 하고 데이터 유효성 검증을 위해 Pydantic을 사용하여 빠르고 신뢰성이 높습니다.

이 글에서는 FastAPI가 인기 있는 이유, 주요 특징, 그리고 직접 API를 구축하기 위해 FastAPI를 시작하는 방법을 살펴보겠습니다. 경험 많은 개발자든 API 개발에 처음 도전하는 개발자든 FastAPI를 사용하면 효율적이고 확장 가능한 웹 애플리케이션을 손쉽게 만들 수 있습니다.

# Flask와 Django와 비교한 FastAPI의 핵심 기능 및 이점

Flask와 Django와 비교했을 때, FastAPI는 다음과 같은 특징으로 두각을 나타냅니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 성능 우수성: FastAPI는 Starlette과 Pydantic을 활용하여 빠른 속도에서 Node.js와 Go와 경쟁하며 효율적인 성능을 제공합니다.
- 사용 편의성 및 개발 속도: FastAPI의 간단한 구문과 자동 문서화(Swagger UI, ReDoc)는 개발을 가속화시켜 오류를 줄입니다.
- 데이터 유효성 검사 및 보안: 통합된 Pydantic은 견고한 데이터 유효성을 보장하여 API 신뢰성을 향상시킵니다. FastAPI는 인증 및 권한 부여를 위한 내장 도구로 보안을 간소화합니다.
- 비동기 지원 및 확장성: 비동기 프로그래밍에 대한 일류 지원은 병렬 요청 처리를 가능하게 하며 높은 수요 애플리케이션의 확장성에 중요합니다.

FastAPI는 이러한 분야에서 뛰어나므로 Python 기반 API 프레임워크에서 속도, 확장성 및 개발의 편의성을 필요로 하는 개발자에게 플라스크와 장고 대비 매력적인 선택지입니다.

# FastAPI로 시작하기

FastAPI로 시작하는 것은 간단하며 몇 가지 주요 단계를 거치면 됩니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 설치:

- FastAPI를 pip를 사용하여 설치하세요:

```js
pip install fastapi
```

2- 개발 서버 실행:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 빠른 ASGI 서버 인 Uvicorn을 사용하여 FastAPI 애플리케이션을 실행하세요:

```js
uvicorn your_module_name:app --reload
```

- your_module_name을 FastAPI 앱이 정의된 Python 파일로 바꿔주세요.
- --reload 옵션을 사용하여 자동으로 다시로드되도록 설정할 수 있습니다. 코드에 변경 사항이 감지되면 서버가 자동으로 재시작되어 개발이 더 빠르고 편리해집니다.

3- 첫 번째 FastAPI 애플리케이션 만들기:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- Python 파일(main.py)에 FastAPI 애플리케이션을 정의하세요:

```python
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}
```

- 이 예제에서 @app.get("/")은 루트 URL("/")에서 GET 요청에 응답하는 라우트를 정의합니다.

![이미지](/TIL/assets/img/2024-07-09-Hands-OnwithFastAPICreatingaSimpleTo-DoListApplication_0.png)



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

4- 대화식 API 문서 탐색:

- FastAPI는 자동으로 대화식 API 문서를 생성합니다. 브라우저에서 http://localhost:8000/docs 에 방문하여 Swagger UI를 탐색해보세요.

![FastAPI Swagger UI](/TIL/assets/img/2024-07-09-Hands-OnwithFastAPICreatingaSimpleTo-DoListApplication_1.png)

- 또는, http://localhost:8000/redoc 에 방문하여 ReDoc 문서를 확인할 수도 있습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

![image](/TIL/assets/img/2024-07-09-Hands-OnwithFastAPICreatingaSimpleTo-DoListApplication_2.png)

5- Expand Your Application:

- Build upon your basic application by adding more routes, handling query parameters, path parameters, request bodies, and integrating with databases or other services.

# Real-World Use Case: Simple To-Do List API



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

간단한 To-Do 리스트 API를 만들면 FastAPI의 핵심 기능과 이점을 이해하는 데 훌륭한 방법입니다. 이 API를 사용하면 사용자가 할 일 항목을 추가, 보기, 업데이트 및 삭제하는 기본 작업을 수행하여 작업을 관리할 수 있습니다.

1- 모델 정의:

FastAPI에서 Pydantic을 사용하여 모델을 정의하면 API 요청 및 응답의 데이터 구조를 유효성 검사할 수 있습니다. 다음은 간단한 To-Do 리스트 API의 모델을 정의하는 방법에 대한 코드입니다:

```js
# Pydantic 및 typing 모듈에서 필요한 구성 요소 가져오기
from pydantic import BaseModel
from typing import List

# 단일 TodoItem을 위한 Pydantic 모델 정의
class TodoItem(BaseModel):
    id: int  # TodoItem의 정수 ID
    title: str  # 예상되는 문자열인 TodoItem의 제목
    description: str  # 예상되는 문자열인 TodoItem의 설명
    completed: bool = False  # TodoItem이 완료되었는지를 나타내는 부울 플래그, 기본값은 False

# TodoList를 나타내는 또 다른 Pydantic 모델 정의
class TodoList(BaseModel):
    todos: List[TodoItem] = []  # 기본적으로 비어 있도록 초기화된 TodoItem 객체 목록
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 모델을 정의하는 것은 API가 처리하는 데이터를 일관되게 유지하고 유효성을 검증하여 FastAPI 애플리케이션에서 데이터 관리와 오류 처리를 간소화합니다.

루트 구현:

FastAPI에서 루트는 API의 엔드포인트를 정의하고 들어오는 요청을 처리하는 방법을 지정합니다. 루트를 구현하는 것은 간단한 할 일 목록 API를 구축하는 중요한 단계입니다.

```python
from fastapi import FastAPI, HTTPException
from typing import Optional

# FastAPI 인스턴스 생성
app = FastAPI()
# 할 일 항목을 임시 보관하는 (인메모리 리스트)
todos = []
# 모든 할 일 항목을 검색하는 엔드포인트
@app.get("/todos/", response_model=TodoList)
async def read_todos():
    return {"todos": todos}

# 새 할 일 항목 생성하는 엔드포인트
@app.post("/todos/")
async def create_todo(title: str, description: str):
    # 고유 ID 생성 (실제 애플리케이션에서는 데이터베이스 또는 UUID 사용을 고려)
    todo = {"id": len(todos) + 1, "title": title, "description": description, "completed": False}
    todos.append(todo)
    return todo

# 특정 할 일 항목 업데이트하는 엔드포인트
@app.put("/todos/{todo_id}/", response_model=TodoItem)
async def update_todo(todo_id: int, title: Optional[str] = None, description: Optional[str] = None):
    for todo in todos:
        if todo["id"] == todo_id:
            todo["title"] = title if title else todo["title"]
            todo["description"] = description if description else todo["description"]
            return todo
    raise HTTPException(status_code=404, detail="할 일을 찾을 수 없습니다")

# 특정 할 일 항목 삭제하는 엔드포인트
@app.delete("/todos/{todo_id}/")
async def delete_todo(todo_id: int):
    for idx, todo in enumerate(todos):
        if todo["id"] == todo_id:
            del todos[idx]
            return {"message": "할 일이 삭제되었습니다"}
    raise HTTPException(status_code=404, detail="할 일을 찾을 수 없습니다")
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 설명:

- GET 라우트 (/todos/): 모든 할 일 항목을 검색하여 리스트 형식으로 반환합니다.

![이미지](/TIL/assets/img/2024-07-09-Hands-OnwithFastAPICreatingaSimpleTo-DoListApplication_3.png)

- POST 라우트 (/todos/): 고유한 ID, 제목 및 설명을 갖는 새로운 할 일 항목을 만들고 목록에 추가합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

![image](/TIL/assets/img/2024-07-09-Hands-OnwithFastAPICreatingaSimpleTo-DoListApplication_4.png)

- PUT Route (/todos/'todo_id'/): 기존에 있는 ID로 식별된 to-do 항목을 업데이트합니다. 부분적 업데이트가 가능합니다 (제목 또는 설명만 업데이트할 수 있음).

![image](/TIL/assets/img/2024-07-09-Hands-OnwithFastAPICreatingaSimpleTo-DoListApplication_5.png)

- DELETE Route (/todos/'todo_id'/): 목록에서 ID로 식별된 to-do 항목을 삭제합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

<img src="/TIL/assets/img/2024-07-09-Hands-OnwithFastAPICreatingaSimpleTo-DoListApplication_6.png" />

이러한 경로들은 클라이언트가 할 일 항목에 대해 모든 CRUD 작업(생성, 읽기, 업데이트, 삭제)을 수행할 수 있도록 합니다. 이를 통해 FastAPI가 다양한 유형의 HTTP 요청과 응답을 처리하는 방법을 보여줍니다.

# 결론

FastAPI를 사용하여 간단한 할 일 목록 API를 작성하면 강력한 기능과 이점에 대해 실용적으로 소개 받을 수 있습니다. 모델 정의, 경로 구현, CRUD 작업 처리 단계를 따르면 FastAPI의 사용 편의성, 성능 및 자동 문서화 기능에 대한 실전 경험을 얻을 수 있습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

FastAPI의 직관적인 디자인과 강력한 기능으로 초심자든 숙련된 개발자든 모두 현대적이고 고성능의 웹 API를 만드는데 우수한 선택이 될 것입니다. 이 연습을 통해 FastAPI의 핵심 개념을 이해하는데 도움을 받을 뿐만 아니라 미래에 더 복잡하고 확장 가능한 애플리케이션을 구축하는 기술도 갖추게 될 것입니다.

FastAPI를 활용하여 빠르고 효율적으로 API를 개발할 수 있어, 애플리케이션이 강력하면서 유지보수가 쉬운 것을 보장할 수 있습니다. 즐거운 코딩되세요!

FastAPI 실습 간단한 할 일 목록 애플리케이션 만들기 방법

요약: Python과 R을 이용한 LeapFROGS는 과학 응용 프로그램 및 시계열 분석을 위한 비동기 플랫폼으로, 여러분의 과학을 공유하고 공개 및 재현 가능하게 만들기 위해 개발되었습니다. 이 플랫폼은 비동기식 학습 활동과 교육 워크샵을 지원합니다.

![이미지](/TIL/assets/img/2024-07-09-IntroducingLeapFROGSaplatformforopensciencepracticeandpublishing_0.png)

작년 가을에 발표된 최신 LinkedEarth 프로젝트는 오픈 지구과학 연구 및 게재 영역에서 동기식 및 비동기식 학습 활동으로 구성되어 있습니다. 이 블로그 포스트는 LeapFROGS (Python 및 R) 비동기 플랫폼을 소개합니다.

# 왜 FROGS를 선택했나요?



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

연구 데이터, 소프트웨어 및 워크플로우를 공유하는 것은 Findable, Accessible, Interoperable, and Reusable (FAIR) 오픈 사이언스 생태계를 구축하는 데 필수적입니다. 실제로 지난 10년 동안 후원자와 출판사들은 재현성을 강조하며 재현 가능한 과학 제품의 공유를 지원하는 프레임워크를 인정하는 오픈 사이언스 정책을 도입했습니다. 다음 논리적인 단계는 과학 문제를 해결하면서 이러한 프레임워크의 사용법을 공동체에게 가르치는 것입니다.

FROGS는 인원 중 절반의 국적에 대한 존경의 표시입니다.

# LeapFROGS

LeapFROGS의 목표는 Python, R, 시계열 분석 및 오픈 사이언스 출판의 비동기 학습을 위한 플랫폼을 제공하는 것입니다. 이 플랫폼에는 해당 주제에 대한 짧은 텍스트 소개와 주제에 대해 더 자세히 배울 수 있는 관련 자료로의 링크가 혼합되어 있으며, 주제 이해도를 테스트하는 코딩 연습 및 객관식 문제가 포함되어 있습니다. 2024년 7월 현재, 이 플랫폼에는 다음 모듈이 포함되어 있습니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 파이썬 또는 R 소개. 이 모듈은 이 두 언어에 대한 기본적인 프로그래밍 소개에 초점을 맞춥니다. 주요 데이터 유형부터 루프 및 조건문까지 다룹니다. 또한 함수 작성에 대해서도 소개합니다.

![이미지](/TIL/assets/img/2024-07-09-IntroducingLeapFROGSaplatformforopensciencepracticeandpublishing_1.png)

2. 과학 애플리케이션을 위한 Python/R. 두 번째 모듈은 Python/R을 과학 분야에서 사용하는 방법을 다룹니다. Python의 경우, 이 모듈은 NumPy, Pandas, Matplotlib 및 지도를 위한 Cartopy와 같은 라이브러리를 포함한 과학 Python 스택의 기본을 다룹니다. R의 경우, 해당 모듈은 R 데이터 프레임 및 dplyr, tidyr, tibble 및 ggplot2와 같은 tidyverse의 유용한 패키지를 다룹니다.

![이미지](/TIL/assets/img/2024-07-09-IntroducingLeapFROGSaplatformforopensciencepracticeandpublishing_2.png)



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

3. 시계열 분석. 이 모듈은 시계열 분석을 위한 데이터 처리, 연관성 측정, 가설 검정을 위한 대리자 사용 및 스펙트럼 및 웨이블릿 분석을 다룹니다. 이 모듈과 관련된 강의는 Figshare에서 확인할 수 있습니다. 연습문제는 Python용 [여기](링크)와 R용 [여기](링크)에서 확인할 수 있습니다. LeapFROGS에는 학습 내용 이해도를 평가하는 객관식 퀴즈도 포함되어 있습니다.

4. 미래의 과학 논문. 이 모듈은 공개과학 발간의 기본 원칙을 제공하며 데이터, 소프트웨어 및 작업흐름을 공유하는 방법에 대한 모범 사례를 안내합니다. Yolanda Gil과 동료들이 모은 원래 논문 자료를 기반으로 하여 Binder와 같은 새로운 기술을 위해 업데이트하였습니다. 새 자료는 Figshare에 있으며 LeapFROGS에 요약되어 재료 이해도를 테스트하는 퀴즈가 있습니다.

![이미지](/TIL/assets/img/2024-07-09-IntroducingLeapFROGSaplatformforopensciencepracticeandpublishing_3.png)

5. Github 소개. 이 모듈은 연구를 공유하고 협업하기 위한 GitHub 플랫폼 소개를 제공합니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>

<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 누가 LeapFROGS를 사용할 수 있나요?

누구나 이 플랫폼을 사용할 수 있으며, Python 및/또는 R을 사용하여 자신의 분석에 사용하는 과학자 커뮤니티를 위한 자원이 되기를 희망합니다. 오픈 사이언스에 관심이 있고 연구 결과물을 재현 가능하고 공정하게 만들기를 원하는 분들을 위한 것입니다.

지금까지 LeapFROGS는 18명의 지구과학자를 위한 대면 해커톤(PyRATES) 행사를 지원해 왔습니다.

Posts