RNN LSTM부터 Temporal Fusion Transformers와 Lag-Llama까지 최신 시계열 예측 기술들

MLOps는 AI 통합과 혁신을 위한 기계 학습 모델과 실제 응용 프로그램 사이의 다리 역할을 합니다.

![MLOps](/TIL/assets/img/2024-07-09-WhatisMLOpsMachineLearningOperationsExplained_0.png)

저희가 사는 세상의 모든 측면에 AI가 통합된 시대에, 실리콘 밸리의 작은 팀이 기계 학습과 상호 작용하는 방식을 바꿀 수 있는 위험을 감지했습니다.

MLOps의 심층적인 내용을 밝혀냄으로써, 기계 학습 모델과 현실 세계 응용 프로그램 간의 간극을 메우는 역할을 발견할 수 있습니다.



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

저는 MLOps의 복잡성을 안내해 드릴 거에요. 기계 학습 모델의 배포, 모니터링 및 관리를 어떻게 가속화하는지 보여 드릴 거예요.

# Machine Learning Operations (MLOps)란 무엇인가요?

MLOps는 기계 학습 운영(Machine Learning Operations)을 의미하며, 기계 학습 시스템의 개발(Dev) 및 운영(Ops)을 통합하기 위해 제안된 최상의 실천 방법의 모음을 지칭합니다.

MLOps는 DevOps 철학 중 일부 중요한 요소를 통합하여 데이터 과학 및 운영 전문가의 개선된 커뮤니케이션, 협력 및 통합 작업을 도입합니다.



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

그 의미에서 MLOps는 기계 학습 시스템이 직면하는 독특한 도전에 대응하도록 설계되었습니다.

# MLOps의 주요 구성 요소

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

MLOps에는 다양한 구성 요소가 있습니다:



<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 실천, 보안 및 규정 준수에 관한 거버넌스가 필요합니다.

이 통합은 MLOps의 기초가 되며, 팀은 기계 학습 모델을 효율적이고 효과적으로 생성, 배포 및 관리할 수 있습니다.

# MLOps의 주요 이점

기관은 기계 학습 모델의 흐름 내에서 MLOps를 구현함으로써 여러 이점을 얻을 수 있습니다. 일부 주요 이점은 다음과 같습니다:



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

- Time to Market: MLOps는 기계 학습의 라이프사이클을 데이터 준비 단계부터 모델 준비 단계까지의 시간을 단축시켜 모델로 배포하는 데 소요되는 시간을 줄입니다. 이로써 제품 모델을 성공적으로 도입하는 데 걸리는 시간을 단축시킵니다.
- 향상된 모델 품질과 성능: 모델들의 지속적인 워크플로우 - 통합, 배포 및 모니터링 - 은 모델이 항상 최적으로 작동하여 가장 정확한 결과를 제공하도록 합니다.
- 협업: MLOps는 데이터 과학자, 개발자 및 운영 엔지니어간 협업을 개선하여 목표를 공유하고 효과적으로 함께 일할 수 있도록합니다.
- 확장성: MLOps의 모범 사례 및 도구는 기계 학습 운영을 확장할 수 있도록 도와줍니다. 이로써 여러 모델과 대량의 데이터를 효과적으로 처리하는 것이 용이해집니다.
- 재현성 및 추적성: MLOps는 모델과 데이터의 버전 관리를 가능하게 함으로써 재현 가능한 실험과 명확한 이력을 통한 변경 사항의 추적을 보장하여 책임과 투명성을 더합니다.
- 비용 효율성: 반복적인 작업의 자동화 및 자원 최적화를 통해 기계 학습 프로젝트 주변의 작업을 수행하는 데 드라마틱하게 줄어든 비용을 제공합니다.
- 규제 준수 및 보안: MLOps는 감사 모델, 데이터 프라이버시, 보안 조치를 검토할 수 있는 메커니즘을 제공하여 거버넌스 및 규제 준수를 허용합니다.

기계 학습 프로젝트에 포함된 MLOps는 기업들이 AI 시스템의 배포와 유지를 돕는 데 문제를 쉽게 해결할 수 있게 합니다.

# MLOps의 도구 및 기술

MLOps 생태계의 일부인 여러 도구와 기술들이 ML 라이프사이클의 다양한 단계를 지원하기 위해 개발되었습니다. 아래에는 일반적으로 MLOps에서 사용되는 가장 중요한 도구와 기술 중 일부가 소개되어 있습니다:



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

- 데이터 관리 및 버전 관리: DVC(Data Version Control)와 LakeFS와 같은 도구들은 데이터 관리와 버전 관리를 돕고, 이를 통해 머신 러닝 프로젝트를 재현 가능하고 추적 가능하게 합니다.
- 실험 추적: MLflow 플랫폼과 Weights & Biases는 실험 추적 프레임워크를 내장하여 실험을 추적하고 매개변수 및 결과를 기록하며, 데이터 과학자가 실험을 비교하고 관리할 수 있게 합니다.
- 모델 개발 프레임워크: 머신 러닝 모델 개발을 지원하는 인기 있는 라이브러리와 프레임워크에는 TensorFlow, PyTorch 및 Scikit-learn이 포함됩니다.
- 모델 버전 및 레지스트리: MLflow Model Registry와 DVC가 모델의 버전 관리를 처리하여 해당 메타데이터를 포함하고 올바른 모델을 추적하는 것을 쉽게 합니다.
- 워크플로 오케스트레이션 및 자동화: Apache Airflow와 Kubeflow Pipelines는 데이터 전처리부터 모델 학습 및 배포까지 머신 러닝 워크플로를 자동화할 수 있습니다. 이로써 프로세스에서 일관성과 효율성을 약속합니다.
- 모델 배포: TensorFlow Serving, TorchServe 및 Kubernetes를 사용하여 개발된 모델을 실제 세계에서 프로덕션 규모로 배포하는 프로세스로, 이러한 방식으로 실제 업무 부하를 효과적으로 처리할 수 있습니다.
- 모델 모니터링 및 운영: 이 프로세스는 모델의 성능과 운영 상태를 Prometheus, Grafana 및 AI를 사용하여 모니터링하고, 정의된 정상 범위나 임계값을 벗어났을 경우 해당 팀에 경고를 보냅니다.
- 버전 관리 및 협업: Git 및 GitHub 도구는 버전 관리와 협업을 지원합니다. 이를 통해 파일 버전을 제어하고 프로젝트의 소프트웨어 개발자팀과 협업할 수 있습니다.

이러한 도구와 기술들은 MLOps 툴킷의 주요 구성 요소로, 어떤 프로젝트에서도 MLOps를 롤아웃, 채택 및 실천하는 데 도움이 됩니다.

# DevOps vs MLOps

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

비록 데브옵스(DevOps)와 엠엘옵스(MLOps)는 개발과 운영이 어떻게 이루어져야 하는지에 대한 유사한 목표를 향하지만, 머신 러닝 프로젝트가 가져다주는 도전에 따라 차이가 발생합니다. 엠엘옵스와 데브옵스의 차이점은 다음과 같습니다:

- 데이터와 모델에 초점: 데브옵스는 소프트웨어 개발 프로세스를 중점으로 두며 코드의 통합, 테스트, 배포를 강조하지만, 엠엘옵스는 데이터 버전 관리와 모델 훈련을 포함하여 배포에 이르기까지 모델의 라이프사이클을 보완함으로써 머신 러닝의 핵심인 코드 외에 다른 측면을 다룹니다.
- 데이터 출처와 모델 버전 관리: 엠엘옵스에서는 모델 버전 관리가 매우 중요하며 코드 뿐만 아니라 데이터와 모델도 버전 관리됩니다. 이는 모델의 출처를 재현하고 이해하는 능력에 중요하며, 이는 보통 데브옵스에서 다루지 않는 영역입니다.
- 지속적인 훈련과 모니터링: 데브옵스가 지속적인 통합 및 배포를 갖고 있다면, 엠엘옵스는 모델의 지속적인 훈련과 모니터링을 포함합니다. 이는 모델이 새로운 데이터로 지속적으로 재훈련되어야 하며 모델 성능이 시간이 지남에 따라 모니터링되어야 한다는 것을 반영합니다.
- 실험 및 평가: 다양한 모델 아키텍처와 매개변수 설정에 대해 유연한 실험을 가능하게 하며, 실험 추적, 결과 및 모델 평가를 추적하는 도구는 엠엘옵스의 핵심입니다. 그러나 이러한 부분은 전통적인 데브옵스의 중심에 있지 않습니다.
- 다양한 팀 간의 협업: 엠엘옵스는 데이터 과학자, 데이터 엔지니어, 머신 러닝 엔지니어 및 운영팀과 긴밀히 협업해야 합니다. 반면 데브옵스는 개발과 IT 운영 사이의 연결을 강조합니다. 엠엘옵스는 데이터와 모델 관리에 중점을 둔 역할을 통합함으로써 또 다른 층을 더하였습니다.
- 확장성과 거버넌스 도전: 엠엘옵스는 머신 러닝 모델의 확장과 이러한 리소스의 효율적인 거버넌스에 특유의 도전에 직면할 것입니다. 또한 이는 소프트웨어 개발에서 만나는 것보다 비교적 더 복잡한 거버넌스, 윤리 및 규정 이슈에 대처할 수 있어야 합니다.

요약하면, 엠엘옵스는 머신 러닝 프로젝트의 특수 요구 사항을 고려해 데브옵스의 원칙을 적용 및 확장합니다. 모델의 라이프사이클은 개발부터 배포 및 모니터링까지 끝까지 고려하여 데이터 관리, 모델 버전 관리 및 지속적인 개선을 다룹니다.

# 엠엘옵스에서의 Best Practices



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

MLOps를 수용하려면 올바른 장치와 최상의 실천 방법을 준수해야 합니다. 이는 AI 워크플로우의 원활한 작동을 보장합니다. 여기 MLOps에서의 절대적인 Best Practices 목록입니다:

- 머신 러닝 라이프사이클 자동화: 가능한 한 데이터 준비, 모델 개발, 평가 및 구현과 같은 머신 러닝 프로세스를 자동화합니다. 이 접근 방식은 인적 오류를 최소화하고 생산성을 향상시킵니다.
- 모든 것을 버전 관리: 코드, 데이터 세트, 모델 및 실험 로그를 포함한 모든 구성 요소에 대해 버전 관리 메커니즘을 적용합니다. 이러한 방법은 일관성, 책임성 및 필요할 때 이전 반복으로 되돌아갈 수 있는 능력을 보장합니다.
- 모델을 위한 CI/CD(Continuous Integration/Continuous Delivery) 설정: 소프트웨어 엔지니어링에서의 관행을 반영하여 머신 러닝 프로젝트에 지속적인 통합 및 지속적인 배포 방법론을 적용하여 자동화된 테스트와 원활한 모델 배포를 보장합니다.
- 생산 중인 모델 모니터링: 배포된 모델을 지속적으로 관찰하여 성능이나 정확도의 저하를 주시합니다. 비정상적인 활동에 대한 자동화된 알림을 설정하고 필요에 따라 모델 업데이트 및 재배포 프로세스를 간소화합니다.
- 모델 관리와 윤리 실행: 윤리적 고려사항, 규정 준수 및 데이터 프라이버시를 다루는 프레임워크를 개발합니다. 모델이 어떻게 결정을 내리고 데이터를 사용하는지에 대한 투명성을 확보합니다.
- 팀 간 협업 강화: 데이터 과학자, ML 엔지니어 및 운영 직원 간의 협업 환경을 조성하여 정확성뿐만 아니라 확장 가능하고 지속 가능한 모델을 생산합니다.
- 데이터 품질 강조: 훈련 및 추론에 사용되는 데이터가 품질이 높은지 확인합니다. 편향, 누락된 값, 소음과 같은 문제를 해결합니다. 데이터 원천 및 전처리 단계를 정기적으로 감사합니다.
- 지식 문서화 및 공유: 모델, 데이터 원천, 실험 및 결정을 문서화합니다. 팀 내부 및 조직 전체에서 지식을 공유하여 학습 및 지속적인 개선 문화를 구축합니다.

이러한 절차를 따르면 조직은 MLOps의 장점을 극대화하여 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>

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

MLOps은 이론적인 개념뿐만 아니라 다양한 산업 분야에서 현실 세계 문제 해결을 위해 적용될 수 있습니다. 아래는 MLOps가 실무에서 활용되는 몇 가지 예시입니다:

- **의료 분야:** 의료 분야에서는 환자 결과 예측, 진단 지원, 그리고 치료 계획 개인화를 예측하는 모델을 배포하고 관리하는 데 MLOps가 활용됩니다. 지속적인 모니터링은 모델이 새로운 데이터에 적응하여 정확도와 환자 치료를 향상시킵니다.
- **금융 분야:** 은행 및 금융 기관은 신용 위험 모델 관리, 사기 거래 감지, 그리고 개인화된 고객 서비스에 MLOps를 활용합니다. MLOps를 통해 이러한 모델들이 최신 상태를 유지하고 새로운 데이터가 입력될 때 잘 수행되도록 보장합니다.
- **소매 분야:** 소매업체는 재고 최적화, 제품 추천, 그리고 공급망 관리를 위해 MLOps를 활용합니다. MLOps는 변화하는 소비자 행동과 시장 트렌드에 적응하는 모델들을 신속하게 배포하는 것을 돕습니다.
- **제조업:** 제조업에서는 예측 유지보수, 품질 통제, 그리고 공정 최적화를 촉진하는데 MLOps를 활용합니다. 모델은 지속적으로 모니터링되고 업데이트되어 다운타임을 예방하고 효율성을 향상시킵니다.
- **자율 주행차:** MLOps는 자율 주행을 위한 모델 개발과 배포를 지원하며, 차량에서 수집된 새로운 데이터를 통해 업데이트되어 안전성과 성능을 향상시키는 것을 보장합니다.
- **엔터테인먼트:** 스트리밍 서비스는 콘텐츠 추천 개인화, 사용자 경험 향상, 스트리밍 품질 최적화에 MLOps를 적용합니다. 모델의 지속적인 개선이 시청자의 참여를 유지하는 데 중요합니다.

이러한 예시들은 다양한 분야에서 MLOps의 다재다능성과 영향을 보여줍니다. 기계 학습 모델의 효율적인 배포와 관리를 가능케 함으로써 MLOps는 기업이 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>

# 결론

요약하면, MLOps는 기계 학습 개발과 운영을 연결해주는 다리 역할을 하며, 기계 학습 모델의 배포 및 유지보수를 간소화하고 향상시키는 것을 목표로 합니다.

MLOps를 숙달하고 능숙한 데이터 과학자가 되기 위한 여정은 지속적인 학습과 실전 연습으로 마련되어 있습니다.

원본 게시물: https://www.stratascratch.com.



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

# Stackademic 🎓

끝까지 읽어주셔서 감사합니다. 떠나시기 전에:

- 작가를 응원하고 팔로우해주시면 감사하겠습니다! 👏
- 다음 계정도 팔로우해주세요: X | LinkedIn | YouTube | Discord
- 다른 플랫폼도 방문해주세요: In Plain English | CoFeed | Differ
- 더 많은 콘텐츠는 Stackademic.com에서 확인하실 수 있습니다.

MLOps란  머신러닝 운영 쉽게 이해하기

## 파이썬 프로그래밍

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

Pandas는 데이터프레임에서 작업할 때 환상적인 프레임워크를 제공합니다. 데이터 과학에서는 작은 데이터프레임부터 크고 때로는 아주 큰 데이터프레임까지 다룹니다. 작은 데이터프레임을 분석하는 것은 매우 빠를 수 있지만, 큰 데이터프레임에서 심지어 단일 작업도 상당한 시간이 걸릴 수 있습니다.

이 글에서는 종종 데이터프레임에서 작업 순서를 바꿈으로써 이 시간을 단축시킬 수 있다는 것을 보여 드리겠습니다. 이 작업은 사실상 아무 비용도 들지 않는 방법입니다.



<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 pandas as pd

n = 1_000_000
df = pd.DataFrame({
    letter: list(range(n))
    for letter in "abcdefghijklmnopqrstuwxyz"
})
```

100만 행과 25개의 열을 갖고 있어요. 이렇게 큰 데이터프레임에서 다양한 작업을 수행하면 현재 개인 컴퓨터에서 눈에 띌 것입니다.

가령, 다음 조건을 따르는 행만 필터링하여 가져와야 한다고 상상해보죠: `a` 50,000이상 그리고 `b` 3,000이상, 그리고 `a`, `b`, `g`, `n`, `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>

```js
subdf = df[take_cols];
subdf = subdf[subdf["a"] < 50_000];
subdf = subdf[subdf["b"] > 3000];
```

위 코드에서는 먼저 필요한 열을 가져와서 행을 필터링합니다. 동일한 결과를 얻을 수 있으며, 연산의 순서를 바꿔서 먼저 필터링을 수행한 다음 열을 선택할 수도 있습니다:

```js
subdf = df[df["a"] < 50_000];
subdf = subdf[subdf["b"] > 3000];
subdf = subdf[take_cols];
```

더불어 Pandas 연산을 연결하여 동일한 결과를 얻을 수도 있습니다. 해당 명령의 연결은 다음과 같습니다:



<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
# 칼럼을 먼저 선택한 다음 행을 필터링합니다.
df.filter(take_cols).query(query)

# 행을 먼저 필터링한 다음 칼럼을 선택합니다.
df.query(query).filter(take_cols)
```

df가 크기 때문에 네 가지 버전 간 성능이 다를 것으로 예상됩니다. 어느 것이 가장 빠를까요? 가장 느릴까요?

# 벤치마크

이 작업을 벤치마크해보겠습니다. timeit 모듈을 사용할 것입니다:



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

아니면 IPython 쉘에서 이용 가능한 버전입니다.

저희의 벤치마크는 다음과 같습니다:

![벤치마크 이미지](/TIL/assets/img/2024-07-09-OptimizingPandasCodeTheImpactofOperationSequence_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>

# 결과

## Bracketing: 열 선택한 다음 행 필터링하기 (16.5 ms)

```js
subdf = df[take_cols];
subdf = subdf[subdf["a"] < 50_000];
subdf = subdf[subdf["b"] > 3000];
```

이 코드에서는 Tipycal Pandas 코드로 괄호, 불리언 인덱싱 및 대입을 사용했습니다. 예상 결과를 얻기 위해 다음 순서대로 세 줄을 사용했습니다: 먼저 열 하위 집합을 선택하고 그런 다음 두 개의 필터링 조건을 순차적으로 적용했습니다.



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

네 가지 접근법 중에서 이 방법은 비교적 빨랐어요 — 하지만 가장 빠른 방법은 아니었어요. 먼저 열을 선택하면 df 데이터프레임의 너비가 줄어들지만, 데이터프레임이 큰 이유는 주로 너비가 아니라 행의 수 때문이에요. 이렇게요¹:

```js
In [7]: n_of_elements = lambda d: d.shape[0]*d.shape[1]

In [8]: n_of_elements(df)
Out[8]: 25000000

In [9]: n_of_elements(df.filter(take_cols))
Out[9]: 5000000

In  [10]: n_of_elements(df.query(query))
Out [10]: 1174975
```

보시다시피 열을 먼저 제거할 때 (df.filter(take_cols)), 500만 개 요소를 갖는 데이터프레임을 얻을 수 있고, 행을 먼저 필터링할 때 (df.query(query))는 100만 개가 넘는 요소를 가진 데이터프레임을 얻게 돼요. 이는 네 배 이상 작은 크기에요.

불필요한 열을 먼저 제거하면 불필요한 행을 먼저 제거하는 것보다 작업이 느려질 것이 당연해요 — 다음 섹션에서 보여줄게요.



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

## 괄호 사용: 행 필터링 후 열 선택 (10.7 ms)

```js
subdf = df[df["a"] < 50_000];
subdf = subdf[subdf["b"] > 3000];
subdf = subdf[take_cols];
```

이 코드는 브래킷, 부울 인덱싱, 및 할당을 기반으로 한 전형적인 판다스 코드를 사용하지만, 이번에는 데이터프레임의 크기를 줄이기 위해 먼저 행이 필터링됩니다. 그런 다음 선택된 열이 가져와집니다.

이는 시험한 네 가지 방법 중에서 명백히 가장 빠른 방법입니다. 효율성 향상은 데이터프레임 크기의 초기 감소로 인해 얻어지며, 결과적으로 후속 단계에서 처리해야 하는 더 작은 데이터셋을 제공합니다.



<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 코드를 사용했습니다. 이는 직접 부울 인덱싱을 사용했다는 것을 의미합니다. 이론적으로 가장 성능이 우수한 Pandas 코드를 제공하는 것은 벡터화된 연산이며, 그것을 볼 수 있습니다. 두 가지 버전 간의 차이는 우리가 방금 분석한 내용에서 나타납니다: 데이터프레임 크기를 가장 줄일 것으로 생각되는 이 작업을 먼저 사용해야 합니다.

## Pipes: 열 선택 후 행 필터링 (26.0 ms)

```python
df.filter(take_cols).query(query)
```

이 코드는 연결된 Pandas 연산을 사용합니다. 먼저 행을 필터링한 다음 필요한 열을 가져옵니다.



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

판다스 데이터프레임의 .query() 메서드는 전통적인 판다스/넘파이 의미의 벡터화된 연산을 사용하지 않습니다. 대신, numexpr Python 패키지를 사용합니다. 이론적으로는 문서에 설명된 대로,

우리가 실험한 결과로는 불리언 인덱싱을 기반으로 한 벡터화된 연산보다 속도가 느린 것을 확인했습니다.

우리의 벤치마크로 돌아와서, 이 코드는 관찰된 코드 중에서 분명히 가장 느립니다. 이에는 두 가지 이유가 있습니다: 판다스 연산을 연쇄적으로 하는 것이 벡터화하는 것보다 느리며, 우리가 방금 논의한 대로, 먼저 열의 수를 줄이는 것이 먼저 행을 필터링하는 것보다 이 데이터셋에 효율적이지 않습니다. .filter() 메서드는 데이터프레임의 크기를 줄이지만, 이 감소는 .query()를 사용하여 행 수를 줄인 후에 얻은 감소보다 4배 이상 작습니다.

## Pipes: 행을 필터링한 다음 열을 선택합니다 (17.3 ms)



<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
df.query(query).filter(take_cols);
```

이 코드는 이전 것의 개선된 버전으로 간주할 수 있습니다. 이미 필요 없는 행을 먼저 없애야 하고, 그 후에 필요한 열을 선택해야 한다는 것을 알고 있습니다. 이 코드는 Pandas 연산을 연쇄적으로 수행하여 이 작업을 수행합니다.

이 방법은 이전 방법(열을 선택한 후 .query()가 적용되는 파이프)보다 효율적이지만, 여전히 해당 벡터화된 코드와 성능이 맞지는 않습니다. 덜 효과적인 순서에서 벡터화된 코드와 거의 유사한 성능을 보입니다.

# 해석



<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 작업을 연쇄하는 것은 벡터화하는 것보다 효율적이지 않음을 관찰했습니다. 파이프의 실행 시간 (17.3 ms 및 26 ms)은 이 현상을 보여줍니다. 해당 시간은 해당 벡터화된 작업(각각 10.7 ms 및 16.5 ms)보다 더 느립니다.

그러나 이해해야 할 점은 이해가 일반적이 아니라는 것입니다. 이는 우리의 벤치마크 및 분석한 특정 시나리오를 참조합니다.

여러분에게 연습 문제를 남기겠습니다: `50_000 또는 b` 3000 중 어떤 행 필터링을 먼저 적용하느냐에 따라 어떤 영향이 있을까요?



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

이거 봤어요? 718 µs 대 121 ms로 첫 번째 접근 방식(먼저 열을 선택)이 훨씬 빠릅니다. 거의 170 배나 빠르죠! 그 이유는 이전과 같아요 — 첫 번째 작업 후 데이터프레임의 크기 때문이에요. 이번에는 차이가 엄청나죠:

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

두 번째 작업도 매우 다른 크기의 데이터프레임에서 작동합니다:

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

Pandas 연쇄 작업은 이러한 데이터프레임에 대해 매우 비효율적으로 작동하는 흥미로운 점입니다:

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

열을 먼저 처리했음에도 불구하고 이 파이프는 위의 느린 작업보다 시간을 세 배나 적게 소요했음을 유념하세요. 순서를 바꾼 상태의 대응하는 파이프를 벤치마킹 해보려고 했지만, 3시간 후에 벤치마킹을 종료했습니다:

![Image](/TIL/assets/img/2024-07-09-OptimizingPandasCodeTheImpactofOperationSequence_6.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>

테이블 태그를 마크다운 형식으로 변경해 보겠습니다.

# 결론

저희 실험은 판다스에서 데이터 조작의 중요한 원칙을 보여줍니다: 가능한 한 빨리 데이터셋 크기를 줄이는 것이 성능을 크게 향상시킬 수 있습니다, 특히 벡터화된 행 필터링 작업을 통해.

이 권장 사항은 놀랍지 않을 수 있지만 상당히 분명해 보입니다. 과거에 가끔 이를 따르지 못한 적이 있었는데, 앞으로는 판다스 작업의 순서에 대해 생각해야겠다고 확실히 기억하겠습니다.



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

작은 데이터프레임을 대화식 세션에서 분석할 때는 성능 차이를 무시하고 선호하는 코드를 사용해도 됩니다. 그러나 실제 운영 코드에서는 작은 데이터프레임이나 대규모 데이터프레임을 분석할 때 작업 순서가 상당한 차이를 만들 수 있습니다.

첫 번째 예시에서 행 필터링을 열 선택보다 먼저 적용하는 것이 더 효율적인 전략으로 나타났습니다. 그러나 이는 일반적으로 나타나는 현상은 아니며 데이터프레임에 따라 다릅니다.

우리는 데이터프레임의 요소 수를 주요 기준으로 사용했지만, 데이터프레임이 길거나 넓은지도 중요한 점입니다. 요소 수가 동일한 두 데이터프레임을 분석했을 때 성능에 큰 차이를 확인했습니다.

따라서 성능이 중요하다면 각각의 데이터프레임을 개별적으로 분석하고 모양과 크기를 고려하여 작업 순서를 신중히 선택해야 합니다. 이 통찰력은 특히 대용량 데이터셋을 다룰 때 판다스 워크플로를 최적화하는 데 매우 소중합니다.



<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 작업을 구현하는 데 다음과 같은 주요 통찰을 제공합니다:

- Pandas 작업에 벡터화를 적용하면 Pandas 작업을 연쇄하는 것보다 성능이 더 우수한 코드를 얻을 수 있습니다.
- 일반적으로 여러 Pandas 작업을 포함하는 성능이 우수한 코드를 구현하려면 데이터프레임의 모양과 크기에 따라 후속 단계에서 데이터프레임의 크기를 가장 크게 줄일 작업부터 시작하고, 이를 가장 적게 줄이는 작업으로 끝냅니다.
- 성능이 중요한 경우, 데이터프레임의 모양과 크기를 고려하여 각 코드 조각을 개별적으로 최적화합니다.

# 각주

¹ 이 코드에서는 다음 람다 정의를 사용하여 명명된 함수를 정의했습니다:



<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
In [7]: n_of_elements = lambda d: d.shape[0]*d.shape[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>

재밌게도, 이 정확한 코드를 배포했어요. 하지만 반항적으로 하는 게 아니라 어떤 점을 강조하기 위해서였죠.

Pandas 코드 최적화 연산 순서가 미치는 영향

일상적인 프로덕션 프로젝트에서 사용하는 파이썬 도구들  Part I

인과 검증과 인과 추론에서 V-구조의 중요성과 그 역할 이해하기

## 거래 결정 도구

![Trading Index](/TIL/assets/img/2024-07-09-BuildyourowntradingindexwithPython_0.png)

맞춤 지수는 자산 구성 및 가중치에 대한 유연성과 제어를 제공하여 전통적인 지수와 비교했을 때 투자 전략을 더 잘 반영할 수 있는 고유한 기준을 제공합니다. 이 기사에서는 Python을 사용하여 맞춤 지수를 작성하는 방법을 안내하겠습니다.

## 왜 맞춤 지수를 사용해야 하나요?



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

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

- 유연성: 특정 투자 또는 거래 전략에 맞게 지수를 맞춤 설정할 수 있습니다.
- 통제: 자산 포함 및 가중 기준을 사용자 정의할 수 있습니다.
- 혁신: 투자 및 거래 모두에서 경쟁 우위를 제공할 수 있는 독특한 지수 개발

## 미국 달러 지수를 계산하는 이유

역사적 가격을 찾을 수 있는 모든 것에 대해 사용자 정의 지수를 만들 수 있지만, 이 글은 이미 존재하는 지수인 미국 달러 지수를 만들 것입니다.

제가 미국 달러(USD)를 선택한 이유는 우리가 사용자 정의 결과를 실제 지수와 비교하여 테스트할 수 있기 때문입니다.



<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로 가장 중요한 건 통화를 선택했습니다. 외환 거래에서 외환 페어를 거래할 때 한 통화가 다른 통화와 비교됨을 볼 수 있습니다. 실제로 페어가 길어지면, 예를 들어 EURUSD가 있습니다. EUR이 강해지고 있는지, USD가 약해지고 있는지 확신할 수 없습니다. 이것은 통화 지수로만 제공될 수 있는 답변입니다.

## 사용자 정의 인덱스 생성 단계별 안내서

통화 데이터 처리 및 금융 데이터 가져오기를 위해 pandas, numpy 및 yfinance와 같은 필수 라이브러리를 가져와 시작합니다.

```js
import pandas as pd
import json
import yfinance as yf
import mplfinance as mpf
```



<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
with open('currencies_weights.json') as f:
    currencies = json.load(f)

with open('currencies_pairs.json') as f:
    pairs = json.load(f)
```

통화는 심볼(예: EUR)과 해당 국가의 GDP(십억 달러)를 가장 중요하게 가지고 있어야 합니다. GDP를 선택한 이유는 가장 현실적인 측정값으로 보였습니다(결국 옳은 것으로 판명되었죠…). 그냥 하나의 통화로 표시되어야 한다는 점만 주의하면 됩니다. 예를 들어, 유로존 GDP는 USD로 표시되어야 하며 EUR이 아니어야 합니다. 이것이 가장 쉬운 방법인 것을 발견했는데, 로컬 통화로 GDP를 가지고 있고 이후 변환해야 하는 방법보다 편리합니다.

아래 for 루프를 사용하면 모든 쌍에 대한 1시간 가격을 다운로드하고, 우리 사랑하는 `yfinance`의 도움으로 이를 딕셔너리에 추가할 수 있습니다.



<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
for pair in pairs:
    pairs[pair]['df'] = yf.download(pairs[pair]['name'] + '=X', start='2023-01-01', end='2023-12-31', interval='1h')
```

가능한 가장 작은 시간 단위를 선택하여 데이터를 찾아야 큰 시간 단위(예: 4시간 또는 일일)의 캔들을 만들 수 있습니다. 그런 다음 야후 금융이 가끔 일부 날짜를 제공하지 않을 경우에도 데이터 프레임을 동기화합니다. API가 완전하고 적절한 데이터를 제공할 것이라고 확신하는 경우, 이 부분은 건너 뛰시기 바랍니다.

```js
# 최소 및 최대 날짜 찾기
for pair in pairs:
    mindate = min(pairs[pair]['df'].index)
    maxdate = max(pairs[pair]['df'].index)
# 공통되지 않은 날짜 제외
for pair in pairs:
    pairs[pair]['df'] = pairs[pair]['df'].loc[mindate:maxdate]
print(mindate, maxdate)
```

이제 계산할 통화의 지수와 이 통화를 포함하는 모든 통화에 대한 종가를 갖는 데이터 프레임을 생성하고 설정해야 합니다. 통화가 판매 쪽에 있다면 환율을 뒤집어서 모두 매수쪽으로 가져와야 합니다.



<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
통화 = 'USD'

mydict = {}
# 해당 통화를 포함하는 쌍 필터링
for pair in pairs:
    if 통화 in pairs[pair]['buycur']:
        print("매수", pair)
        mydict[pairs[pair]['sellcur']] = pairs[pair]['df']['Close']
    elif 통화 in pairs[pair]['sellcur']:
        print("매도", pair)
        mydict[pairs[pair]['buycur']] = 1 / pairs[pair]['df']['Close']

df_currency = pd.DataFrame(mydict)
```

위 데이터프레임의 각 열(통화)에 대해 GDP를 사용하여 가중치 목록을 생성합니다.

```js
weights = []
for col in df_currency.columns:
    weights.append(currencies[col]['GDP'])

weights = [weight / sum(weights) for weight in weights]
```

이제 가중 폐장 가격을 생성하고 선택한 데이터프레임으로 재샘플링하는 마법이 일어납니다(원본보다 더 높아야 함).



<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
# 데이터프레임 준비
df_index = df_currency.copy()
df_index = df_index.pct_change(fill_method=None)
df_index.dropna(inplace=True)

# 가중 평균 종가 계산
weights_df = pd.DataFrame(weights, index=df_index.columns, columns=['Weight'])
df_index[currency] = df_index.dot(weights_df['Weight']).cumsum(axis=0)*1000
df_index[currency] = df_index[currency].round(6)

# 인덱스를 일별로 다시 샘플링
df_index = df_index[currency].dropna()
ohlc = df_index.resample('D').ohlc()
ohlc.dropna(inplace=True)
```

여기까지입니다. ohlc 데이터프레임에는 일별 미국 달러 지수의 캔들 정보가 포함되어 있습니다.

과정을 확인하려면 실제 미국 달러 지수를 다운로드하여 비교해보겠습니다.

```js
usd_dollar_index = yf.download("DX-Y.NYB", (start = "2023-01-01"), (end = "2023-12-31"), (interval = "1d"));
```



<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
mpf.plot(ohlc, (type = "candle"), (figratio = (30, 10)));
mpf.plot(usd_dollar_index, (type = "candle"), (figratio = (30, 10)));
```

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

다른 방법은 종가의 상관 관계를 점검하는 것이에요.



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

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

```python
# 먼저 상관 계수를 계산하기 전에 두 날짜 및 시간 인덱스를 시간대 정보 없이 만들어야 합니다
ohlc.index = ohlc.index.tz_localize(None)
usd_dollar_index.index = usd_dollar_index.index.tz_localize(None)

combined_df = pd.DataFrame({
    'ohlc': ohlc['close'],
    'usd_dollar_index': usd_dollar_index['Close']
})

correlation = combined_df.corr().iloc[0, 1]
```

이를 통해 우리는 놀라운 0.976의 상관 관계를 얻게 됩니다. 이를 통해 두 인덱스가 일치함을 알 수 있습니다...

하지만 미국 달러 지수는 6개 통화에 대한 고정 가중치로 계산되는 반면, 우리의 경우에는 14가 있었으므로 약간의 차이가 있습니다!

여기에서 Git Hub에서 코드와 통화 쌍에 대한 json 파일을 찾을 수 있습니다. 클릭하세요.



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

## 다음 단계

- 실험: 다양한 가중 체계와 자산 선택을 시도해보세요.
- 향상: 보다 정교한 백테스팅 지표 추가.
- 최적화: 기계 학습 모델 통합하여 사용자 정의 지수를 최적화하세요.

나의 데이터 주도 투자 여정을 함께 해보세요! 저를 Medium, Twitter (현재 X로 잘 알려진) 및 Github에서 팔로우해주세요. 저는 코딩, 글쓰기, 데이터 이해를 통한 성장을 추구합니다 ;)

면책 조항: 이 글에서 투자의 흥미로운 세계를 탐험하는 동안 교육 목적으로 제공되는 정보임을 꼭 상기해주세요. 저는 금융 자문가가 아니며 여기에 게시된 내용은 금융 조언으로 간주되지 않습니다. 언제나 연구를 하시고 투자 결정을 내리기 전에 전문가와 상의하는 것을 고려해주십시오.



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

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

# 쉽고 간결한 영어 커뮤니티에 참여해 주셔서 감사합니다! 떠나시기 전에:

- 반드시 저자를 clapping 하고 팔로우 해주세요 ️👏️️
- 팔로우하기: X | LinkedIn | YouTube | Discord | 뉴스레터
- 다른 플랫폼 방문하기: CoFeed | Differ
- PlainEnglish.io에서 더 많은 콘텐츠 확인하기

Python으로 나만의 트레이딩 인덱스 만드는 방법

파이썬에서 함수 인터페이스 사용하는 방법

Scikit-learn 2024 시각화 가이드 모델을 이해하기 쉽게 만드는 방법

아래는 작성한 표의 내용이에요.

| 제목                             | 링크                                                                                           |
| -------------------------------- | ---------------------------------------------------------------------------------------------- |
| Authentication and authorization | [여기](/TIL/assets/img/2024-07-09-HowtohandleauthenticationandauthorizationinGraphQLAPI_0.png) |

인증(Authentication)과 권한 부여(authorization)는 종종 혼동되지만, 이러한 개념들은 서로 다른 프로세스를 담당하고 있어요. '인증'은 사용자 식별을 결정하며(사용자가 시스템에 로그인되어 있는지 여부), '권한 부여'는 인증된 사용자가 특정 리소스에 액세스할 수 있는지 여부를 나타냅니다. 그래서 보통 인증 단계가 권한 부여 단계를 선행해요. GraphQL에서 인증과 권한 부여는 도전적일 수 있는데 이는 하나의 노출된 HTTP 엔드포인트 (예: /graphql)만 있기 때문이에요. 이 엔드포인트 진입점에서 사용자를 인증할 수는 있지만, 그 구현에서 일부 리소스에 대한 공개 접근 옵션을 포기해야 할 수 있어요. 이 유일한 엔드포인트 진입에서 권한을 부여하는 것은 불가능해요. 왜냐하면 어떤 리소스가 쿼리될 지 모르기 때문이에요.

이 게시물의 영감은 해당 주제에 대한 답변을 찾는 스택오버플로우 질문에서 얻은 거예요. # 애플리케이션 설정



<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에서 GraphQL와 REST의 예제 구현을 비교한 내용에 대한 후속 게시물입니다. 따라서 애플리케이션을 설정하는 데 필요한 요구 사항을 찾을 수 있습니다.

# 회원 가입 / 로그인

우선 이메일 및 해싱된 패스워드 속성을 가진 간단한 사용자 모델(User)부터 시작합니다.

```js
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import relationship
from db import Base

class User(Base):
    __tablename__ = "user"

    id = Column(Integer, primary_key=True, autoincrement=True)
    email = Column(String, unique=True)
    password = Column(String)
    table_bookings = relationship("TableBooking")
```



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

사용자 등록은 이메일과 비밀번호 매개변수를 받아들이고 데이터베이스에 사용자 레코드를 생성하는 SignUp 뮤테이션을 통해 제공됩니다.

```js
# api/graphql.py
import graphene
from service import sign_up

class SignUp(graphene.Mutation):
    class Arguments:
        email = graphene.String(required=True)
        password = graphene.String(required=True)

   user = graphene.Field(UserNode)

   def mutate(self, info, email: str, password: str):
        session = info.context["session"]
        user = sign_up(session, email, password)
        return SignUp(user=user)

class Mutation(graphene.ObjectType):
    sign_up = SignUp.Field()

# service.py
from auth import generate_password_hash

class UserAlreadyExist(Exception):
    pass

def sign_up(session: Session, email: str, password) -> User:
    if session.query(User).filter_by(email=email).first():
        raise UserAlreadyExist()
    user = User(email=email, password=generate_password_hash(password))
    session.add(user)
    session.commit()
    return user

# auth.py
import hashlib

SALT = "STRONg@Salt"

def generate_password_hash(password: str) -> str:
    h = hashlib.md5(f"{password}{SALT}".encode())
    return h.hexdigest()
```

뮤테이션은 /graphql 엔드포인트에서 POST 요청을 통해 실행됩니다. GraphQL에 대한 이전 게시물과 같이 insomnia를 사용하여 HTTP 요청을 수행합니다.

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

사용자 인스턴스가 생성되면 올바른 자격 증명이 전달되면 사용자 인증 JWT 토큰을 생성하는 SignIn 뮤테이션이 필요합니다.

```js
# api/graphql.py
import graphene
from service import sign_in

class SignIn(graphene.Mutation):
    class Arguments:
        email = graphene.String(required=True)
        password = graphene.String(required=True)

   token = graphene.String()

   def mutate(self, info, email: str, password: str):
        session = info.context["session"]
        token = sign_in(session, email, password)
        return SignIn(token=token)

   class Mutation(graphene.ObjectType):
        sign_in = SignIn.Field()

# service.py
from sqlalchemy.orm import Session
from auth import generate_token, verify_password
from models import User

class UserAuthenticationError(Exception):
    pass

def sign_in(session: Session, email: str, password) -> str:
    user = session.query(User).filter_by(email=email).first()
    if not user:
        raise UserAuthenticationError()
    if not verify_password(user, password):
        raise UserAuthenticationError()
    return generate_token(user)

# auth.py
import hashlib
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from models import User

SALT = "STRONg@Salt"
SECRET_KEY = "!SECRET!"
TOKEN_EXPIRES_IN = 3600 * 24 * 30

def generate_password_hash(password: str) -> str:
    h = hashlib.md5(f"{password}{SALT}".encode())
    return h.hexdigest()

def verify_password(user: User, password: str) -> bool:
    return user.password == generate_password_hash(password)

def generate_token(user: User) -> str:
    serializer = Serializer(SECRET_KEY, expires_in=TOKEN_EXPIRES_IN)
    return serializer.dumps({"user_id": user.id}).decode("utf-8")
```

SignIn 뮤테이션을 위해 이메일과 비밀번호를 전달하고 인증이 필요한 요청에서 사용할 수 있는 토큰을 페이로드로 받습니다.

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

# 인증

SignIn 단계에서 생성된 토큰이 있으므로 "Bearer Authentication" 프로세스에서 사용할 수 있습니다. 이러한 유형의 인증에서는 유효한 토큰(베어러)을 가진 모든 사용자가 해당 토큰에 해당하는 사용자로 인식될 수 있습니다. 각 GraphQL 필드 리졸버에 사용할 수 있는 sign_in_required 데코레이터를 정의합니다. 이 데코레이터는 "Authorization" 요청 헤더에서 토큰을 가져와 해독하여 user_id를 얻은 다음, user_id에 해당하는 User가 있는지 확인합니다. 성공적으로 완료되면 인증된 User가 됩니다.

```js
# api/graphql.py

import graphene
from api.auth import sign_in_required

class Query(graphene.ObjectType):
    up = graphene.Boolean()
    restaurants = graphene.relay.ConnectionField(
        RestaurantConnection, q=graphene.String()
    )
    me = graphene.Field(UserNode)

    def resolve_up(root, info, **kwargs):
        return True

    @sign_in_required()
    def resolve_restaurants(root, info, **kwargs):
        query = get_restaurants(
            info.context["session"], search=kwargs.get("q"), limit=kwargs.get("first")
        )
        return [RestaurantNode(id=r.id, name=r.name) for r in query]

    @sign_in_required()
    def resolve_me(root, info, **kwargs):
        return kwargs["current_user"]

# api/auth.py
from functools import wraps
from auth import get_user_by_token
from models import User

class UnauthenticatedUser(Exception):
    pass

def sign_in_required():
    def decorator(func):
        @wraps(func)
        def wrapper(root, info, *args, **kwargs):
            kwargs["current_user"] = get_current_user(info.context)
            return func(root, info, *args, **kwargs)
        return wrapper
    return decorator

def get_current_user(context) -> User:
    try:
        token = get_token_from_request(context["request"])
        user = get_user_by_token(context["session"], token)
        if not user:
            raise UnauthenticatedUser("UnauthenticatedUser")
        return user
    except KeyError:
        raise UnauthenticatedUser("UnauthenticatedUser")

def get_token_from_request(request) -> str:
    header = request.headers["Authorization"]
    token = header.replace("Bearer ", "", 1)
    return token

# auth.py
import hashlib
from typing import Optional
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from sqlalchemy.orm import Session
from models import User

SECRET_KEY = "!SECRET!"
TOKEN_EXPIRES_IN = 3600 * 24 * 30

def get_user_by_token(session: Session, token: str) -> Optional[User]:
    serializer = Serializer(SECRET_KEY, expires_in=TOKEN_EXPIRES_IN)
    data = serializer.loads(token)
    return session.query(User).get(data["user_id"])
```

up 필드는 공개 액세스이므로 쿼리를 위해 자격 증명을 전달할 필요가 없습니다. 한편, me 필드는 sign_in_required로 데코레이트되었으므로 적절한 토큰을 전달해야 해결할 수 있습니다.



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

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

"Authorization" 헤더에 토큰을 전달하지 않고 sign_in_required로 표시된 필드에 접근하면 UnauthenticatedUser 예외가 발생합니다.

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



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

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

# 인가

쿼리를 인증하여 로그인한 사용자만 액세스할 수 있도록 제한하는 방법을 살펴보았습니다. 그러나 사용자가 로그인했지만 수행하는 작업이 허용되지 않는 경우는 어떻게 할까요? 예를 들어, 예약한 레스토랑 테이블이 있으며 사용자가 인증되었을 때 허용되어야 하는 경우와 테이블 예약을 취소해야 하는 경우와 같이 사용자가 이전에 생성한 예약만 취소할 수 있는 경우가 있습니다.

우리는 두 가지 작업을 구현했습니다:

- 사용자가 인증되었을 때 허용되어야 하는 BookRestaurantTable 뮤테이션,
- 취소되어야 하는 TableBooking을 취소하는 CancelTableBooking 뮤테이션.

이를 위해 BookRestaurantTable은 sign_in_required로 데코레이트된 mutate 메서드를 사용하고, CancelTableBooking은 authorize_required로 데코레이트된 새로운 메서드를 사용합니다. 이 데코레이터는 사용자가 인증되었는지 확인하고, table_booking_gid(인스턴스의 전역 ID를 나타내는 값)가 인증된 사용자에 의해 생성된 TableBooking 인스턴스와 일치하는지 확인합니다.



<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 BookRestaurantTable(graphene.Mutation):
    class Arguments:
        restaurant_gid = graphene.ID(required=True)
        persons = graphene.Int(required=True)

    table_booking = graphene.Field(TableBookingNode)

    @sign_in_required()
    def mutate(self, info, restaurant_gid: str, persons: int, **kwargs):
        session = info.context["session"]
        current_user = kwargs["current_user"]
        _, restaurant_id = from_global_id(restaurant_gid)
        table_booking = book_restaurant_table(
            session, restaurant_id, current_user.email, persons
        )
        return BookRestaurantTable(
            table_booking=TableBookingNode(
                id=table_booking.id,
                is_active=table_booking.is_active,
            )
        )

class CancelTableBooking(graphene.Mutation):
    class Arguments:
        table_booking_gid = graphene.ID(required=True)

    table_booking = graphene.Field(TableBookingNode)

    @authorize_required(TableBooking)
    def mutate(self, info, table_booking_gid: str, **kwargs):
        session = info.context["session"]
        table_booking = kwargs["instance"]
        cancel_table_booking(session, table_booking)
        return CancelTableBooking(
            table_booking=TableBookingNode(
                id=table_booking.id,
                is_active=table_booking.is_active,
            )
        )

class Mutation(graphene.ObjectType):
    book_restaurant_table = BookRestaurantTable.Field()
    cancel_table_booking = CancelTableBooking.Field()

# api/auth.py
import re
from functools import wraps
from graphene.relay.node import from_global_id
from auth import authorize
from models import User

def camel_to_snake(name: str) -> str:
    """CamelCase -> camel_case"""
    return re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()

class UnauthorizedAccess(Exception):
    pass

class InstanceNotExist(Exception):
    pass

def authorize_required(model):
    """
    We assume that the global id field name of a resource
    follow convention like:
    model_name: `TableBooking`
    global id field name: `table_booking_gid`
    """
    def decorator(func):
        @wraps(func)
        def wrapper(root, info, *args, **kwargs):
            kwargs["current_user"] = get_current_user(info.context)
            model_name = model.__name__
            gid_field_name = f"{camel_to_snake(model_name)}_gid"
            instance_gid = kwargs[gid_field_name]
            instance_model_name, instance_id = from_global_id(instance_gid)
            if instance_model_name != f"{model_name}Node":
                raise UnauthorizedAccess("UnauthorizedAccess")
            instance = info.context["session"].query(model).get(instance_id)
            if not instance:
                InstanceNotExist()
            kwargs["instance"] = instance
            if not authorize(instance, kwargs["current_user"]):
                raise UnauthorizedAccess("UnauthorizedAccess")
            return func(root, info, *args, **kwargs)
        return wrapper
    return decorator

# auth.py
from functools import singledispatch
from models import TableBooking, User

@singledispatch
def authorize(instance, current_user: User) -> bool:
    raise NotImplementedError

@authorize.register(TableBooking)
def _authorize(instance: TableBooking, current_user: User) -> bool:
    return instance.user_id == current_user.id
```

BookRestaurantTable을 실행하기 위해 restaurant_gid 및 persons라는 두 가지 필수 인수를 전달해야 합니다. "Authorization" 헤더에 토큰을 추가해야 합니다. Mutation 응답에서는 TableBooking.id를 얻습니다.

이미지가 포함된 파일경로: `/assets/img/2024-07-09-HowtohandleauthenticationandauthorizationinGraphQLAPI_6.png`

CancelTableBooking은 BookRestaurantTable 페이로드(TableBooking.id)에서 가져올 수 있는 table_booking_gid만 필요합니다.



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

만약 토큰이 주어진 테이블 예약의 소유자와 일치하지 않는 경우, 동작을 수행할 수 없으며, 권한이 없음 예외가 발생합니다.

<img src="/TIL/assets/img/2024-07-09-HowtohandleauthenticationandauthorizationinGraphQLAPI_8.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 GraphQL 프로젝트에도 쉽게 통합할 수 있어요. 전체 소스 코드는 여기에서 확인할 수 있어요: https://github.com/jorzel/service-layer/tree/auth.

GraphQL API에서 인증 및 권한 관리하는 방법

## 파이썬 인터뷰 질문

전 세계에는 800만 명 이상의 파이썬 개발자가 있습니다. 매일 수천 명의 새로운 학습자가 파이썬 커뮤니티에 가입합니다. 혹독한 진실은, 그 중에서도 단 10~20%만이 좋은 개발자가 되어 좋은 직장을 찾을 수 있습니다. 이유는 고급 인터뷰 질문을 해결하지 못하기 때문입니다. 이제 10가지 중요하고 흔한 파이썬 인터뷰 질문을 공유하겠습니다.

# `.py` 파일과 `.pyc` 파일의 차이는 무엇인가요?

`.py` 파일은 프로그램의 소스 코드입니다. `.pyc` 파일은 컴파일된 바이트 코드입니다.


<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` 파일을 컴파일하여 `.pyc` 파일로 저장하고, 이 파일은 파이썬 가상 머신에서 실행됩니다.

주 소스 코드를 실행하기 전에 파이썬은 컴파일된 버전인 `.pyc` 파일을 찾습니다. 찾았다면 해당 파일을 가상 머신으로 실행합니다. 찾지 못했다면 `.py` 파일을 컴파일하고 실행합니다. 요컨대, `.pyc` 파일은 이미 컴파일된 코드를 재사용하여 컴파일 시간을 단축해줍니다.

# 추상화란 무엇인가요? 파이썬에서는 어떻게 추상화를 구현할 수 있나요?

추상화는 내부 함수를 사용자로부터 숨기는 것을 말합니다. 사용자는 결과가 어떻게 생성되었는지 알지 못한 채 함수와 상호 작용합니다.


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

간단히 말하면, 추상화는 프로그램 복잡성을 줄이기 위해 관련 없는 데이터를 숨기는 것을 의미합니다. 파이썬에서는 추상화를 달성하기 위해 ABC 모듈을 사용합니다.

추상 클래스는 다른 클래스의 기반으로 사용할 수 있습니다. 추상 클래스의 객체는 생성할 수 없으므로 요소에 액세스하는 유일한 방법은 상속을 통해서입니다.

```python
from abc import ABC, abstractmethod
```

```python
class Parent(ABC):
    @abstractmethod
    def show(self):
        pass
  
class child(Parent):
    def show(self):
        print("Child Class")
obj = child() # 추상 클래스는 인스턴스화 할 수 없습니다
obj.show() # Child Class
```


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

# FrozenSet이란 무엇인가요? 예시와 함께 중요성을 설명해주세요.

FrozenSets는 set과 비슷하지만 변경할 수 없습니다.

`set` 요소를 언제든지 수정할 수 있지만, 생성된 후에는 `frozenset`을 변경할 수 없습니다.

생성 후에는 요소를 추가, 삭제 또는 업데이트할 수 없습니다. `frozenset`은 반복 가능한 항목을 입력으로 받아들이고 변경할 수 없게 만듭니다. 변경할 수 없기 때문에 딕셔너리의 키로 사용할 수 있습니다.


<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 = {"Name": "Roger", "Pin": 3056, "ActNo":9892345112234565}
fSet = frozenset(data)
print(fSet) # frozenset({'Name', 'Pin', 'ActNo'})
```

**얕은 복사와 깊은 복사의 차이를 설명해보겠습니다.**

`얕은 복사`는 객체에 대한 참조를 새로운 메모리 위치에 저장합니다. 새로운 위치에서의 변경 사항은 이전 위치에 반영됩니다. 깊은 복사보다 더 빠릅니다.

`깊은 복사`는 객체의 값을 새로운 위치에 저장합니다. 새 위치에서의 변경 사항이 이전 위치에 영향을 미치지 않습니다.


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

`id` 는 객체의 메모리 주소를 보는 데 사용됩니다. 예시에서의 주소는 여러분의 컴퓨터에서 다를 수 있습니다.

```js
## 얕은 복사
data = [1, 2, 3, 4, 5]
updated_data = data
updated_data.append(6)
print(updated_data) # [1, 2, 3, 4, 5, 6]
print(data) # [1, 2, 3, 4, 5, 6]
print(id(data)) # 16777216
print(id(updated_data)) # 16777216
```

```js
## 깊은 복사
import copy
data = [1, 2, 3, 4, 5]
updated_data = copy.deepcopy(data)
updated_data.append(6)
print(updated_data) # [1, 2, 3, 4, 5, 6]
print(data) # [1, 2, 3, 4, 5]
print(id(updated_data)) # 16777216
print(id(data)) # 14020317
```

# pickle을 사용하는 방법은요?


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

`피클링(Pickling)`은 Python 객체를 바이트 스트림으로 변환하여 직렬화하는 것을 말합니다.

`언피클링(Unpickling)`은 그 반대로, 바이트 스트림을 다시 Python 객체로 변환하여 역직렬화하는 것을 의미합니다.

Python에서는 직렬화와 역직렬화를 위해 `pickle.dump`와 `pickle.load`를 사용합니다.

```python
## Pickling
import pickle
data =  {
    'Names': ["Karl","Robin","Lary"],
    'Id': ('G770531','G770532','G770533'),
    'Salary':[55600,88900,76000]
    }
output = open('./data.pkl', 'wb')
pickle.dump(data, output)
output.close()
```


<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 pickle
stream = open('./data.pkl', 'rb')
data = pickle.load(stream)
print(data) # {'Names': ['Karl', 'Robin', 'Lary'], 'Id': ('G770531', 'G770532', 'G770533'), 'Salary': [55600, 88900, 76000]}
stream.close()
```

# *args와 **kwargs가 무엇인가요?

*args와 **kwargs는 함수에 가변 개수의 인수를 전달하는 것을 가능하게 합니다. 전달되는 인수가 몇 개인지 확신이 없을 때 사용합니다.

*args는 함수에 가변 개수의 인수를 전달하는 것을 가능하게 합니다.



<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 addNumbers(*numbers):
    sum = 0
    for number in numbers:
        sum = sum + number
    print("Sum: ", sum)
addNumbers(3,5) # Sum: 8
addNumbers(5,6,7) # Sum: 18
```

**kwargs는 함수에 변수 수의 키워드 인수를 전달하는 데 사용됩니다.

```python
def addNumbers(**data):
    sum = 0
    for key, value in data.items():
        sum = sum + value
    print("Sum: ", sum)
    
addNumbers(a=5, b=6) # Sum: 11
addNumbers(a=5, b=8, c=10) # Sum: 23
```

# 파이썬에서 컨텍스트 매니저란 무엇인가요?


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

컨텍스트 관리자는 리소스를 관리합니다. 필요에 따라 리소스를 할당하고 해제할 수 있게 해줍니다.

가장 일반적인 예시는 `with` 문입니다.

주로 파일을 열고 닫는 데 사용됩니다.

`with`를 사용하면 코드 한 줄에서 문제가 발생해도 파일이 올바르게 닫힙니다.


<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
with open('./data.txt', 'w') as f:
    f.write("Hello")
```

# 파이썬에서 인스턴스 메소드, 클래스 메소드 및 정적 메소드란 무엇인가요?

파이썬에서는 세 가지 종류의 메소드가 있습니다: 인스턴스 메소드, 클래스 메소드 및 정적 메소드.

- 인스턴스 메소드: 클래스 내에 만드는 일반적인 메소드로, 객체와 관련이 있습니다. 인스턴스를 가리키기 위해 `self`를 사용합니다.
- 클래스 메소드: 객체가 아닌 클래스에 바운드된 메소드로, 클래스 수준의 작업을 수행하며 클래스 상태를 변경할 수 있습니다. `@classmethod` 데코레이터를 사용합니다.
- 정적 메소드: 클래스 내에 정의되어 있지만 클래스 자체와 관련이 없는 논리를 명확하게 하기 위해 사용합니다. `@staticmethod` 데코레이터를 사용합니다.


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

# nonlocal과 global 변수란 무엇인가요?

이들은 변수의 범위를 정의합니다. Global 변수는 함수 외부에서 정의됩니다.

```js
pi = 3.14  ## Global 변수
def circle(radius):
    area_of_circle = pi * (radius) ** 2
    print("원의 면적은: ", area_of_circle)
circle(7) # 원의 면적은: 153.86
```

이들의 값은 코드 전체에서 동일하며 프로그램의 어디에서든 사용할 수 있습니다.


<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 outer_function():
    x = "로컬 변수"
    def inner_function():
        nonlocal x
        x = "비로컬 변수"
        print("내부 함수:", x)
    inner_function()
    print("외부 함수:", x)
outer_function()
# 내부 함수: 비로컬 변수
# 외부 함수: 비로컬 변수
```

# 예제와 함께 제너레이터에 대해 설명해주세요.

제너레이터(generator)는 순회 가능한 객체(iterable objects)를 반환하는 함수입니다. 하나 이상의 `yield` 문을 포함해야 합니다.


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

`yield`은 함수의 현재 상태나 로컬 변수 참조를 잃지 않고 값을 반환하는 키워드입니다. `yield`가 포함된 함수를 제너레이터라고 부릅니다.

제너레이터는 필요할 때만 항목을 생성하여 메모리를 효율적으로 사용합니다.

초보자들에게 `yield`를 함수를 중지하지 않고 값을 반환하는 `return`으로 생각해보세요.

```js
def fibon(limit):
    a,b = 0,1
    while a < limit:
        yield a
        a, b = b, a + b
        
for x in fibon(10):
    print(x) # 1 2 3 5 8 13 21 34 55 89
```


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

# 결론

저는 10가지 흔한 Python 면접 질문을 공유했습니다. 이 질문들이 직장을 바꾸거나 직장을 찾을 때 도움이 되길 바라요!

저는 “Medium에서 빠르게 팔로워를 얻는 방법”에 대한 eBook을 쓰고 있어요. 왜냐하면 저는 최고의 증거이기 때문이죠 — 딱 한 달 만에 5,000명 이상의 팔로워를 얻었어요. 기대해주세요!

저는 Substack에서 "GPT 소개" 시리즈를 쓰고 있어요. 관심 있으시면 팔로우 해주세요!


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

10개의 글 중 10번째가 이미 완료되었습니다!

읽어주셔서 감사합니다📖, 강조해주셔서 감사합니다🖍️, 박수를 보내주셔서 감사합니다👏, 댓글을 달아주셔서 감사합니다💬, 그리고 공유해주셔서 감사합니다🗣️. "미디움의 친구"로써, 저는 매일 동료 작가들에게 제 게시물을 봐주며 보답하려 노력합니다.

최신 AI 이야기에 대한 소식을 받으려면 Substack에서 저희와 연락을 유지하세요. 함께 AI의 미래를 함께 만들어 봅시다!

Posts