파이썬 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>

6월 말을 위한 8가지 GitHub 프로젝트

새롭고 인기 있는 엘릭서 저장소들

인기있는 9가지 GitHub 프로젝트

그리고 구독이 무료인 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>

저가 작성한 AI 노트 앱을 다룬 포스트가 있어요.

## Graphrag

Microsoft Research에서 개발한 GraphRAG는 대규모 언어 모델(LLM)의 검색 및 생성 능력을 향상시키는 고급 검색-증강 생성(RAG) 기술입니다. 이는 지식 그래프를 활용하여 생성된 응답의 품질과 관련성을 개선합니다.

벡터 데이터베이스에만 의존하는 대신, GraphRAG는 구조화된 지식 그래프를 활용하여 생성된 응답의 품질과 관련성을 개선합니다. 이는 텍스트 추출, 네트워크 분석, 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>

GraphRAG의 중요한 기능 중 하나는 텍스트에서 계층적 지식 그래프를 구축하는 것이며, Leiden 알고리즘과 같은 계층적 클러스터링 기술을 사용하여 정보를 요약하며, 질의 시간에 LLM에게 환경적으로 풍부하고 관련성 높은 정보를 제공하는 향상된 검색 기능이 있습니다.

이 접근 방식은 기본 RAG에 비해 상당한 장점을 제공합니다. 개선된 환경 이해력, 응답에 대한 증거 출처, 전체 데이터 질병 추론 수행 능력 등이 있습니다. 이는 비공개 데이터 집합을 분석하고 복잡한 질문을 처리하는 데 유용하며, 고급 챗봇, 가상 어시스턴트 및 상세한 데이터 분석 도구에 적합합니다.

## Claude 엔지니어

Claude 엔지니어는 Anthropic의 Claude-3.5-Sonnet 모델을 활용하는 명령줄 인터페이스(CLI)로, 소프트웨어 개발 작업을 보조합니다. Anthropic에 의해 개발되었으며, 상호작용형 채팅, 파일 시스템 작업, 웹 검색, 구문 강조, 프로젝트 구조 관리 및 코드 분석과 같은 기능이 통합되어 있습니다.


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

Claude Engineer는 다양한 기능을 강력한 CLI로 통합하여 작업 흐름을 최적화하고 생산성을 향상시키며 전반적인 소프트웨어 개발 경험을 개선합니다.

## TorToiSe

Tortoise TTS는 neonbjb에 의해 개발된 오픈 소스 텍스트 음성 변환(TTS) 시스템입니다. 이 도구는 강력한 다중 음성 기능을 갖추어 매우 현실적이고 표현력이 풍부한 음성 합성을 생성하도록 설계되었습니다.

이 시스템은 자동 회귀 및 확산 모델의 조합을 활용하여 텍스트를 자연스러운 음성으로 변환하며, 다양한 억양과 억양에 중점을 두고 있습니다. 또한 Tortoise TTS는 여러 언어를 지원하며 각각의 언어에 대해 많은 훈련 데이터가 필요하지 않고도 다양한 목소리를 모방할 수 있어 다양한 응용 프로그램에 유연하게 활용할 수 있는 도구입니다.


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

Tortoise TTS의 주요 기능은 제로샷 다중 음성 기능, 현실적인 프로소디와 억양, 몇 가지 예시를 기반으로 한 음성 클론 등이 있습니다. 또한 프로젝트 구조의 생성 및 관리를 지원하여 이 도구의 다재다능성을 향상시킵니다. Tortoise TTS는 높은 품질의 음성 합성으로 알려져 있지만, 처리 파이프라인이 복잡하기 때문에 병렬 TTS 모델에 비해 비교적 느립니다.

## Omniparse

Omniparse는 비구조적 데이터를 구조화된 형식으로 변환하여 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>

- 다양한 데이터 유형 (문서, 이미지, 오디오, 비디오, 웹 페이지) 처리합니다.
- 데이터 개인 정보 보호를 위해 로컬에서 작동합니다.
- Docker 및 Skypilot을 통해 배포할 수 있습니다.
- 사용자 친화적인 Gradio 인터페이스를 제공합니다.
- OCR, 레이아웃 감지 및 전사용 고급 모델을 사용합니다.

기능에는 테이블 추출, 이미지 캡션, 오디오/비디오 전사, 웹 크롤링, 스키마 기반 변환이 포함됩니다. 문서 처리, 미디어 분석, 웹 데이터 추출 및 AI 모델 준비에 이상적입니다.

Omniparse는 Linux 시스템에 설치하고 Docker를 사용하여 실행할 수 있습니다. 생성적 AI 및 대규모 언어 모델이 포함된 응용 프로그램에 특히 유용합니다.

![이미지](/TIL/assets/img/2024-07-14-11TrendingGithubProjects_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>

## OmniParser

안녕하세요! OmniParser는 다양한 데이터 형식을 처리하기 위한 Go 언어의 오픈 소스 ETL 라이브러리입니다.

중요한 기능:

- 다양한 입력 형식 지원 (CSV, XML, EDI, JSON 등)
- 성능을 위한 원시 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>

아주 유용한 내용이에요! 데이터 통합, ETL 프로세스, 데이터 정리, 그리고 API 데이터 처리에 활용할 수 있어요.

이 프로젝트는 포괄적인 문서와 커뮤니티 기여를 환영해요.

## Autogroq

AutoGroq은 Autogen 및 CrewAI와 호환되는 플랫폼을 위해 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>

시스템은 문제 분석 및 에이전트 생성을 위해 자연어 처리를 활용합니다. 다양한 언어 모델 및 내보내기 형식을 쉽게 통합할 수 있는 모듈식 아키텍처를 채택했습니다.

AutoGroq는 온라인 데모(autogroq.streamlit.app)와 로컬 설치용 GitHub 저장소로 제공됩니다. 작동을 위해서 Groq 개발자 API 키가 필요합니다.

이 도구의 아키텍처는 빠른 프로토타이핑, 워크플로 최적화 및 특화된 에이전트 생성을 용이하게 합니다. AI 기반 프로젝트 개발 및 테스트에 가치가 있는 도구입니다.

![이미지](/TIL/assets/img/2024-07-14-11TrendingGithubProjects_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>

## OpenAGI

오픈AGI는 자유로운 소스 플랫폼으로, 자율적 AI 에이전트의 개발과 배포를 진보시키기 위해 설계되었으며, 특히 대형 언어 모델 (LLMs)과 도메인 특화 전문 모델을 통합하는 데 중점을 두고 있습니다.

오픈AGI는 LLMs의 기능과 계획, 추론, 자립적 행동이 가능한 자율 에이전트에 대한 필요 사이의 간극을 줄이려고 노력하고 있습니다. 이는 실제 세계 상황에서 복잡한 다단계 작업을 처리할 수 있는 AI 에이전트의 생성을 용이하게 하는 데 목표를 두고 있습니다.

여기에는 OpenAGI의 작동 방식을 설명하는 논문이 있습니다.


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

## Vanna

Vanna는 자연어를 사용하여 SQL 쿼리를 생성하는 오픈 소스 Python 프레임워크입니다. RAG(retrieval-augmented generation)를 사용하여 복잡한 데이터 세트에서 높은 정확도를 제공하며 데이터 프라이버시를 유지하고 다양한 SQL 데이터베이스를 지원합니다. Vanna는 데이터베이스 스키마와 샘플 쿼리를 학습하는 RAG 모델을 통해 자연어 질문에서 SQL을 생성합니다.

이 프레임워크는 pip를 통해 쉽게 설치할 수 있으며 다양한 LLMs 및 벡터 데이터베이스와 함께 사용할 수 있습니다. Jupyter 노트북 및 Streamlit 앱을 포함한 여러 사용자 인터페이스 옵션을 제공합니다. Vanna는 LLMs나 벡터 데이터베이스의 사용자 지정 구현을 허용하도록 설계되어 확장 가능합니다.

Vanna는 활발한 커뮤니티 개발과 포괄적인 문서화를 통해 비기술적 사용자를 위한 데이터베이스 쿼리 작업을 간소화하고 신속한 프로토 타이핑을 용이하게 하며 데이터 분석 워크플로우를 향상시키는 것을 목표로 합니다. 데이터베이스 상호 작용을 보다 접근 가능하게 만드는 중요한 단계를 나타냅니다.


<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-14-11TrendingGithubProjects_2.png)

## Fine-tuning llama 3

This is a concept and not an open source project, but it is important to know this if you are building your own LLMs.

Fine-tuning Llama 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>

- 8B 및 70B 매개변수 버전으로 사용 가능
- MMLU 및 HumanEval과 같은 벤치마크에서 높은 성능
- 파인튜닝 방법: Full Parameter, LoRA, QLoRA
- 도구: Unsloth, PyTorch FSDP, TRL
- 과제: 베이스 모델 문제, 프롬프트 민감도
- 권장 사항: LoRA/QLoRA부터 시작하고, 학습률과 배치 크기 최적화
- 응용: 고객 지원 자동화, 의도 분류
- 자원: Hugging Face, Unsloth, YouTube에서 제공하는 튜토리얼
- 배포 시 윤리적 고려 사항 중요

Llama 3의 파인튜닝은 과업별 모델의 가능성을 제공하지만, 적절한 하드웨어 및 방법 선택과 적절한 데이터 준비가 필요합니다.

## TensorRT

TensorRT는 NVIDIA가 개발한 오픈소스 딥러닝 추론 최적화 및 런타임 도구입니다. NVIDIA GPU에서 성능을 향상시키도록 설계되었으며, ONNX 및 TensorFlow SavedModel과 같은 다양한 입력 형식을 지원합니다. 이 소프트웨어는 레이어 퓨전 및 정밀도 보정과 같은 최적화 기술을 제공하며, C++ 및 Python API를 모두 지원합니다. 별도의 프로젝트인 TensorRT-LLM은 대규모 언어 모델의 최적화에 초점을 맞춥니다. 최신 버전인 TensorRT 10.1.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>

커뮤니티 프로젝트들이 TensorRT의 기능을 확장하여 PyTorch와 같은 프레임워크와 통합했습니다. TensorRT 자체는 프로프리어터리이지만, 오픈 소스 구성 요소는 다양한 라이선스로 제공됩니다. NVIDIA 하드웨어에서 딥 러닝 추론을 최적화하려는 개발자들에게 TensorRT는 강력한 해결책을 제공하며, 강력한 커뮤니티 지원과 지속적인 개발을 제공합니다.

## 홈 어시스턴트 코어

홈 어시스턴트 코어는 홈 어시스턴트 생태계의 기반이되는 오픈 소스 홈 자동화 플랫폼으로서, 로컬 제어 및 개인 정보 보호에 중점을 두고 있습니다.

다양한 운영 체제에서 스마트 홈 기기를 추적, 제어 및 자동화하는 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 가상 환경을 사용한 수동 설정과 같은 다양한 방법으로 설치할 수 있습니다. 해당 프로젝트는 강력한 커뮤니티를 가지고 있으며, GitHub에서 소스 코드를 제공하고 정기적으로 업데이트됩니다.

오픈 소스 프로젝트는 소프트웨어 산업에서 계속해서 주요 동력이 되고 있습니다. 이들은 협업, 투명성, 혁신이라는 기본적인 원칙을 구현하며 기술 발전을 위해 필수적인 가치를 내포하고 있습니다.

다양한 프로젝트들을 통해 확인할 수 있듯이, 오픈 소스 솔루션은 종종 품질, 보안, 기능 면에서 사유 소스 제품을 능가하거나 맞먹습니다.

오픈 소스 모델은 개인 개발자와 기업 뿐만 아니라 기술 커뮤니티와 사회 전반에도 이익을 제공합니다. 강력한 도구와 기술에 대한 접근성을 둘려주며, 모든 규모의 개인 및 조직들이 혁신하고 경쟁할 수 있는 수준 playing field에서 수행할 수 있도록 합니다.

현재 핫한 GitHub 프로젝트 11선

퀀트를 위한 블랙-숄즈 모델 완벽 가이드

![image](/TIL/assets/img/2024-07-14-CreatingaReLUActivationFunctionfromScratchAStep-by-StepGuideinPythonCandRust_0.png)

# 소개

신경망 세계에서 활성화 함수는 모델의 출력을 결정하는 데 중요한 역할을 합니다. 가장 인기 있는 활성화 함수 중 하나는 ReLU(렉티파이드 루 linear Unit)입니다. 간단함과 효과적임으로 유명한 ReLU는 많은 딥러닝 모델에서 표준 선택지가 되었습니다. 이 안내서에서는 Python, C 및 Rust 세 가지 다른 프로그래밍 언어로부터 ReLU 활성화 함수를 처음부터 만드는 과정을 안내합니다. 이를 통해 다양한 플랫폼에서의 구현과 이점에 대한 명확한 이해를 제공할 것입니다.

# ReLU란 무엇인가요?



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

ReLU은 Rectified Linear Unit의 약자입니다. 이는 입력 값을 반환하는 활성화 함수로 정의됩니다:

![ReLU Activation Function](/TIL/assets/img/2024-07-14-CreatingaReLUActivationFunctionfromScratchAStep-by-StepGuideinPythonCandRust_1.png)

더 간단히 말하면, 입력 값이 양수인 경우 입력 값을 반환하고, 그렇지 않으면 0을 반환합니다. ReLU 함수는 수학적으로 다음과 같이 표현됩니다:

![ReLU Formula](/TIL/assets/img/2024-07-14-CreatingaReLUActivationFunctionfromScratchAStep-by-StepGuideinPythonCandRust_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>

# ReLU를 사용하는 이유?

- 단순성: ReLU 함수는 0을 기준으로 한 간단한 임계값 처리를 포함하기 때문에 계산 효율적입니다.
- 비선형성: 선형 함수처럼 보이지만 ReLU는 비선형성을 도입하여 복잡한 패턴을 학습하는 데 필수적입니다.
- 희소 활성화: ReLU는 희소한 활성화를 생성하는 경향이 있어서 (많은 뉴런이 0을 출력) 네트워크를 더 효율적으로 만듭니다.

# Python에서 ReLU 및 신경망 레이어 구현하기

파이썬에서 ReLU 활성화 함수와 간단한 신경망 레이어를 구현해보겠습니다.


<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: ReLU 함수 정의

먼저, 간단한 파이썬 함수를 사용하여 ReLU 함수를 정의해 보겠습니다.

```python
def relu(x):
    return max(0, 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>

## 단계 2: 배열에 ReLU 적용하기

우리는 NumPy를 사용하여 배열을 처리할 수 있는 ReLU 함수를 확장할 것입니다.

```python
import numpy as np

def relu_array(arr):
    return np.maximum(0, arr)
```

## 단계 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>

자, 이제 간단한 신경망 레이어 클래스를 만들어봅시다.

```js
class SimpleNeuralLayer:
    def __init__(self, input_size, output_size):
        self.weights = np.random.randn(input_size, output_size)
        self.biases = np.zeros(output_size)

    def forward(self, inputs):
        z = np.dot(inputs, self.weights) + self.biases
        return relu_array(z)
```

## 단계 4: 신경망 레이어 테스트

```js
# 예제 사용법
layer = SimpleNeuralLayer(3, 2)
inputs = np.array([1, 2, -1])
output = layer.forward(inputs)
print(output)
```


<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에서 ReLU 및 신경 계층 구현

이제 C에서 ReLU 함수와 간단한 신경망 계층을 구현해 보겠습니다.

# C 구현

## 단계 1: ReLU 함수 정의


<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
#include <stdio.h>

double relu(double x) {
    return x > 0 ? x : 0;
}
```

## 단계 2: 배열에 ReLU 적용하기

```js
#include <stdio.h>

void relu_array(double* arr, int size) {
    for (int i = 0; i < size; i++) {
        arr[i] = arr[i] > 0 ? arr[i] : 0;
    }
}
```

## 단계 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>


## 단계 4: 신경망 레이어 테스트

```js
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
    srand(time(NULL));
    SimpleNeuralLayer layer = create_layer(3, 2);
    double inputs[] = {1, 2, -1};
    double output[2];
    forward(layer, inputs, output);
    printf("Output: %f %f\n", output[0], output[1]);
    free(layer.weights);
    free(layer.biases);
    return 0;
}
```

# ReLU 및 신경망 레이어 구현하기



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

마침내, ReLU 함수와 간단한 신경망 레이어를 Rust로 구현해 봅시다.

# Rust 구현

## 단계 1: ReLU 함수 정의

```rust
fn relu(x: f64) -> f64 {
    if x > 0.0 { x } else { 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>

## 단계 2: 배열에 ReLU 적용하기

```js
fn relu_array(arr: &mut [f64]) {
    for x in arr.iter_mut() {
        *x = if *x > 0.0 { *x } else { 0.0 };
    }
}
```

## 단계 3: 간단한 신경망 계층 정의

```js
use rand::Rng;

struct SimpleNeuralLayer {
    weights: Vec<Vec<f64>>,
    biases: Vec<f64>,
}

impl SimpleNeuralLayer {
    fn new(input_size: usize, output_size: usize) -> Self {
        let mut rng = rand::thread_rng();
        let weights = (0..input_size)
            .map(|_| (0..output_size).map(|_| rng.gen_range(-1.0..1.0)).collect())
            .collect();
        let biases = vec![0.0; output_size];
        
        SimpleNeuralLayer { weights, biases }
    }

    fn forward(&self, inputs: &[f64]) -> Vec<f64> {
        let mut output = vec![0.0; self.biases.len()];
        
        for (i, &bias) in self.biases.iter().enumerate() {
            output[i] = inputs.iter()
                .zip(&self.weights)
                .map(|(&input, weight_row)| input * weight_row[i])
                .sum::<f64>() + bias;
            output[i] = relu(output[i]);
        }
        output
    }
}
```


<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: 신경 계층 테스트

```js
fn main() {
    let layer = SimpleNeuralLayer::new(3, 2);
    let inputs = [1.0, 2.0, -1.0];
    let output = layer.forward(&inputs);
    
    for value in output {
        print!("{} ", value);
    }
    // 출력: 0 0
}
```

# 결론

ReLU 활성화 함수를 만들고 간단한 신경망 계층에 통합하는 것은 신경망 작업에 대한 기본 개념을 강조합니다. Python, C 및 Rust에서 ReLU를 구현함으로써, 여러 플랫폼에서 딥러닝 모델의 성공을 이끌어내는 주요 구성 요소 중 하나에 대한 통찰을 얻을 수 있습니다.


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

기계 학습 초보자이거나 경험이 풍부한 실무자이든 ReLU와 같은 활성화 함수의 내부 작업을 이해하는 것이 중요합니다. 이 지식을 통해 다양한 응용 프로그램을 위해 신경망을 더 잘 설계, 디버그 및 최적화할 수 있습니다.

좋은 코딩되세요!

![image](/TIL/assets/img/2024-07-14-CreatingaReLUActivationFunctionfromScratchAStep-by-StepGuideinPythonCandRust_3.png)

Python, C, Rust로 직접 만들어보는 ReLU 활성화 함수 단계별 가이드

배포 후 머신러닝 모델을 관리해야 하는 이유

## TOP 10 PYTHON INTERVIEW QUESTIONS

회사나 역할에 따라 자주 나오는 인터뷰 질문이 다양하지만, 일반적으로 큰 기술 회사의 인터뷰에서는 기본 지식, 알고리즘, 시스템 디자인 질문이 흔합니다. 이 블로그에서는 대형 기술 회사 인터뷰에서 자주 나오는 10가지 질문을 다루고 있습니다.

# 1. 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>

# 2. Python 코드는 어떻게 실행되나요?

- 해석기는 Python 코드를 읽고 구문 또는 형식 오류를 확인합니다.
- 오류가 없다면 해석기는 코드를 바이트 코드로 변환합니다.
- 이 바이트 코드는 Python 가상 머신에 실행을 위임합니다. 실행 중 오류가 발생하면 프로세스가 중단됩니다; 그렇지 않으면 결과가 표시됩니다.

![](/TIL/assets/img/2024-07-14-10Must-KnowPythonInterviewQuestionsforTechGiants_0.png)

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

- 반복자(Iterator): `next()` 작업을 지원하는 객체로, 일련의 요소를 포함합니다. `next()` 메서드는 요소를 하나씩 반환하고 모든 요소가 반환된 경우 `StopIteration`을 발생시킵니다. 반복자는 `__iter__()`와 `__next__()` 메서드를 구현합니다.
- 생성자(Generator): `yield` 키워드를 사용하여 생성자 객체를 반환하는 함수입니다. 이 객체는 실행을 일시 중단하고 다시 시작할 수 있습니다. 생성자에서 `next()`를 호출하면 `yield` 문에 도달할 때까지 실행이 계속되며, 생성자는 요청 시 값을 생성하여 메모리를 절약하고 효율성을 높일 수 있습니다.
- 차이점: 생성자는 함수 및 `yield` 키워드를 사용하여 정의된 특별한 반복자로, 내장 `iter()` 함수로 생성된 표준 반복자와 달리 호출 가능한 일반 함수이며 값들을 순차적으로 생성합니다.

# 4. `yield`를 사용하는 방법

- `yield`는 함수에서 생성자를 반환하는 Python 키워드입니다. 생성자는 모든 데이터를 한 번에 메모리에 저장하지 않기 때문에 대규모 데이터나 복잡한 구조에 유용한 지연 계산을 허용합니다.
- `yield`를 포함하는 함수를 **생성자 함수(Generator function)**라고 합니다. 값의 시리즈를 생성하고 각 호출 시 이전 상태에서 실행을 계속합니다.

```js
# 원래 방법: 대형 목록은 많은 메모리를 사용합니다
def create_numbers(n):
    num_list = []
    for i in range(n):
        num_list.append(i)
    return num_list

# yield 사용: 메모리를 효율적으로 사용하는 데이터 스트림 생성
def create_numbers(n):
    for i in range(n):
        yield i

nums = create_numbers(5)
for num in nums:
    print(num)
```  


<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. 파이썬2와 파이썬3의 차이점은 무엇인가요?

- 정수 타입: 파이썬2는 int와 long을 구분하지만, 파이썬3는 구분하지 않습니다.
- 문자열 포매팅: 파이썬3는 포매팅을 위해 f-문자열을 도입했습니다.
- 정수 나눗셈: 파이썬2는 정수 나눗셈을 수행하고, 파이썬3는 부동 소수점을 반환합니다.
- 인코딩: 파이썬2는 기본적으로 ASCII를 사용하며, 파이썬3는 유니코드를 사용합니다.
- 출력문: 파이썬2는 `print`를 사용하고, 파이썬3는 `print()`를 사용합니다.
- `range()` 함수: 파이썬2는 리스트를 반환하지만, 파이썬3는 이터레이터를 반환합니다.
- `input()`과 `raw_input()`: 파이썬2는 문자열에 대해 `raw_input()`을 사용하고, 파이썬3는 `input()`을 사용합니다.

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

- 참조 카운팅은 객체 참조를 추적합니다. 카운트가 제로에 도달하면 객체가 삭제됩니다.
- 가비지 컬렉션은 순환 참조를 처리하며, 객체를 수명에 따라 세대로 나누고 그에 따라 쓰레기를 수거합니다.

이러한 메커니즘들은 Python이 메모리를 자동으로 관리할 수 있게 하며, 개발자들이 메모리 세부사항에 집중하는 대신 논리에 집중할 수 있게 합니다.

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

# 8. 클로저란 무엇인가요?

클로저는 내부 함수가 외부 함수의 변수에 의존하고, 외부 함수가 내부 함수를 반환할 때 생성됩니다. 이는 외부 함수가 실행을 마친 후에도 내부 함수가 이러한 변수에 액세스를 유지할 수 있게 합니다.

```js
def out_function(y):
    def in_function(x):
        return x + y
    return in_function

f = out_function(5)
print(f(3))  # 8
```

# 9. `is not`과 `!=`의 차이점은 무엇인가요?


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

- `!=`: 두 객체가 서로 다른 값을 가지는지 확인합니다.
- `is not`: 두 객체가 메모리에서 서로 다른지 확인합니다.

# 10. 람다 함수란 무엇인가요?

람다 함수 또는 익명 함수는 이름이 없는 한 줄짜리 함수입니다. 여러 매개변수를 가질 수 있지만 표현식은 하나뿐입니다.

최신 AI 이야기를 탑재하려면 Substack에서 저희와 연락을 유지하세요. 함께 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>

파이썬 이야기를 업데이트 받으려면 Substack에서 우리와 함께하세요. 함께 파이썬을 배워봐요!

대기업 취업을 위한 필수 Python 면접 질문 10선

# TL;TR

증강 식물 지수 (EVI)는 원격 감지에서 널리 사용되는 분광 지수로, 위성 영상을 통해 식물 건강 및 영역을 평가하는 데 사용됩니다. 일반화된 차이 식물 지수 (NDVI)를 개선하여 대기 영향을 최소화하고 수관 구조 변화 및 밀집 식물 지역에 대한 민감도를 향상시켰습니다.

## EVI의 주요 특징:

- 식물에 대한 민감도: EVI는 대기 영향을 최소화하고 수관 특성에 대한 민감도를 증가시킴으로써 특히 밀집 식물 지역에서 효과적으로 작동하도록 설계되었습니다.
- 공식: EVI 공식은 빨강, 근적외선 (NIR), 파랑 분광대를 포함하여 식물에 대한 민감도를 개선합니다.


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

여기서:

- NIR은 근적외선 대역의 반사율입니다.
- Red는 빨간 대역의 반사율입니다.
- Blue는 파란 대역의 반사율입니다.
- G는 이득 요소입니다 (기본값: 2.5).
- C1 및 C2는 대기의 영향을 최소화하기 위한 계수입니다 (기본값: 각각 6 및 7.5).
- L은 수관 배경 조정 요소입니다 (기본값: 1).

값의 범위: EVI 값은 일반적으로 -1에서 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>

- 높은 값은 밀도가 높은 식물을 나타냅니다.
- 0 또는 음수에 가까운 값은 비식물 또는 희소식물이 자리 잡은 지역을 나타냅니다.

## 응용:

- 식물 모니터링: EVI는 식물 동태를 모니터링하는 데 널리 사용되며 성장 패턴, 건강 평가, 그리고 환경 요소 또는 인간 활동으로 인한 변화 감지에 도움이 됩니다.
- 토지 이용 및 토지 피복 매핑: 특히 식물로 지배되는 토지 이용 유형을 매핑하고 분류하는 데 도움이 됩니다.
- 생태학 연구: 식물 분포를 분석하는 데 유용하며, 생물 다양성 평가 및 서식지 매핑에 활용됩니다.

## 장점:


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

- 민감도 향상: NDVI와 비교하여 밀집 식물 지역의 변화에 대한 감도를 향상시켰습니다.
- 대기 보정: 대기 간섭을 줄이기 위한 계수를 포함하여 대기 보정을 통해 전 세계 및 지역 규모의 응용 프로그램에 더 견고하게 만들었습니다.

## 고려 사항:

- 데이터 요구 사항: 일반적으로 중고해상도 위성 플랫폼에서 널리 사용되는 빨강, NIR 및 파랑 밴드를 갖춘 다중 스펙트럼 위성 영상이 필요합니다.
- 매개변수 민감도: 계수 G, C1, C2 및 L의 선택에 민감하며 특정 환경 조건 및 연구 목표에 따라 조정이 필요할 수 있습니다.

## 선행 조건:


<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 3.10+
- 시각화를 위한 QGIS 3.X.X +

또한 다음이 필요합니다:

- Copernicus 사이트에서 다운로드할 데이터 세트. 2024년 2월 27일 센티넬 2 2A 이미지로 작업할 예정입니다 (이미지 참조: T36QUL_20240227T082911).
- Copernicus 플랫폼에서 다운로드할 수 있습니다; 데이터 다운로드에 대한 문서를 확인할 수 있습니다.


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

# Sentinel-2 데이터를 활용한 실제 적용:

## 1. 저장소 복제

분류 스크립트 및 학습 샘플을 가져오세요:

```js
git clone https://github.com/kokatic/remote_sensing
```


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

내 레포지토리(/data/)에 데이터 폴더를 추가했습니다. 이 폴더에는 2024년 4월 30일 에르 우에드 지역의 Sentinel-2 데이터가 포함되어 있습니다. 기준 이미지는 T32SKC_20240430T102021이며, 밴드 4와 8을 포함하고 있습니다.

## 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
python -m venv venv
```

그런 다음 가상 환경을 활성화합니다:

Windows용 (CMD)에서:


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


venv\Scripts\activate # Linux의 경우: source venv/bin/activate


필요한 패키지 설치 후:


pip install -r requirements.txt


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

동일한 폴더에서 스크립트를 실행하려면 터미널 또는 명령 프롬프트를 열고 스크립트가 있는 폴더로 이동한 다음 다음 명령을 실행하세요:

```js
import rasterio
import numpy as np

def calculate_evi(red_band_path, nir_band_path, blue_band_path, output_path):
    try:
        # rasterio 데이터셋으로 빨간색, NIR, 파란색 밴드 열기
        with rasterio.open(red_band_path) as red_dataset, \
             rasterio.open(nir_band_path) as nir_dataset, \
             rasterio.open(blue_band_path) as blue_dataset:

            # rasterio 데이터셋에서 데이터 읽기
            red = red_dataset.read(1, masked=True).astype('float32')
            nir = nir_dataset.read(1, masked=True).astype('float32')
            blue = blue_dataset.read(1, masked=True).astype('float32')

            # EVI 계산
            G = 2.5
            C1 = 6
            C2 = 7.5
            L = 1
            epsilon = 1e-6  # 0으로 나누기를 피하기 위한 작은 엡실론 값
            denominator = nir + C1 * red - C2 * blue + L
            evi = np.where(denominator != 0, G * ((nir - red) / denominator), np.nan)

            # EVI 값을 [-1, 1] 범위로 클리핑
            evi = np.clip(evi, -1, 1)

            # EVI 출력을 위한 프로필 업데이트
            profile = red_dataset.profile
            profile.update(dtype=rasterio.float32, count=1, compress='lzw')

            # 새 GeoTIFF 파일에 EVI 결과 작성
            with rasterio.open(output_path, 'w', **profile) as dst:
                dst.write(evi.astype(np.float32), 1)

    except Exception as e:
        print(f"오류가 발생했습니다: {e}")

# 예시 파일 경로
red_band_path = 'data/Toshka/S2A_MSIL2A_20240227T082911/T36QUL_20240227T082911_B04_10m.jp2'  # 빨간색 밴드
nir_band_path = 'data/Toshka/S2A_MSIL2A_20240227T082911/T36QUL_20240227T082911_B08_10m.jp2'  # 근적외선 밴드
blue_band_path = 'data/Toshka/S2A_MSIL2A_20240227T082911/T36QUL_20240227T082911_B02_10m.jp2'  # 파란색 밴드
output_path = 'output/evi.tif'  # EVI 출력 파일

calculate_evi(red_band_path, nir_band_path, blue_band_path, output_path)
```

스크립트를 실행한 후 output/ 폴더에 EVI 출력물을 찾을 수 있습니다:

![EVI 출력물](/TIL/assets/img/2024-07-14-ProduceEVImapswithPythonSentinel2Data_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- 결과 확인: 시각화와 분석

- EVI 출력 파일 (evi.tif)을 QGIS에 로드합니다.
- 더 밀집한 식물 상층을 나타내는 더 높은 EVI 값의 시각화를 위해 적합한 컬러 팔레트를 적용합니다.
- EVI 값에 기반하여 관심 영역을 강조하기 위해 시각화 설정을 조정하여 식물 건강 평가 및 토지 피복 맵핑을 지원합니다.

![이미지1](/TIL/assets/img/2024-07-14-ProduceEVImapswithPythonSentinel2Data_3.png)

![이미지2](/TIL/assets/img/2024-07-14-ProduceEVImapswithPythonSentinel2Data_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>

# 결론

요약하자면, 향상된 식물지수(EVI)는 원격 감지 응용 프로그램에 강력한 도구로, 식물 역학 및 건강 평가에 대한 감도를 향상시켜줍니다. Sentinel-2 위성 이미지와 Python 및 QGIS와 같은 컴퓨터 도구를 활용하여 연구원 및 실무자는 효과적으로 식물 변화를 모니터링하고 토지 피복 유형을 분류하며 생태학 연구 및 환경 관리에 기여할 수 있습니다. 더 자세한 내용이나 문의 사항이 있으시면 언제든지 댓글을 남기거나 직접 연락해주세요.

# 팔로우

- 내 랜딩 페이지
- 내 Youtube 채널
- 내 SaaS 서비스
- 내 GitHub

Sentinel 2 데이터를 이용한 Python으로 EVI 지도 생성하는 방법

## 파이썬

프로젝트가 점점 커지면서, 컴퓨팅 자원을 효율적으로 관리하는 것은 불가피한 요구사항입니다.

안타깝게도, 특히 C나 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>

물론이죠.

사실, 파이썬 프로그램의 메모리 사용량을 최적화하는 많은 방법이 있습니다. 훌륭한 모듈과 도구부터 고급 데이터 구조와 알고리즘까지 다양한 방법이 있어요.

이 기사는 파이썬의 내장 메커니즘에 초점을 맞추고 7가지 기본적이지만 효과적인 메모리 최적화 요령을 소개할 거에요. 이들을 숙달하면 파이썬 프로그래밍 스킬이 상당히 향상될 거예요.

# 1. 클래스 정의에서 __slots__ 사용하기


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

파이썬은 동적 타이핑 언어로 객체 지향 프로그래밍에 있어 유연성을 가지고 있습니다. 좋은 예시로 파이썬 클래스에 런타임에서 추가적인 속성과 메서드를 넣는 기능이 있습니다.

예를 들어, 아래 코드는 'Author'라는 클래스를 정의합니다. 원래 'name'과 'age'라는 두 속성이 있었지만 나중에 손쉽게 하나를 더 추가할 수 있습니다:

```python
class Author:
    def __init__(self, name, age):
        self.name = name
        self.age = age

me = Author('Yang Zhou', 30)
me.job = 'Software Engineer'
print(me.job)
# Software Engineer
```

그러나 동전에는 양면이 있다고 하죠. 이 유연성은 내부에서 더 많은 메모리를 낭비합니다.


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

파이썬의 클래스의 모든 인스턴스는 인스턴스 변수를 저장하는 특별한 사전(__dict__)을 유지합니다. 이 사전은 해시 테이블 기반의 구현 때문에 메모리 효율이 좋지 않기 때문에 상당한 양의 메모리를 소비합니다.

대부분의 경우에는 인스턴스의 변수나 메서드를 런타임에 변경할 필요가 없으며, 클래스 정의 이후에는 __dict__가 변경되지 않습니다. 따라서 __dict__ 사전을 유지하는 것을 피하는 것이 좋습니다.

파이썬은 이를 위해 마법처럼 동작하는 속성을 제공합니다: __slots__.

이는 클래스의 모든 유효한 속성 이름을 지정하여 화이트리스트로 작동합니다:


<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
class Author:
    __slots__ = ('name', 'age')

    def __init__(self, name, age):
        self.name = name
        self.age = age

me = Author('양주', 30)
me.job = '소프트웨어 엔지니어'
print(me.job)
# AttributeError: 'Author' object has no attribute 'job'
```

위의 코드에서 보듯이, 런타임 중에 job 속성을 더 이상 추가할 수 없습니다. 왜냐하면 __slots__ 화이트리스트에서는 name과 age 속성만을 정의했기 때문입니다.

이론적으로 속성이 지금 고정되어 있기 때문에, Python은 더 이상 이를 위한 사전을 유지할 필요가 없습니다. __slots__에서 정의된 속성에 필요한 메모리 공간만 할당하면 됩니다.

이것이 실제로 작동하는지 여부를 확인하기 위해 간단한 비교 프로그램을 작성해 봅시다:



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

class Author:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class AuthorWithSlots:
    __slots__ = ['name', 'age']

    def __init__(self, name, age):
        self.name = name
        self.age = age

# Creating instances
me = Author('Yang', 30)
me_with_slots = AuthorWithSlots('Yang', 30)

# Comparing memory usage
memory_without_slots = sys.getsizeof(me) + sys.getsizeof(me.__dict__)
memory_with_slots = sys.getsizeof(me_with_slots)  # __slots__ classes don't have __dict__

print(memory_without_slots, memory_with_slots)
# 152 48
print(me.__dict__)
# {'name': 'Yang', 'age': 30}
print(me_with_slots.__dict__)
# AttributeError: 'AuthorWithSlots' object has no attribute '__dict__'
```

위 코드에서 볼 수 있듯이, __slots__를 사용하기 때문에 me_with_slots 인스턴스는 __dict__ 사전이 없습니다. 이는 me 인스턴스와 비교하여 추가 사전을 유지해야 하는 리소스를 효과적으로 절약합니다.

# 2. Generators 사용

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

그들은 요소를 생성하는 공장처럼 작동합니다: 모든 항목을 한꺼번에 계산하는 대신 next() 메서드가 호출될 때마다 항목을 생성합니다.

그렇기 때문에 대규모 데이터셋을 처리할 때 매우 메모리를 효율적으로 사용합니다.

```js
def number_generator():
    for i in range(100):
        yield i

numbers = number_generator()
print(numbers)
# <generator object number_generator at 0x104a57e40>
print(next(numbers))
# 0
print(next(numbers))
# 1
```

위 코드는 제너레이터를 작성하고 사용하는 기본적인 예제를 보여줍니다. yield 키워드가 제너레이터의 정의 핵심입니다. 이를 적용하면 항목 i는 next() 메서드가 호출될 때에만 생성됩니다.


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

numbers = []
for i in range(100):
    numbers.append(i)

def number_generator():
    for i in range(100):
        yield i

numbers_generator = number_generator()
print(sys.getsizeof(numbers_generator))
# 112
print(sys.getsizeof(numbers))
# 920
```

위 프로그램의 결과는 제너레이터를 사용하면 메모리 사용량을 크게 절약할 수 있다는 사실을 입증합니다.

그런데, 리스트 컴프리헨션의 대괄호를 괄호로 변환하면 제너레이터 표현식이 됩니다. 이것이 파이썬에서 제너레이터를 정의하는 더 간단한 방법입니다:


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

numbers = [i for i in range(100)]
numbers_generator = (i for i in range(100))

print(sys.getsizeof(numbers_generator))
# 112
print(sys.getsizeof(numbers))
# 920
```

# 3. 대용량 파일 처리를 위한 메모리 맵 파일 지원 활용

메모리 맵 파일 I/O, 줄여서 "mmap"이라고도 불리는 것은 OS 수준의 최적화입니다.

간단히 말해서, mmap 기술을 사용하여 파일을 메모리 맵핑하면 현재 프로세스의 가상 메모리 공간에 파일의 맵핑이 직접 생성되어 파일 전체를 메모리에 로드하는 대신 처리합니다.



<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 형식으로 변경할 수 있습니다.


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

with open('test.txt', "r+b") as f:
    # 파일을 메모리 매핑하여 사용할 수 있습니다. 크기 0은 전체 파일을 의미합니다.
    with mmap.mmap(f.fileno(), 0) as mm:
        # 표준 파일 메서드를 사용하여 내용 읽기
        print(mm.read())
        # 슬라이스 표기법을 사용하여 내용 읽기
        snippet = mm[0:10]
        print(snippet.decode('utf-8'))
```

위에서 보여진 대로, Python은 메모리 매핑된 파일 I/O 기술의 사용을 편리하게 만듭니다. 우리가 해야 할 일은 단지 mmap.mmap() 메서드를 적용하고, 표준 파일 메서드나 슬라이싱 표기법을 통해 개방된 객체를 처리하는 것뿐입니다.

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

전역 변수가 큰 데이터 구조를 보유하는 경우 프로그램 수명 전체 동안 메모리를 점유하므로 비효율적인 메모리 사용으로 이어질 수 있습니다.

파이썬 코드에서 전역 변수 사용을 최소화해야 합니다.

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

예를 들어, 반환된 boolean 값에 따라 최종 결과를 얻는 간단한 코드 스니펫이 있습니다:

```js
result_a = expensive_function_a()
result_b = expensive_function_b()
result = result_a if result_a else result_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
result = expensive_function1() or expensive_function2()
```

위 코드의 논리 연산자는 단락 평가 규칙을 따르기 때문에, expensive_function1()이 True 인 경우, 위 코드의 expensive_function2()는 실행되지 않습니다. 이는 불필요한 메모리 사용을 절약할 수 있습니다.

# 6. 데이터 유형 신중히 선택하기

고급 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은 메모리 할당 측면에서 최적화를 할 수 있습니다.

하지만, 리스트는 변경 가능하기 때문에 잠재적인 수정 사항을 수용하기 위해 추가 공간이 필요합니다.


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

my_tuple = (1, 2, 3, 4, 5)
my_list = [1, 2, 3, 4, 5]

print(sys.getsizeof(my_tuple))
# 80
print(sys.getsizeof(my_list)) 
# 120
```

위 코드 조각에서 보듯이, 같은 요소를 포함하고 있어도 튜플인 my_tuple이 리스트보다 적은 메모리를 사용합니다.

따라서, 데이터를 생성한 후에 변경할 필요가 없다면 리스트 대신 튜플을 사용하는 것이 좋습니다.

## 배열은 리스트보다 메모리를 더 효율적으로 사용합니다.


<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
import sys
import array

my_list = [i for i in range(1000)]

my_array = array.array('i', [i for i in range(1000)])

print(sys.getsizeof(my_list))  
# 8856
print(sys.getsizeof(my_array)) 
# 4064
```

## 우수한 데이터 과학 모듈이 내장 데이터 유형보다 효율적입니다


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

파이썬은 데이터 과학의 주요 언어입니다. NumPy와 Pandas와 같은 강력한 타사 모듈과 도구들이 더 많은 데이터 유형을 제공합니다.

만약 NumPy가 제공하는 많은 기능이 필요하지 않고 단순한 1차원 숫자 배열만 필요하다면, 파이썬의 내장 배열이 좋은 선택일 수 있습니다.

하지만 복잡한 행렬 조작이 필요한 경우에는, NumPy가 제공하는 배열을 사용하는 것이 모든 데이터 과학자에게 첫 번째이자 아마도 최상의 선택일 것입니다.

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

많은 개발자들을 혼란스럽게 만들 수 있는 코드는 다음과 같습니다:

```js
a = 'Y'*4096
b = 'Y'*4096
a is b
True
c = 'Y'*4097
d = 'Y'*4097
c is d
False
```

is 연산자는 두 변수가 메모리에서 동일한 객체를 참조하는지 확인하는 데 사용됩니다. 이는 == 연산자와는 다릅니다. == 연산자는 두 객체의 값을 비교합니다.

그래서 a is b는 True를 반환하지만, c is d는 False를 반환하는 이유는 무엇인가요?


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

파이썬에는 숨겨진 보석이 있습니다 — 문자열 인터닝 기술이 그것입니다.

값이 같은 몇 개의 작은 크기 문자열들이 있다면, 파이썬은 암묵적으로 그들을 인터닝하고 메모리에서 동일한 객체를 참조합니다.

작은 문자열을 정의하는 마법 숫자는 4096입니다.

c와 d의 길이가 4097이므로, 두 개의 객체가 메모리에 있기 때문에, 암묵적인 문자열 인터닝은 일어나지 않습니다. 따라서 c is d를 실행하면 False를 얻습니다.


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

문자열 인터닝은 메모리 사용량을 최적화하는 강력한 기술입니다. 명시적으로 수행하려면 sys.intern() 메서드를 활용해야 합니다:

```js
>>> import sys
>>> c = sys.intern('Y'*4097)
>>> d = sys.intern('Y'*4097)
>>> c is d
True
```

그리고, 문자열 인터닝 외에도 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>

X | Linkedin | Medium 

파이썬 메모리 관리 메커니즘에 관한 인터뷰 질문:

코드 효율성을 높이는 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>


<img src="/TIL/assets/img/2024-07-14-FactoryMethodpatterninPython_0.png" />

# Factory Method 패턴을 사용하지 않은 예제

다른 종류의 문서인 이력서와 보고서를 가진 예제를 만들어 봅시다.

이러한 문서 유형은 고유한 생성자를 가질 것입니다:



<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 abc import ABC, abstractmethod

# 제품 인터페이스 정의
class Document(ABC):
    @abstractmethod
    def create(self):
        pass

# 구체적인 제품 생성
class Resume(Document):
    def create(self):
        return "이력서 생성됨"

class Report(Document):
    def create(self):
        return "보고서 생성됨"
```

이후에는 이 유형의 문서를 선택하는 함수가 있을 것입니다:

```js
def create_document(document_type: str) -> Document:
    if document_type == "resume":
        return Resume()
    elif document_type == "report":
        return Report()
    else:
        raise ValueError(f"알 수 없는 문서 유형: {document_type}")
```

이후 팩토리 메서드 패턴을 통해 이 함수의 구현을 개선할 수 있음을 나중에 확인하게 될 것입니다.


<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 client_code(document_type: str):
    document = create_document(document_type)
    print(document.create())

if __name__ == "__main__":
    print("이력서 생성:")
    client_code("resume")
    
    print("\n보고서 생성:")
    client_code("report")
```

# 팩토리 메서드 사용

리팩토링에서는 여전히 각 객체의 생성자가 있습니다:


<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 abc import ABC, abstractmethod

# 제품 인터페이스 정의
class Document(ABC):
    @abstractmethod
    def create(self):
        pass

# 구체적인 제품 생성
class Resume(Document):
    def create(self):
        return "이력서 생성됨"

class Report(Document):
    def create(self):
        return "보고서 생성됨"
```

그러나 이제 각 유형의 문서 생성을 탈 중앙화했습니다:

```python
# 팩토리 메서드를 사용하여 생성자 클래스 정의
class DocumentCreator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

    def create_document(self):
        # 제품을 얻기 위해 팩토리 메서드 호출
        document = self.factory_method()
        return document.create()

# 구체적인 생성자 구현
class ResumeCreator(DocumentCreator):
    def factory_method(self):
        return Resume()

class ReportCreator(DocumentCreator):
    def factory_method(self):
        return Report()
```

새로운 문서 유형을 추가하는 것은 새로운 구체적인 생성자 클래스를 만드는 것만큼 간단합니다.


<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 client_code(creator: DocumentCreator):
    print(creator.create_document())

if __name__ == "__main__":
    print("이력서 생성 중:")
    resume_creator = ResumeCreator()
    client_code(resume_creator)
    
    print("\n보고서 생성 중:")
    report_creator = ReportCreator()
    client_code(report_creator)
```

# 차이점 설명

주요 차이점은 팩토리 메서드 패턴을 사용하지 않을 때, 객체를 프로그램 로직을 정의하는 곳과 동일한 위치에서 생성한다는 것입니다.


<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 create_document(document_type: str) -> Document:
    if document_type == "resume":
        return Resume()
    elif document_type == "report":
        return Report()
    else:
        raise ValueError(f"Unknown document type: {document_type}")
```

위의 예제는 매우 간단합니다. 새로운 문서 유형을 추가하거나 삭제할 때 이 논리를 변경하는 것은 비교적 쉬우지만, 더 복잡한 경우에는 더 비용이 많이 들 수 있습니다.

게다가, 이것에는 훌륭한 논리가 없습니다. 각 if/else 이후에 일련의 동작이 수행된다고 상상해보세요.

## 비교



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

- 팩토리 메소드 없이: 문서 생성 로직은 create_document 함수에 중앙 집중화되어 있습니다. 이는 더 간단하지만 코드를 유연하게 만들고 유지하기 어렵게 만듭니다. 새로운 유형의 문서를 추가하려면 create_document 함수를 수정해야 하며, 이로 인해 버그가 발생할 수 있고 전체 함수의 로직을 이해해야 합니다.
- 팩토리 메소드 사용: 생성 로직이 분산됩니다. 각 구체적인 생성자는 자체 유형의 문서를 생성하는 방법을 알고 있습니다. 새로운 유형의 문서를 추가하는 것은 새로운 구체적인 생성자 클래스를 만드는 것만큼 간답습니다. 이 접근 방식은 개방/폐쇄 원칙을 준수하며 코드를 보다 모듈식으로 만들고 확장하기 쉽게 만듭니다.

![Factory Method Pattern](/TIL/assets/img/2024-07-14-FactoryMethodpatterninPython_1.png)

# 어떻게 인식할까요?

이 패턴을 사용해야 하는 시점은 로직 일부가 서로 다른 객체 유형을 생성하는 if/else if/else를 사용하고 있을 때 가장 쉽게 인식할 수 있습니다.


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


# 예시
def mainfuntion():
    if option==1:
        Object1=Object_constructor()
        action1()
        action2()
    elif option==2:
        Object2=Object_constructor2()
        action3()
        action4()
    else:
        Object3=Object_constructor3()
        action5()
        action6()


우리는 보듯이, 이 논리는 사용된 객체의 유형에 매우 의존합니다. 다른 유형의 객체를 사용해야 한다면 프로그램의 논리를 바꿀 필요가 있습니다.

이러한 패턴을 보게 되면, 팩토리 메서드를 사용하여 개선을 고려할 수 있습니다.

# 결론



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

인터넷에서 찾을 수 있는 것들과는 조금 다른 방식으로 이 디자인 패턴을 설명해 보았어요. 가능한 가장 간단한 방법으로 설명해 보았답니다.

저는 이러한 패턴에 대해 다양한 정보원에서 배우는 것이 이상적이라고 생각해요. 각각의 예시를 보면서 개념을 더 깊이 이해할 수 있을 거예요.

이야기가 마음에 들기를 바랍니다.

관심 가져 주셔서 정말 감사합니다!

Posts