탐험을 위한 최고의 소프트웨어 10가지

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

패스트API를 사용하여 백엔드를 구축할 때, 일반적으로 하나의 app.py 파일로 시작하는 것이 흔합니다. 이 접근 방식은 작은 프로젝트에 적합하지만, 응용 프로그램이 성장함에 따라 유지 보수와 확장이 어려워집니다.

이 블로그 포스트에서는 Routers, Controllers, Services 및 Repositories로 구성된 구조화된 아키텍처를 사용하여 FastAPI 애플리케이션을 모놀리식 app.py 파일에서 리팩토링하는 방법을 살펴보겠습니다.

## 소개: 우리의 할 일 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>

리팩터링 프로세스에 뛰어들기 전에 함께 작업할 API를 살펴보겠습니다. 다음과 같은 엔드포인트를 가진 간단한 할 일 애플리케이션을 구축 중입니다.

![API Image](/TIL/assets/img/2024-07-09-FastAPIFromApppytoaModularArchitecture_1.png)

이러한 API를 통해 사용자는 할 일 항목에 대한 CRUD(Create, Read, Update, Delete) 작업을 수행할 수 있습니다. 각 할 일 항목은 다음과 같은 속성을 가지게 될 것입니다.

이제 작업 중인 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 프로젝트를 설정해 봅시다.

```js
python3 -m venv venv
source env/bin/activate  # Windows에서는 `env\Scripts\activate
```

```js
fastapi;
uvicorn;
```



<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
pip3 install -r requirements.txt
```

## 초기 접근 방식: 모든 것을 app.py에서 처리

간단한 Todo API를 시작해봅시다. 이 API는 루트 레벨의 app.py에서 완전히 구현되어 있습니다.

```python
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

# 새로운 todo를 생성하기 위한 Pydantic 모델
class TodoCreate(BaseModel):
    title: str

# todo 항목을 위한 Pydantic 모델. TodoCreate를 상속받고 id 및 completed 필드를 추가합니다.
class Todo(TodoCreate):
    id: int
    completed: bool = False

# 데이터베이스를 모방한 todos의 인메모리 저장소
todos = []

# 새로운 todo를 생성하는 엔드포인트
@app.post("/todos", response_model=Todo)
def create_todo(todo: TodoCreate):
    # id를 증가시킨 새로운 todo 항목을 생성합니다.
    new_todo = Todo(id=len(todos) + 1, **todo.model_dump())
    todos.append(new_todo)  # 새로운 todo를 목록에 추가합니다.
    return new_todo  # 생성된 todo를 응답으로 반환합니다.

# 모든 todo를 가져오는 엔드포인트
@app.get("/todos", response_model=list[Todo])
def get_todos():
    return todos  # todo 목록을 응답으로 반환합니다.

# 특정 id의 todo를 가져오는 엔드포인트
@app.get("/todos/{todo_id}", response_model=Todo)
def get_todo(todo_id: int):
    for todo in todos:
        if todo.id == todo_id:
            return todo  # 찾은 경우 해당 todo를 반환합니다.
    # 해당 todo를 찾을 수 없는 경우 404 상태 코드와 메시지를 포함한 HTTPException을 발생시킵니다.
    raise HTTPException(status_code=404, detail="Todo가 없습니다")

# id에 따라 todo를 업데이트하는 엔드포인트
@app.put("/todos/{todo_id}", response_model=Todo)
def update_todo(todo_id: int, updated_todo: TodoCreate):
    for todo in todos:
        if todo.id == todo_id:
            todo.title = updated_todo.title  # todo의 제목을 업데이트합니다.
            return todo  # 업데이트된 todo를 반환합니다.
    # 해당 todo를 찾을 수 없는 경우 404 상태 코드와 메시지를 포함한 HTTPException을 발생시킵니다.
    raise HTTPException(status_code=404, detail="Todo가 없습니다")

# id에 따라 todo를 삭제하는 엔드포인트
@app.delete("/todos/{todo_id}")
def delete_todo(todo_id: int):
    for index, todo in enumerate(todos):
        if todo.id == todo_id:
            del todos[index]  # 목록에서 todo를 삭제합니다.
            return {"message": "Todo가 성공적으로 삭제되었습니다"}  # 성공 메시지를 반환합니다.
    # 해당 todo를 찾을 수 없는 경우 404 상태 코드와 메시지를 포함한 HTTPException을 발생시킵니다.
    raise HTTPException(status_code=404, detail="Todo가 없습니다")

# Uvicorn 서버를 사용하여 애플리케이션을 실행하는 주요 블록
if __name__ == "__main__":
    import uvicorn
    uvicorn.run("app:app", port=3000, host="0.0.0.0", reload=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>

API를 시작하려면 python3 app.py 명령어를 사용해요

음...

이 방법은 작은 애플리케이션에는 작동하지만 몇 가지 단점이 있어요:

- 모든 라우팅, 비즈니스 로직 및 데이터 저장소가 단일 파일에 혼합되어 있어요.
- 애플리케이션이 성장함에 따라 유지 및 확장하기 어려워져요.
- 개별 구성 요소를 테스트하는 것이 어려워져요.
- 코드의 재사용성이 제한되어요



<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>

![FastAPIFromApppytoaModularArchitecture](/TIL/assets/img/2024-07-09-FastAPIFromApppytoaModularArchitecture_2.png)

Refactoring journey starts now...

## Routers Introduction

To structure our application effectively, the first step is to introduce routers.



<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>

새로운 폴더를 만들어 routers라는 이름을 붙이고 todo_router.py라는 파일을 추가해주세요.

```python
from fastapi import APIRouter

router = APIRouter()

@router.post("/todos")
def create_todo():
    pass

@router.get("/todos")
def get_todos():
    pass

@router.get("/todos/{todo_id}")
def get_todo(todo_id: int):
    pass

@router.put("/todos/{todo_id}")
def update_todo(todo_id: int):
    pass

@router.delete("/todos/{todo_id}")
def delete_todo(todo_id: int):
    pass
```

이제 app.py를 업데이트하여 라우터를 사용하세요.

```python
from fastapi import FastAPI
from routers import todo_router

app = FastAPI()

app.include_router(todo_router.router)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run("app:app", port=3000, host="0.0.0.0", reload=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>

라우터를 도입함으로써 작업 관련 라우트를 메인 app.py 파일에서 분리하여 코드를 더 깔끔하고 집중적으로 유지하였습니다.

## 컨트롤러 추가

다음으로, 요청 처리 로직을 처리하기 위한 컨트롤러를 도입할 예정입니다.

controllers라는 새 디렉토리를 생성하고 todo_controller.py라는 파일을 추가하세요.



<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
from fastapi import HTTPException
from pydantic import BaseModel

class TodoCreate(BaseModel):
    title: str

class Todo(TodoCreate):
    id: int
    completed: bool = False

class TodoController:
    def __init__(self):
        self.todos = []

    def create_todo(self, todo: TodoCreate):
        new_todo = Todo(id=len(self.todos) + 1, **todo.model_dump())
        self.todos.append(new_todo)
        return new_todo

    def get_todos(self):
        return self.todos

    def get_todo(self, todo_id: int):
        for todo in self.todos:
            if todo.id == todo_id:
                return todo
        raise HTTPException(status_code=404, detail="Todo를 찾을 수 없습니다.")

    def update_todo(self, todo_id: int, updated_todo: TodoCreate):
        for todo in self.todos:
            if todo.id == todo_id:
                todo.title = updated_todo.title
                return todo
        raise HTTPException(status_code=404, detail="Todo를 찾을 수 없습니다.")

    def delete_todo(self, todo_id: int):
        for index, todo in enumerate(self.todos):
            if todo.id == todo_id:
                del self.todos[index]
                return {"message": "Todo가 성공적으로 삭제되었습니다."}
        raise HTTPException(status_code=404, detail="Todo를 찾을 수 없습니다.")
```

todo_router.py 파일을 업데이트하여 컨트롤러를 사용하십시오.

```js
from fastapi import APIRouter
from controllers.todo_controller import TodoController, TodoCreate, Todo

router = APIRouter()
todo_controller = TodoController()

@router.post("/todos", response_model=Todo)
def create_todo(todo: TodoCreate):
    return todo_controller.create_todo(todo)

@router.get("/todos", response_model=list[Todo])
def get_todos():
    return todo_controller.get_todos()

@router.get("/todos/{todo_id}", response_model=Todo)
def get_todo(todo_id: int):
    return todo_controller.get_todo(todo_id)

@router.put("/todos/{todo_id}", response_model=Todo)
def update_todo(todo_id: int, updated_todo: TodoCreate):
    return todo_controller.update_todo(todo_id, updated_todo)

@router.delete("/todos/{todo_id}")
def delete_todo(todo_id: int):
    return todo_controller.delete_todo(todo_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>

이제 비즈니스 로직을 처리하는 서비스 레이어를 소개해 봅시다.

services 라는 새 디렉토리를 만들고 todo_service.py 라는 파일을 추가해 주세요.

```js
from pydantic import BaseModel

class TodoCreate(BaseModel):
    title: str

class Todo(TodoCreate):
    id: int
    completed: bool = False

class TodoService:
    def __init__(self):
        self.todos = []

    def create_todo(self, todo: TodoCreate) -> Todo:
        new_todo = Todo(id=len(self.todos) + 1, **todo.model_dump())
        self.todos.append(new_todo)
        return new_todo

    def get_todos(self) -> list[Todo]:
        return self.todos

    def get_todo(self, todo_id: int) -> Todo | None:
        for todo in self.todos:
            if todo.id == todo_id:
                return todo
        return None

    def update_todo(self, todo_id: int, updated_todo: TodoCreate) -> Todo | None:
        for todo in self.todos:
            if todo.id == todo_id:
                todo.title = updated_todo.title
                return todo
        return None

    def delete_todo(self, todo_id: int) -> bool:
        for index, todo in enumerate(self.todos):
            if todo.id == todo_id:
                del self.todos[index]
                return True
        return False
```

todo_controller.py를 업데이트하여 서비스를 사용하도록합니다.



<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
from fastapi import HTTPException
from services.todo_service import TodoService, TodoCreate, Todo

class TodoController:
    def __init__(self):
        self.todo_service = TodoService()

    def create_todo(self, todo: TodoCreate):
        return self.todo_service.create_todo(todo)

    def get_todos(self):
        return self.todo_service.get_todos()

    def get_todo(self, todo_id: int):
        todo = self.todo_service.get_todo(todo_id)
        if todo is None:
            raise HTTPException(status_code=404, detail="할 일을 찾을 수 없습니다")
        return todo

    def update_todo(self, todo_id: int, updated_todo: TodoCreate):
        todo = self.todo_service.update_todo(todo_id, updated_todo)
        if todo is None:
            raise HTTPException(status_code=404, detail="할 일을 찾을 수 없습니다")
        return todo

    def delete_todo(self, todo_id: int):
        if self.todo_service.delete_todo(todo_id):
            return {"message": "할 일이 성공적으로 삭제되었습니다"}
        raise HTTPException(status_code=404, detail="할 일을 찾을 수 없습니다")
```

## 레포지터리 레이어 생성

마지막으로 데이터 지속성을 처리하는 레포지터리 레이어를 소개합니다.

repositories라는 새 디렉토리를 만들고 todo_repository.py라는 파일을 추가하세요.



<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
from pydantic import BaseModel

class TodoCreate(BaseModel):
    title: str

class Todo(TodoCreate):
    id: int
    completed: bool = False

class TodoRepository:
    def __init__(self):
        self.todos = []

    def create_todo(self, todo: TodoCreate) -> Todo:
        new_todo = Todo(id=len(self.todos) + 1, **todo.model_dump())
        self.todos.append(new_todo)
        return new_todo

    def get_todos(self) -> list[Todo]:
        return self.todos

    def get_todo(self, todo_id: int) -> Todo | None:
        for todo in self.todos:
            if todo.id == todo_id:
                return todo
        return None

    def update_todo(self, todo_id: int, updated_todo: TodoCreate) -> Todo | None:
        for todo in self.todos:
            if todo.id == todo_id:
                todo.title = updated_todo.title
                return todo
        return None

    def delete_todo(self, todo_id: int) -> bool:
        for index, todo in enumerate(self.todos):
            if todo.id == todo_id:
                del self.todos[index]
                return True
        return False
```

Update `todo_service.py` to use the repository,

```python
from repositories.todo_repository import TodoRepository, TodoCreate, Todo

class TodoService:
    def __init__(self):
        self.todo_repository = TodoRepository()

    def create_todo(self, todo: TodoCreate) -> Todo:
        return self.todo_repository.create_todo(todo)

    def get_todos(self) -> list[Todo]:
        return self.todo_repository.get_todos()

    def get_todo(self, todo_id: int) -> Todo | None:
        return self.todo_repository.get_todo(todo_id)

    def update_todo(self, todo_id: int, updated_todo: TodoCreate) -> Todo | None:
        return self.todo_repository.update_todo(todo_id, updated_todo)

    def delete_todo(self, todo_id: int) -> bool:
        return self.todo_repository.delete_todo(todo_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>

파이썬 앱.py에서 구조화된 모듈 아키텍처로 이어지는 이 여정에서, 우리는 Todo 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>

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

FastAPI 애플리케이션을 모듈식 아키텍처로 리팩토링함으로써, 지속적인 성장과 유연성을 위한 견고한 기반을 마련했습니다. 이 접근 방식은 현재 개발 노력을 향상시킬 뿐만 아니라 앞으로의 도전과 기회에 대비하는 데 도움이 됩니다.

안녕히 가세요!!

FastAPI Apppy에서 모듈러 아키텍처로 전환하는 방법

AMREx 차세대 GPT-4 연상 메모리 어시스턴트 개발 방법 소개

랜덤 포레스트로 PCA와 특징 중요도 해제하는 방법

스파크 최적화 집중 강좌 최고의 성능을 위한 단계별 가이드

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

몇 달 전에 리서치 프로젝트를 진행하면서 시계열을 다루는 문제를 해결해야 했어요.

이 문제는 상당히 간단했어요:

Machine Learning 애호가들에게는 "Hello World"를 작성하는 것과 같은 느낌이죠. 이 문제는 "forecasting"이라는 이름으로 커뮤니티에서 매우 잘 알려진 문제입니다.



<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>

기계 학습 커뮤니티는 시계열 데이터의 다음 값을 예측하는 데 사용할 수 있는 많은 기술을 개발했습니다. 일부 전통적인 방법에는 ARIMA/SARIMA 또는 푸리에 변환 분석과 같은 알고리즘이 포함되어 있으며, 더 복잡한 알고리즘에는 컨볼루션/순환 신경망 또는 슈퍼 유명한 "Transformer" (ChatGPT의 T는 transformers를 나타냅니다)이 있습니다.

예측 문제는 매우 잘 알려진 문제이지만, 제약 조건이 있는 예측 문제에 대해 다루는 것은 덜 흔한 것일 수 있습니다.
무엇을 의미하는지 설명해 드릴게요.

일련의 매개변수 X와 시간 단계 t가 있는 시계열 데이터가 있다고 가정해 봅시다.
표준 시간 예측 문제는 다음과 같습니다:

![image](/TIL/assets/img/2024-07-09-HandsOnMonotonicTimeSeriesForecastingwithXGBoostusingPython_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>

우리가 직면한 문제는 다음과 같습니다:

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

따라서 입력 매개변수가 d 차원이라고 가정할 때, 저는 차원 1을 위한 함수가 단조적이 되기를 원합니다. 그렇다면 어떻게 처리해야 할까요? 어떻게 "단조적" 시계열을 예측할 수 있을까요? 이 문제에 대한 설명은 XGBoost를 사용할 것입니다.

이 블로그 포스트의 구조는 다음과 같습니다:



<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>

- XGBoost에 대해: XGBoost가 무엇에 대해, 기본 아이디어가 무엇인지, 장단점은 무엇인지 몇 줄로 설명하겠습니다.
- XGBoost 예제: XGBoost 코드를 설명하겠습니다. Python 설명부터 장난감 예제까지를 포함하여요.
- XGBoost의 명확성을 갖춘 예제: XGBoost를 실제 예제로 테스트하겠습니다.
- 결론: 이 블로그 포스트에서 언급된 내용에 대한 요약을 제시하겠습니다.

# 1. XGBoost에 대해

## 1.1 XGBoost의 아이디어

XGBoost의 XG는 extreme gradient(부스팅)을 의미합니다.
"gradient boosting" 알고리즘은 "예측자 체인"을 사용하려고 합니다.
입력 행렬 X 및 해당 출력 y가 주어지면, 아이디어는 여러 예측자가 있습니다. 첫 번째 예측자는 입력 X로부터 직접 해당 출력 y를 찾으려고 합니다. 이야기의 끝. 아니요, 농담이에요 🤣



<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>

첫 번째 예측기는 “약한 예측기”라고 불리는 것을 목표로 합니다. 이는 예측된 y1과 실제 출력 y 사이에 무시할 수 없는 차이가 있는 것을 의미합니다. 두 번째 예측기는 첫 번째 예측의 오류를 보정하는 것을 목표로 하므로 X에서 y로 이동하는 것이 아니라 y2 = y-y1로 이동하는 것으로 훈련됩니다. 이 작업은 예측기의 수인 N번 반복되며, 아래 이미지에 나타난 바와 같습니다:

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

각 예측기는 의사 결정 트리(decision tree)입니다. 의사 결정 트리에 대한 설명을 할 때마다, 나는 그것을 게임 “guess who”에 비유하여 설명합니다. 그 게임은 다음과 같이 진행됩니다.

각 플레이어가 일부 캐릭터 얼굴로 가득 찬 게시판을 가진 “guess who”의 클래식 게임을 하는 상황을 상상해보세요. 각 캐릭터는 머리카락 색상, 눈동자 색상, 안경, 모자 등과 같은 구별 가능한 특징을 가지고 있습니다. 목표는 이러한 특징들에 대한 예/아니오 질문을 통해 상대방의 비밀 캐릭터를 추측하는 것입니다. 각 질문은 답변과 맞지 않는 후보를 없애줄 뿐 아니라, 가능성을 좁히며 마침내 확신을 갖고 비밀 캐릭터를 추측할 수 있도록 도와줍니다.



<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>

![Hands on Monotonic Time Series Forecasting with XGBoost using Python](/TIL/assets/img/2024-07-09-HandsOnMonotonicTimeSeriesForecastingwithXGBoostusingPython_4.png)

As you can see, the structure resembles an upside-down tree, starting from the leaves (bottom) and extending to the root (top).

Each predictor corresponds to one of these trees. If you are pondering the difference between classification and regression, you are correct. The example I showcased, for simplicity, focuses on a classification problem. However, if you substitute "Kristen" with a real number like "0.47462", you will shift to a regression problem. It's that straightforward.

The XGBoost algorithm cleverly utilizes all these decision trees to "boost" the prediction of the preceding tree. It's called "extreme" because a plethora of intermediate optimization steps have been undertaken by the talented scientists who developed the algorithm, which you can explore [here](link).



<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>

학습 파트는 항상 손실 함수 최소화 + 오버피팅 방지를 위한 정규화 항이 포함됩니다. 파라미터로는 잎의 수, 트리의 깊이 및 트리의 분할 지점이 있습니다. "트리의 분할 지점"이란 무엇을 의미하냐면요. 위 예제에서 "이 사람이 아이인가요?"와 같은 질문이 있습니다. 실제로는 연속적인 특성을 갖게 되어 "x_1이 분할 지점인가요?"와 같이 더 많이 사용하게 될 수 있습니다. 이는 분할 지점이 하나의 파라미터로 작용하게 되는 것입니다.

## 1.1 XGBoost 단조성

이제, XGBoost 알고리즘은 제공할 것이 많습니다:

- 오버피팅에 대한 일반적으로 강한 내구성을 보여줍니다. 의사결정 트리는 오버피팅 문제가 잘 알려져 있으며 이러한 앙상블 방법은 이를 극복하는 데 좋습니다.
- 저렴한 계산 복잡성을 다룰 수 있습니다. 그것을 하면서 오버피팅을 방지하는 것이 특히 명확하지 않습니다.
- 특성의 중요성 덕분에 여전히 설명 가능성을 제공합니다. 이를 통해 어떤 X의 파라미터가 예측에 중요한지 이해할 수 있습니다.
- 특정 특성에 대해 단조 함수로 응답을 하도록 선택할 수 있습니다.



<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>

예를 들어, 다음과 같은 함수가 있다고 가정해 봅시다:

![Alt text](/TIL/assets/img/2024-07-09-HandsOnMonotonicTimeSeriesForecastingwithXGBoostusingPython_5.png)

이 함수는 x2에 대해 단조적입니다. x1과 x2가 주어졌을 때 XGBoost를 사용하여 f(x1, x2)의 결과를 예측하려고 한다고 상상해 봅니다. 이제 현실에서 f(x1, x2)는 알려지지 않았습니다 (그렇지 않으면 기계 학습을 하지 않고 휴가를 가기위해 플로리다로 비행을 갈 것입니다), 하지만 x2에 대해 단조적이라는 점을 알거나 원할 수 있습니다. 실제로 저는 다른 양과 관련하여 단조적임을 알고 있던 물리량이 있었던 적이 있습니다. XGBoost의 구조를 수정하여 해당 특징에 대한 요구 사항을 충족시킬 수 있습니다. 우리의 경우, x2에 대한 단조적 행동을 강제하는 예측을 할 수 있습니다.

좋아요. 이제 이걸 버텨내셨으면 좋겠네요. 이제 재미있는 부분으로 넘어갑시다. 😅



<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>

# 2. 코딩

## 2.1 장난감 데이터셋

결정 트리가 나를 많이 성장시키고, 나의 첫 번째 머신러닝 코드 중 하나였으니까 많은 감정을 불러일으켰어요. 조금 바보 같게 들릴지 몰라도, 조금은 감정적이 느껴져요 ❤️

하지만 솔직히 이 코드는 굉장히 간단합니다. 그러니 더 이상 말이 필요 없이, 바로 시작해 봅시다. 두 가지 예제를 보여 드릴 건데, 첫 번째 예제는 1차원으로, 이 모든 것이 어떻게 작동하는지 설명하는 겁니다. 이것은 우리가 XGBoost를 사용해 예측하고자 하는 대상 함수 f입니다:



<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-HandsOnMonotonicTimeSeriesForecastingwithXGBoostusingPython_6.png)

이것이 플롯입니다.

이제 XGBoost의 실용적인 구현이 문서에 단어별로 자세히 나와 있습니다. 제가 모든 부분을 알려드릴 필요는 없지만, 이 경우에 어떻게 작동하는지 보여드리고 싶습니다. 이는 온라인에서 찾을 수 있는 어떤 SkLearn 모델과 다를 바 없습니다.

쉽죠. 이제 실제 테스트를 해봅시다.



<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>

## 2.2 실제 데이터셋

위의 예제는 xgboost 코드의 구조를 보여줍니다. 그러나, 우리가 구축한 장난감 데이터셋에는 몇 가지 제한 사항이 있습니다:

- 너무 간단하다 (1 차원) 그리고 완전히 근거없이 만들어진 데이터셋이다.
- 우리는 데이터셋을 섞었기 때문에 예측적으로 사용하지 않았다.
- 우리는 모노토닉 제약 조건을 사용하지 않았다 (내가 약속한 것).

그래서, 실제 비즈니스를 시작해 볼까요?
저는 델리 데이터의 데이터셋인 이 데이터셋을 사용했습니다. 이 데이터셋은 두 개의 csv 테이블 (DailyDelhiClimateTrain.csv와 DailyDelhiClimateTest.csv)으로 구성되어 있습니다.



<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>

Pandas를 사용하여 데이터를 가져와서 5개의 행을 표시했습니다. 날짜, 습도, 풍속, 평균 기압 및 평균 온도와 같이 5개의 열이 있습니다. 하나의 합리적인 문제는 다음과 같을 수 있습니다:

그리고 이 문제에 대해 잘 다루는 블로그 포스트가 있습니다. 우리는 한 단계 더 나아가려고 합니다. 우리는 이 다른 열인 "City_Index"를 추가할 것입니다. 이 City_Index는 뉴델리보다 더 덥거나 더 추운 다른 도시가 있다는 사실을 모방할 것입니다. 세계의 다른 부분별로 도시 지수를 그룹화하는 것처럼\*:

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

이제 City_Index=1이 mean_temp의 기본 값이 되도록 만들 것입니다. City_Index = 2는 목표 값으로 2*mean_temp를 가져오도록 만들 것이고, City_Index=9는 목표 값으로 9*mean_temp를 가져오도록 할 것입니다. 이는 다른 변수를 모두 고정시킨다면 City_Index가 단조 변수가 될 수 있다는 것을 의미합니다:



<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-HandsOnMonotonicTimeSeriesForecastingwithXGBoostusingPython_8.png" />

실제로 이것은 로스엔젤레스, 캘리포니아의 온도가 앵코리지, 알래스카의 온도보다 항상 높다는 것을 의미합니다 (알래스카에 있는 도시를 몰라서 구글링했어요).

우리는 "City_Index" 변수와 이 두 함수를 통해 이를 할 것입니다:

이제 우리는 이를 할 것입니다:



<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>

- 새로운 City_Index 변수를 사용하여 증강된 데이터 세트를 생성합니다.
- 데이터를 훈련 및 검증 세트로 분할합니다.
- City_Index에서 단조성을 강제하여 시계열 XGBoost 예측기를 훈련하는 데 훈련 데이터를 사용하고 훈련된 모델을 사용하여 다음 값을 예측합니다.

그리고 이렇게 테스트해 봅니다:

그리고 이것이 우리의 예측 결과입니다:

![image](/TIL/assets/img/2024-07-09-HandsOnMonotonicTimeSeriesForecastingwithXGBoostusingPython_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>

몬토닉성은 params_constraints에서 확인할 수 있습니다. Params constraints 벡터는 우리가 몬토닉성을 유지하고 싶은 특성을 제외한 모든 특성을 0으로 설정한 벡터입니다.
이제 알 수 있듯이, 다른 모든 특성을 고정하고 City_Index를 변경하면 몬토닉한 동작을 볼 수 있습니다:

완벽하게 몬토닉합니다. 거의 선형적이기도 하죠 (우리가 사전에 특정한 것). 이것은 XGBoost 대 ARIMA, SARIMA 또는 다항 회귀를 사용하는 차이를 보여줍니다: XGBoost를 사용하면 명시적인 몬토닉 동작을 부여할 수 있습니다.

# 3. 결론

여기에서 우리가 한 작업을 요약해 드릴게요:



<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>

- 저희는 예보 작업을 수행하되 보존하고 싶은 일부 단조 특성이 있는 문제를 소개했습니다. 이러한 경우에는 ARIMA나 RNN과 같은 고급 방법이 단조성을 깨뜨릴 수 있습니다.

- 간단히 말해, "추측 누구?" 예제를 사용하여 XGBoost 아이디어를 소개했고, 부스팅 알고리즘이 선택할 수 있는 의사 결정 트리를 수정하여 단조성을 강제할 수 있다는 점을 확인했습니다.

- 우리는 XGBoost를 장난감 예제에서 사용하여 구문이 작동하는 방식을 기본적으로 이해했습니다.

- 기후변화 데이터를 사용하여 예보 연구를 수행했으며, 기본적인 예보 이상의 작업을 수행했습니다. 'City_Index'라는 새로운 특성에 단조적으로 증가하는 값을 부과함으로써, City_Index 특성에 대해 예측된 온도가 단조적이어야 한다는 가정에 기반하여 온도를 예측했습니다.



<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. 저에 대해!

다시 한 번 시간 내주셔서 감사합니다. 정말 감사드려요 ❤

내 이름은 Piero Paialunga이고 난 이 사람이야:

![이미지](/TIL/assets/img/2024-07-09-HandsOnMonotonicTimeSeriesForecastingwithXGBoostusingPython_10.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>

저는 시내티 대학교 항공우주공학부 박사 후보이자 Gen Nine의 머신러닝 엔지니어입니다. 블로그 글과 Linkedin에서 AI 및 머신러닝에 대해 이야기합니다. 만약 글이 마음에 드시고 머신러닝에 대해 더 알고 싶으시다면:

A. 제가 모든 이야기를 게시하는 Linkedin에서 팔로우하세요.
B. 뉴스레터를 구독하세요. 새로운 이야기에 대한 업데이트를 제공하며 의문이나 궁금증이 있을 때 연락해 모든 수정을 받아볼 수 있습니다.
C. 추천 회원이 되어 "월간 최대 이야기 수" 제한 없이 저 (그리고 수천 명의 다른 머신러닝 및 데이터 과학 최고 작가)가 제공하는 최신 기술에 대해 읽을 수 있습니다.

질문이 있거나 협업을 시작하려면 여기에 메시지를 남겨주세요:

piero.paialunga@hotmail.com

Python으로 XGBoost를 사용한 모노토닉 시계열 예측 실습

시각화는 데이터에서 통찰을 전달하는 강력한 방법입니다. 파이썬의 Seaborn 라이브러리는 Matplotlib을 기반으로 한, 시각적으로 매력적이고 정보를 제공하는 높은 수준의 인터페이스를 제공합니다. 이 기사에서는 Seaborn 라이브러리를 자세히 살펴보며 그 기능을 탐구하고 다양성을 보여주는 실용적인 코드 예제를 제시할 것입니다.

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

## Seaborn이란

Seaborn은 복잡하고 아름다운 시각화를 만드는 과정을 단순화하는 데이터 시각화 라이브러리입니다. 시각적 경험을 향상하기 위해 내장된 테마와 색 팔레트를 제공합니다. Seaborn은 통계적 시각화를 생성하는 데 특히 적합하며 변수 간의 관계를 시각화하는 데 자주 사용됩니다.



<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>

# Seaborn을 이용한 시각화 생성

Seaborn의 주요 기능과 기능을 몇 가지 코드 예제와 함께 살펴보겠습니다.

## 1. 산점도

- a) 기본 산점도



<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
import seaborn as sns
import matplotlib.pyplot as plt
```

```js
# 샘플 데이터
x = [1, 2, 3, 4, 5]
y = [3, 5, 8, 6, 7]
```

```js
# Seaborn을 사용하여 기본 산점도 그리기
sns.scatterplot(x=x, y=y)
plt.xlabel('X축')
plt.ylabel('Y축')
plt.title('Seaborn을 사용한 기본 산점도')
plt.show()
```

<img src="/TIL/assets/img/2024-07-09-DataVisualizationinPythonSeabornLibrary_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>

- b) 색상과 색조를 가진 산점도

```python
import seaborn as sns
import matplotlib.pyplot as plt
```

```python
# 샘플 데이터
x = [1, 2, 3, 4, 5]
y = [3, 5, 8, 6, 7]
categories = ['A', 'B', 'A', 'B', 'A']
```

```python
# Seaborn을 사용하여 색상과 색조를 가진 산점도 생성
sns.scatterplot(x=x, y=y, hue=categories, palette='Set1')
plt.xlabel('X-축')
plt.ylabel('Y-축')
plt.title('색상과 색조를 가진 산점도')
plt.show()
```



<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-DataVisualizationinPythonSeabornLibrary_2.png" />

## 2. 상자 그림

- a) 기본 상자 그림

```js
import seaborn as sns
import matplotlib.pyplot as plt
```



<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
# 샘플 데이터
data = sns.load_dataset('iris')
```

```js
# Seaborn을 사용하여 기본 상자 그림 생성
sns.boxplot(x='species', y='sepal_length', data=data)
plt.xlabel('종류')
plt.ylabel('꽃 받침 길이')
plt.title('Seaborn을 사용한 기본 상자 그림')
plt.show()
```

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

- b) 색상 팔레트를 사용한 가로 상자 그림



<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
import seaborn as sns
import matplotlib.pyplot as plt
```

```js
# 샘플 데이터
data = sns.load_dataset('titanic')
```

```js
# Seaborn을 사용하여 색상 팔레트를 이용한 수평 상자 그림 생성
sns.boxplot(x='age', y='class', data=data, orient='h', palette='Set2')
plt.xlabel('나이')
plt.ylabel('등급')
plt.title('색상 팔레트를 이용한 수평 상자 그림')
plt.show()
```

<img src="/TIL/assets/img/2024-07-09-DataVisualizationinPythonSeabornLibrary_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>

- c) 그룹화된 상자 그림

```js
import seaborn as sns
import matplotlib.pyplot as plt
```

```js
# 샘플 데이터
data = sns.load_dataset('tips')
```

```js
# Seaborn을 사용하여 그룹화된 상자 그림 생성
sns.boxplot(x='day', y='total_bill', data=data, hue='sex', palette='Set3')
plt.xlabel('요일')
plt.ylabel('총 계산')
plt.title('그룹화된 상자 그림')
plt.legend(title='성별')
plt.show()
```



<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-DataVisualizationinPythonSeabornLibrary_5.png" />

- d) Notched Box Plot

```js
import seaborn as sns
import matplotlib.pyplot as plt
```

```js
# Sample data
data = sns.load_dataset('diamonds')
```



<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
# Seaborn을 사용하여 notch가 있는 상자 그림 만들기
sns.boxplot(x='cut', y='price', data=data, notch=True, palette='pastel')
plt.xlabel('Cut')
plt.ylabel('Price')
plt.title('Notched Box Plot')
plt.show()
```

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

- e) 사용자 정의 상자 그림

```js
import seaborn as sns
import matplotlib.pyplot as plt
```



<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
# 샘플 데이터
data = sns.load_dataset('mpg')
```

```js
# Seaborn을 사용하여 사용자 정의 상자 그림 만들기
sns.boxplot(x='origin', y='mpg', data=data, hue='cylinders', palette='Set2')
plt.xlabel('Origin')
plt.ylabel('Miles per Gallon')
plt.title('Customized Box Plot')
plt.legend(title='Cylinders')
plt.show()
```

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

## 3. Pair Plot



<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>

- a) 기본 Pair Plot

```js
import seaborn as sns
import matplotlib.pyplot as plt
```

```js
# 샘플 데이터
data = sns.load_dataset('iris')
```

```js
# Seaborn을 사용하여 기본 Pair Plot 생성
sns.pairplot(data, hue='species')
plt.title('Seaborn을 사용한 기본 Pair Plot')
plt.show()
```



<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-DataVisualizationinPythonSeabornLibrary_8.png)

- b) Pair Plot with Custom Color Palette

```js
import seaborn as sns
import matplotlib.pyplot as plt
```

```js
# Sample data
data = sns.load_dataset('tips')
```



<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
# Seaborn을 사용하여 사용자 정의 색상 팔레트로 pair plot 만들기
sns.pairplot(data, hue='sex', palette='Set2')
plt.title('사용자 정의 색상 팔레트로 Pair Plot 만들기')
plt.show()
```

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

- c) 다른 플롯 유형을 사용한 Pair Plot

```js
import seaborn as sns
import matplotlib.pyplot as plt
```



<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
# 샘플 데이터
data = sns.load_dataset('penguins')
```

```js
# Seaborn을 사용하여 다른 종류의 플롯을 사용하여 페어 플롯 생성
g = sns.PairGrid(data)
g.map_upper(sns.scatterplot)
g.map_lower(sns.kdeplot)
g.map_diag(sns.histplot, kde_kws={'color': 'k'})
plt.title('다른 플롯 유형을 사용한 페어 플롯')
plt.show()
```

<img src="/TIL/assets/img/2024-07-09-DataVisualizationinPythonSeabornLibrary_10.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 Fundamentals"에서 찾아보실 수 있어요! 💫

파이썬 데이터 시각화 Seaborn 라이브러리 사용법

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

# Asynchronous Processing이란 무엇인가요?

비동기 처리는 작업이나 동작을 메인 프로그램의 실행을 차단하지 않고 동시에 실행할 수 있는 프로그래밍 패러다임입니다.

![image](/TIL/assets/img/2024-07-09-PythonAsynchronousProcessingIntroduction_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>

전통적인 동기 처리 방식에서는 작업이 순차적으로 실행되며, 각 작업이 완료될 때까지 다음 작업으로 넘어가기 전에 프로그램이 기다립니다.

이 방식은 특히 파일 작업이나 네트워크 요청과 같이 I/O 대기가 필요한 작업에 대해 비효율적일 수 있습니다. 이러한 경우 프로그램은 상당한 시간 동안 유휴 상태가 될 수 있습니다.

예를 들어, 아래 코드를 실행한다면:

```js
import time

# 작업을 수행하는 동기 함수
def task(name):
    print(f"작업 {name} 시작")
    time.sleep(2)  # 2초의 지연을 모의합니다
    print(f"작업 {name} 완료")

# 메인 프로그램

print("메인 프로그램 시작")

# 작업을 순차적으로 수행
task("A")
task("B")
task("C")

print("메인 프로그램 완료")
```



<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
Main program started
Task A started
Task A completed
Task B started
Task B completed
Task C started
Task C completed
Main program completed
```

반면에 비동기 처리는 작업이 독립적으로 및 동시에 실행되도록 합니다. 이는 프로그램이 작업을 시작하고 해당 작업이 완료될 때까지 기다리지 않고 다른 작업을 계속할 수 있도록 합니다. 완료된 작업은 준비되면 프로그램이 결과를 처리하거나 실행을 계속할 수 있도록 알림이나 이벤트를 트리거합니다.

예를 들어:



<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
import asyncio

# 작업을 나타내는 비동기 코루틴
async def task(name):
    print(f"작업 {name} 시작")
    await asyncio.sleep(2)  # 2초의 지연을 모의
    print(f"작업 {name} 완료")

# 메인 프로그램

async def main():
    print("메인 프로그램 시작")

    # 동시에 실행할 작업 목록 생성
    tasks = [
        asyncio.create_task(task("A")),
        asyncio.create_task(task("B")),
        asyncio.create_task(task("C"))
    ]

    # 모든 작업이 완료될 때까지 대기
    await asyncio.gather(*tasks)

    print("메인 프로그램 완료")

# 메인 프로그램 실행
asyncio.run(main())
```

출력:

```js
메인 프로그램 시작
작업 A 시작
작업 B 시작
작업 C 시작
작업 A 완료
작업 B 완료
작업 C 완료
메인 프로그램 완료
```

모든 작업이 동시에 시작되며, 완료 순서는 다를 수 있습니다. 메인 프로그램은 작업이 완료될 때까지 기다리지 않고 실행을 계속하여 비동기성을 실현합니다.



<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>

비동기 처리는 일반적으로 코루틴, 이벤트 기반 프로그래밍 또는 콜백 기반 프로그래밍 모델과 같은 비동기 프로그래밍 기법을 사용하여 달성됩니다. 이러한 기술을 사용하면 프로그램이 블로킹 없이 여러 작업 간에 전환할 수 있어 시스템 자원을 가장 효율적으로 활용할 수 있습니다.

비동기 처리의 장점은 성능, 응답 속도, 확장성이 향상된다는 점입니다. 불필요한 대기를 피하고 리소스 사용을 최대화함으로써 응용 프로그램은 대규모의 동시 작업을 효율적으로 처리할 수 있습니다.

# 병렬성 vs 동시성 vs 스레딩

## 병렬성



<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>

병렬 처리는 여러 개의 연산 장치를 사용하여 동시에 여러 작업을 수행하는 것을 말합니다. 이는 주로 멀티코어 프로세서가 장착된 시스템에서 볼 수 있으며 각 작업이 별도의 CPU/프로세서에서 실행됩니다. 이는 주로 하드웨어의 기능입니다. 참된 병렬 처리에서는 여러 작업이 물리적으로 동시에 실행되며, 마치 여러 명의 작업자가 거대한 벽의 서로 다른 부분을 동시에 도색하는 것과 같습니다.

```python
from multiprocessing import Process

def worker(num):
    print(f'Worker: {num}')

if __name__ == '__main__':
    processes = [Process(target=worker, args=(i,)) for i in range(5)]

    for process in processes:
        process.start()

    for process in processes:
        process.join()
```

출력:

```python
Worker: 1
Worker: 0
Worker: 2
Worker: 3
Worker: 4
```



<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
import asyncio

async def worker(num):
    print(f'작업자 시작: {num}')
    await asyncio.sleep(1)
    print(f'작업자 완료: {num}')

async def main():
    # 동시에 실행될 작업 목록 생성
    tasks = [
        asyncio.create_task(worker(1)),
        asyncio.create_task(worker(2)),
        asyncio.create_task(worker(3))
    ]

    # 모든 작업이 완료될 때까지 대기
    await asyncio.gather(*tasks)

asyncio.run(main())
```



<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
Start worker: 1
Start worker: 2
Start worker: 3
Finish worker: 1
Finish worker: 2
Finish worker: 3
```

## 스레딩

스레딩은 동시성을 달성하기 위한 프로그래밍 개념과 기술입니다. 스레드는 운영 체제의 스케줄러에 의해 독립적으로 관리될 수 있는 프로그램 명령의 가장 작은 시퀀스입니다.



<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>

프로그램에는 여러 개의 스레드가 포함될 수 있으며, 각각이 특정 작업을 동시에 처리할 수 있습니다. 여러 스레드를 관리함으로써 하나의 프로세스가 작업을 동시에 실행할 수 있으므로 전체 실행 속도와 효율성이 높아집니다.

시스템에 멀티코어 프로세서가 있다면, 개별 스레드도 병렬로 실행될 수 있습니다. 스레딩의 좋은 예로는 웹 서버가 서로 다른 사용자의 여러 요청을 처리하는 것이 있습니다. 각 요청은 별도의 스레드에서 처리됩니다.

스레딩에 대해 알아둬야 할 중요한 점은 IO-바운드 작업을 다룰 때 그 향상된 효율성입니다. CPU-바운드 작업과는 대조적으로, 계산이 시작부터 끝까지 CPU의 처리 능력에 크게 의존하는 작업에 비해, IO-바운드 작업은 입력/출력 작업이 완료되기를 기다리는 동안 상당한 유휴 시간이 있습니다.

```python
import threading

def worker(num):
    print(f'작업자: {num}')

if __name__ == '__main__':
    threads = [threading.Thread(target=worker, args=(i,)) for i in range(5)]

    for thread in threads:
        thread.start()

    for thread in threads:
        thread.join()
```



<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
Worker: 0;
Worker: 1;
Worker: 2;
Worker: 4;
Worker: 3;
```

요약하면, 병행 시스템에서 작업이 겹치면서 시작, 실행 및 완료되지만, 병렬 시스템에서 작업은 동시에 실행됩니다— 이것이 핵심적인 차이점입니다. 스레딩은 우리가 동시성 및 가능한 병렬성의 목표를 달성하는 기술일 뿐입니다. 동시성에는 CPU 집약적 작업에 최적화된 다중 처리와 IO 집약적 작업에 적합한 스레딩이 포함됩니다. 다중 처리는 병렬성의 한 유형으로 간주될 수 있으며, 병렬성 자체가 동시성의 특정 종류(하위 집합)입니다.

# Python Asyncio 모듈



<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>

The `asyncio` 모듈은 파이썬에서 강력한 라이브러리로, 비동기 코드를 작성하는 데 필요한 지원을 제공합니다. 이는 코루틴, 이벤트 루프, 비동기 I/O 개념을 기반으로하며 효율적이고 동시성을 가진 프로그래밍을 가능하게 합니다.

`asyncio`를 사용한 비동기 프로그래밍을 통해 단일 스레드 동시성 코드를 작성하고 여러 작업을 동시에 실행할 수 있으며 블로킹 작업을 피할 수 있습니다. 이 접근 방식은 특히 장시간 대기 시간이 발생하는 네트워크 요청 또는 파일 작업과 같은 I/O 바운드 작업을 처리할 때 유용합니다.

`asyncio`는 코루틴을 정의하고 비동기 코드의 실행 흐름을 관리하는 데 사용되는 `async` 및 `await` 키워드를 소개합니다. 코루틴은 일시 중지되고 다시 시작될 수 있는 함수로, 그 사이에 다른 작업이 실행될 수 있습니다. 이벤트 루프는 중앙 스케줄러로 작동하여 이러한 코루틴의 실행을 조정하고 I/O 작업을 효율적으로 관리합니다.

## 주요 기능



<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>

- 코루틴: 코루틴은 async 키워드로 정의된 함수들입니다. 실행 중에 일시 중지되고 다시 실행되어 다른 코루틴이 동시에 실행될 수 있습니다.
- 이벤트 루프: 이벤트 루프는 코루틴에 대한 실행 환경을 제공합니다. 여러 코루틴 간의 스케줄링 및 전환이 관리되어 효율적이고 블로킹되지 않는 실행을 보장합니다.
- 작업: 작업은 코루틴 위에서 더 높은 수준의 추상화입니다. 비동기로 실행해야 하는 작업 단위를 나타내고 이벤트 루프에 의해 스케줄링되고 관리될 수 있습니다.
- 미래: 미래는 아직 완료되지 않을 수 있는 코루틴의 결과를 나타내는 객체입니다. 비동기 작업의 완료를 추적하고 기다릴 수 있게 합니다.
- 동기화 기본 요소: asyncio는 락, 세마포어, 큐와 같은 다양한 동기화 기본 요소를 제공하여 공유 리소스를 관리하고 동시 작업을 조정하는 데 도움을 줍니다.

그러나 asyncio는 협력적으로 멀티태스킹을 기반으로 하는 단일 스레드, 단일 프로세스 모델을 사용합니다. asyncio는 하나의 스레드 내에서 작동하지만 효과적이고 블로킹되지 않는 실행 환경을 제공하여 동시성의 환상을 만들어냅니다. asyncio의 핵심인 코루틴은 동시에 배포될 수 있지만 그 자체로는 본질적으로 동시성을 가지지 않습니다.

강조하자면, asyncio는 동시 프로그래밍의 한 형태이지만 병렬성과는 동일하게 여기지 않아야 합니다. 그 방법론은 쓰레딩(threading)과 공유(`multiprocessing`)와는 더 일치하지만 그 둘로부터 독립적이며 다양한 동시성 기술들 중에서 독자적인 방법론을 취하고 있습니다.

# async와 await



<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>

The async and await syntax are key components of Python's asyncio module, a library used for writing concurrent code using the async/await syntax.

## async

async is a keyword used to declare a function as an "asynchronous function". Such functions are also known as "coroutines". You define a coroutine by prefixing def with async. For example, async def my_function():.

When an async function is called, it doesn't execute in the traditional way. Instead, it returns an "awaitable" object, which is a coroutine object. This object needs to be awaited or run in an event loop to get the result. The event loop is where the asynchronous code is executed. It's the core of every asyncio application, managing and scheduling the execution of asynchronous tasks.



<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>

## await

await은 기다리고 있는 작업이 완료될 때까지 코루틴을 일시 중지하는 데 사용됩니다. 이는 async 함수 내에서만 사용할 수 있습니다. await 키워드 뒤에는 코루틴, Future 또는 I/O-bound 함수와 같은 "awaitable" 객체로 이루어진 식이 따릅니다.

await 표현식이 실행되면 사용된 코루틴은 awaitable이 해결될 때까지 일시 중지됩니다. 이러한 일시 중지 동안 이벤트 루프는 다른 작업을 계속 실행합니다.

## async와 await을 사용하는 이유



<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>

- 논블로킹: 비동기 코드는 논블로킹 I/O 작업을 허용합니다. 대기 중인 경우, 다른 코드를 실행할 수 있습니다.
- 동시성: 더 효율적이고 유지보수가 용이한 방식으로 동시성 코드를 작성할 수 있도록 합니다.
- 성능: I/O 바운드 애플리케이션에서 async/await를 사용하면 상당한 성능 향상이 가능합니다.
- 가독성: async/await 구문은 콜백과 같은 이전 비동기 프로그래밍 기법에 비해 더 읽기 쉽고 직관적입니다.

예시:

```python
import asyncio

async def my_async_function():
    await asyncio.sleep(1)
    return "안녕, 비동기 세계!"

async def main():
    result = await my_async_function()
    print(result)

# 주요 코루틴 실행
asyncio.run(main())
```

파이썬 비동기 프로세싱 소개

소프트웨어 개발 및 시스템 관리의 끊임없이 변화하는 환경에서는 특정 도전 과제를 해결하고 생산성을 향상시키기 위해 지속적으로 새로운 도구와 라이브러리가 등장합니다. 이 문서는 Netshoot, Superfile, E2B의 Code Interpreter SDK, Kitbag Router, AWS Lambda Web Adapter 및 React Lua와 같이 6가지 혁신을 강조합니다.

이 도구들 각각은 컨테이너화된 환경에서의 네트워크 문제 해결부터 서버리스 아키텍처에서 웹 응용 프로그램을 가능하게 하는 것과 같이 현대 소프트웨어 개발의 고유한 측면을 대상으로 합니다. 이러한 솔루션들은 산업이 복잡한 작업을 단순화하고 효율성을 향상시키며 다른 기술과 패러다임 간의 간극을 좁히기 위한 지속적인 노력을 보여줍니다.

## 추가로 읽을 거리:

프롬프트 디자인의 기술을 숙달하기



<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>

디자인 및 사용자 스토리 매핑을위한 인공 지능

7개의 더 많은 오픈 소스 도구

언어 모델 구축은 데이터로 시작합니다.

무료로 구독할 수있는 AI 소식지 BrainScriblr도 쓰고 있어요.



<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>

모든 이미지는 별도로 표기되지 않는 한, 제가 캡처한 스크린샷입니다.

## Netshoot

Netshoot은 Docker 및 Kubernetes 네트워크 문제 해결용 컨테이너로, 네트워크 문제를 진단하고 해결하는 다재다능한 도구로 사용됩니다. 컨테이너화된 환경에서 복잡한 네트워킹 문제를 이해하고 해결하는 데 도움이 되는 포괄적인 도구 세트를 제공합니다.

Netshoot의 주요 기능 중 하나는 네트워크 네임스페이스의 사용으로, 네트워킹과 관련된 시스템 리소스를 격리할 수 있습니다. 이를 통해 특정 컨테이너나 팟 내에서 자세한 검사와 문제 해결이 가능합니다. 이 도구는 기존 팟의 디버깅을 위해 일회용 컨테이너를 사용하거나 디버깅을 위해 일시적인 팟을 생성하거나, 호스트의 네트워크 네임스페이스 내에서 컨테이너를 시작하여 호스트 수준의 문제 해결할 수도 있습니다. 또한 응용 프로그램 컨테이너와 함께 해결해야 하는 사이드카 컨테이너로 사용할 수도 있습니다.



<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>

Netshoot은 netstat, nmap, tcpdump, iftop, iperf, drill, nsenter 등 다양한 네트워킹 도구를 포함하고 있어 네트워크 분석과 문제 해결에 탁월한 기능을 제공합니다. Kubernetes와 잘 통합되어 있어 직접 명령어 또는 Netshoot Kubectl 플러그인을 통해 임시 컨테이너를 쉽게 만들 수 있어요. Docker 사용자들은 Docker 명령어나 Docker Compose를 사용하여 Netshoot을 배포할 수 있어 다양한 배포 시나리오에 유연성을 제공합니다.

## Superfile

Superfile은 공통 파일 작업을 쉽게 할 수 있도록 설계된 현대적이고 시각적으로 매력적인 터미널 파일 매니저에요. macOS 및 Linux 사용자를 위한 빠르고 쉬운 설치 프로세스를 제공하며 간단한 명령어로 설치할 수 있어요. 대체 설치 방법을 선호하는 사용자들을 위해 프로젝트 페이지에서 추가 옵션이 제공됩니다.

소스 코드에서 Superfile을 빌드하려는 사용자들을 위한 프로세스는 간단해요. 저장소를 복제하고 적절한 디렉터리로 이동하여 빌드 스크립트를 실행하고 생성된 바이너리를 시스템 경로로 이동하는 과정이에요. 이 방법은 설치 프로세스에 대한 더 많은 제어를 제공합니다.



<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>

슈퍼파일은 현재 리눅스와 macOS를 완벽하게 지원하며 Windows 시스템에서 일부 지원됩니다. 여러분의 경험을 맞춤화하기 위해 다양한 플러그인과 테마를 제공하여 사용자 경험을 세부적으로 조정하는 데 엄청난 노력을 기울이고 있습니다. 이 파일 관리자는 구성 가능한 단축키를 제공하며 vim/nvim 사용자를 위한 구체적인 설정도 제공하여 이 텍스트 편집기에 익숙한 사용자에게 높은 편리성을 제공합니다.

문제 해결에 도움을 드리기 위해 프로젝트는 포괄적인 가이드와 귀중한 팁을 제공합니다. 개발자는 커뮤니티로부터의 기여를 환영하며 프로젝트 개발에 참여하고 싶은 분들을 위한 지침서를 저장소에서 제공하고 있습니다.

## 코드 해석기



<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>

E2B의 코드 해석기 SDK는 코드 해석 기능을 AI 애플리케이션에 통합하기 위해 설계된 도구입니다. 이 도구를 사용하면 AI 앱이 E2B 샌드박스 내에서 코드를 해석하고 실행할 수 있습니다. E2B 샌드박스는 신뢰할 수 없는 AI 생성 코드 및 AI 에이전트를 실행하는 안전한 오픈 소스 환경입니다.

이 SDK는 모든 대형 언어 모델 (LLM) 및 AI 프레임워크를 지원하며 차트, 표준 출력 및 표준 에러와 같은 스트리밍 콘텐츠를 지원합니다. SDK는 Python 및 JavaScript/TypeScript (JS/TS) 모두에서 사용할 수 있어 다양한 개발 환경에 유연하게 대응할 수 있습니다.

코드 해석기 SDK는 서버리스 및 엣지 기능에 배포할 수 있어 AI 생성 코드를 안전하게 실행할 수 있습니다. 또한 전체 인프라는 완전히 오픈 소스로, 사용자에게 투명성과 유연성을 제공합니다.

현재 SDK는 Python을 완전히 지원하며, JavaScript, R 및 Java의 베타 지원이 제공됩니다. JavaScript/TypeScript 및 Python에 각각 간단한 npm 또는 pip 명령을 사용하여 쉽게 설치할 수 있습니다.



<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>

SDK는 JavaScript와 Python 양쪽에 대해 사용하기 쉬운 인터페이스를 제공합니다. 사용자는 몇 줄의 코드로 샌드박스를 생성하고 코드 셀을 실행하며 결과를 검색할 수 있습니다. 이 간편함으로 모든 경험 수준의 개발자들에게 접근성을 제공합니다.

E2B는 개발자들이 쉽게 시작할 수 있도록 상세한 문서 및 빠른 시작 가이드를 제공합니다. 이에는 JavaScript/TypeScript 및 Python에 대한 쿡북 예제, "Hello World" 가이드뿐만 아니라 다양한 LLM 제공업체 및 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>

Kitbag Router은 Vue.js 애플리케이션에 특별히 설계된 타입 안전한 라우팅 라이브러리입니다. 이는 라우팅 프로세스를 간단하고 향상시키려는 목적으로, Vue 프로젝트 내에서 탐색을 관리하기 위한 강력한 도구 세트를 제공합니다.

이 라이브러리는 bun, yarn 또는 npm과 같은 인기있는 패키지 관리자를 이용하여 쉽게 설치할 수 있습니다. 설치 후에는 `createRoutes` 함수를 사용하여 라우트를 정의할 수 있습니다. 이 함수를 사용하면 이름, 경로 및 관련 컴포넌트를 지정하는 각 라우트의 배열을 생성할 수 있습니다.

Vue 애플리케이션에 Kitbag Router를 구현하려면, `createRouter` 함수를 사용하여 라우터 인스턴스를 생성하고 이를 플러그인으로 Vue 앱에 전달해야 합니다. 이 설정을 통해 애플리케이션 전체에서 라우팅 기능을 활성화할 수 있습니다.

라우트 간 이동은 `router.push` 메서드를 통해 용이하게 수행할 수 있으며, 이 메서드는 라우트 이름, URL 경로 및 완전한 URL을 처리할 수 있습니다. 더 동적인 라우팅을 위해, 라이브러리는 `router.route.update`를 사용하여 런타임에서 라우트 매개변수를 업데이트할 수 있는 기능을 제공합니다.



<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>

Kitbag Router은 Vue 템플릿에서 사용할 수 있는 두 가지 주요 구성 요소인 `RouterView`와 `RouterLink`를 제공합니다. `RouterView` 컴포넌트는 라우트 컴포넌트가 애플리케이션 레이아웃 내에서 렌더링될 위치를 정의합니다. 반면에 `RouterLink` 컴포넌트는 페이지 다시로드를 유발하지 않고 라우트 간의 탐색을 가능하게 하므로 싱글 페이지 애플리케이션 경험을 향상시킵니다.

타입 안전성과 효율적인 라우트 관리에 중점을 둔 Kitbag Router는 Vue 개발자에게 원활하고 탐색 가능한 웹 애플리케이션을 만들 수 있는 강력한 도구를 제공합니다. 보다 자세한 정보와 사용 예시는 Kitbag Router GitHub 저장소에서 확인할 수 있습니다.

## AWS Lamda Web Adapter

AWS Lambda 웹 어댑터는 기존 웹 개발과 서버리스 아키텍처를 연결하여 웹 애플리케이션을 AWS Lambda에서 실행할 수 있게 하는 도구입니다. 다양한 웹 프레임워크를 지원하여 기존 애플리케이션을 최소한의 변경으로 Lambda에 배포할 수 있게 합니다.



<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로의 배포를 단순화하여 기존의 웹 프레임워크에 익숙한 개발자들에게 서버리스 아키텍처를 더 쉽게 접근할 수 있도록 도와줍니다.

사용 사례에는 서버리스 환경에서 웹 응용 프로그램, 마이크로서비스 및 API를 배포하는 것이 포함됩니다. 이 프로젝트는 오픈 소스로, 커뮤니티 기여와 개선을 촉진합니다.

이 어댑터는 지속적 통합 및 배포 워크플로우를 통합하여 효율적인 테스트 및 배포 프로세스를 용이하게 합니다. 익숙한 개발 관행을 유지하면서 서버리스 장점을 활용하고자 하는 개발자들을 위해 AWS Lambda 웹 어댑터가 가치 있는 해결책을 제공합니다.



<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>

## 리액트 Lua

리액트 Lua는 ReactJS 17.x를 JavaScript에서 Lua로 번역하는 프로젝트로, 성능과 정확성을 최적화합니다. 기본적으로 원래의 ReactJS와 근접하게 유지하면서 Lua의 장점을 활용하려고 합니다.

이 프로젝트는 가능한 경우 Luau 유형 주석을 사용하며 대부분의 ReactJS 리소스와 호환되도록 설계되었으며 언어 차이에 맞게 조정되었습니다. Roblox의 react-lua의 포크로 커뮤니티 주도의 대안으로 의도되었습니다.

React Lua는 'react', 'scheduler', 'shared'와 같은 주요 패키지를 이식했으며 일부 패키지는 이식되지 않은 상태입니다. Roblox 생태계를 고려하기 위해 Roact와 호환성을 지향하며 일부 조정사항이 있습니다.



<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>

기여자들은 상류 ReactJS와의 일치를 유지하고 필요한 경우 어떠한 이탈 사항도 문서화하는 것을 권장합니다. 이 프로젝트는 ReactJS와 Lua 생태계 사이의 다리 역할을 하며, Lua 개발자들을 위한 익숙하면서도 최적화된 개발 경험을 제공합니다.

토론된 도구들은 다양한 기능을 다루고 있습니다: Docker와 Kubernetes에서 네트워크 진단을 위한 Netshoot, 현대적인 터미널 기반 파일 관리를 위한 Superfile, AI 애플리케이션에서 코드 실행을 통합하기 위한 E2B의 코드 인터프리터 SDK, Vue.js에서 타입 안전한 라우팅을 위한 Kitbag Router, 서버리스 인프라에서 웹 애플리케이션 실행을 위한 AWS Lambda 웹 어댑터, 그리고 ReactJS를 Lua로 변환하는 React Lua. 각 도구는 특정 개발자 요구를 해결하며, 각 도메인에서 공통적인 도전 과제에 대한 혁신적인 해결책을 제공합니다.

Posts