![image](/TIL/assets/img/2024-07-14-15TipsforBuildingRobustWebApplicationswithDjango_0.png)

장고는 강력하고 다재다능한 웹 프레임워크로 개발자들이 빠르고 효율적으로 견고한 웹 애플리케이션을 구축할 수 있습니다. 그러나 진정으로 견고한 애플리케이션을 구축하려면 모범 사례와 고급 기술에 주의를 기울여야 합니다. 이곳에는 Django로 견고한 웹 애플리케이션을 구축하는 데 도움이 되는 15가지 팁이 있습니다.

## 1. 가상 환경 사용

가상 환경은 의존성을 관리하고 프로젝트별 라이브러리를 격리하는 데 필수적입니다. 이를 통해 패키지 간 충돌을 방지하고 일관된 개발 환경을 유지할 수 있습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
# 가상 환경 생성하기
python -m venv env

# 가상 환경 활성화하기
# Windows에서는
env\Scripts\activate
# Unix나 MacOS에서는
source env/bin/activate
```

# 2. 장고 프로젝트 구조 따르기

장고에서 권장하는 프로젝트 구조를 준수하여 애플리케이션을 구조화하고 유지보수 가능하게 유지하세요. 이는 앱, 템플릿, 정적 파일 및 설정을 분리하는 것을 포함합니다.

```js
myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py
    myapp/
        __init__.py
        admin.py
        apps.py
        models.py
        tests.py
        views.py
        migrations/
        templates/
        static/
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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. Django Admin을 활용하여 신속한 프로토타이핑

Django의 내장 관리자 인터페이스는 관리 인터페이스를 빠르게 생성하는 강력한 도구입니다. 필요에 맞게 사용자 정의하고 신속한 프로토타이핑 및 애플리케이션 데이터 관리에 활용하세요.

```js
# admin.py에서 모델 등록
from django.contrib import admin
from .models import MyModel

admin.site.register(MyModel)
```

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

클래스 기반 뷰(CBVs)는 함수 기반 뷰(FBVs)에 비해 더 유연하고 재사용 가능한 접근 방식을 제공합니다. 이를 통해 코드 재사용과 더 나은 구성을 촉진합니다.

```js
from django.views import View
from django.http import HttpResponse

class MyView(View):
    def get(self, request):
        return HttpResponse('Hello, World!')
```

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

```python
from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    # 여기에 사용자 정의 필드를 추가하세요
    pass

# settings.py 업데이트
AUTH_USER_MODEL = 'myapp.CustomUser'
```

# 6. 로직 분리를 위해 시그널 사용하기

Django 시그널을 사용하면 응용 프로그램의 구성 요소를 분리하여 통지를 보내고 받을 수 있습니다. 모델 변경이나 사용자 작업과 같은 이벤트를 처리하기 위해 시그널을 사용하세요.

```python
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import MyModel

@receiver(post_save, sender=MyModel)
def my_model_post_save(sender, instance, created, **kwargs):
    if created:
        # 어떤 동작 수행
        pass
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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. 데이터베이스 쿼리 최적화

효율적인 데이터베이스 쿼리는 성능에 중요합니다. Django의 ORM 기능인 select_related와 prefetch_related를 사용하여 쿼리의 수를 최소화하세요.

```js
# select_related 사용
queryset = MyModel.objects.select_related('related_model').all()

# prefetch_related 사용
queryset = MyModel.objects.prefetch_related('related_set').all()
```

# 8. 캐싱 구현


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

캐싱은 자주 액세스하는 데이터를 저장하여 성능을 향상시킵니다. Django는 Memcached와 Redis와 같은 다양한 캐싱 백엔드를 지원합니다.

```js
# settings.py 업데이트
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

# 뷰에서 캐싱 사용
from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def my_view(request):
    # 뷰 로직 여기에 작성
    pass
```

# 9. 미들웨어 현명하게 사용하기

미들웨어를 사용하면 요청과 응답을 전역적으로 처리할 수 있습니다. 미들웨어를 신중하게 사용하여 기능을 향상시키고 불필요한 복잡성을 추가하지 않도록 합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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 MyMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # 뷰가 호출되기 전 각 요청에 대해 실행되는 코드
        response = self.get_response(request)
        # 뷰가 호출된 후 각 응답에 대해 실행되는 코드
        return response

# settings.py 업데이트
MIDDLEWARE = [
    'myproject.middleware.MyMiddleware',
    # 다른 미들웨어
]
```

# 10. 양식 유효성 검사 구현

견고한 양식 유효성 검사는 데이터 무결성을 보장하고 사용자 경험을 향상시킵니다. Django의 양식 클래스를 사용하여 유효성 검사와 오류 처리를 처리하세요.

```js
from django import forms

class MyForm(forms.Form):
    name = forms.CharField(max_length=100)
    email = forms.EmailField()

    def clean_email(self):
        email = self.cleaned_data.get('email')
        if not email.endswith('@example.com'):
            raise forms.ValidationError('잘못된 이메일 도메인')
        return email
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 11. 애플리케이션 보안 강화하기

웹 애플리케이션에서 보안은 매우 중요합니다. Django의 기본 보안 기능인 CSRF 보호, XSS 보호 및 안전한 비밀번호 해싱 기능을 사용하세요.

```js
# CSRF 미들웨어가 활성화되어 있는지 확인
MIDDLEWARE = [
    'django.middleware.csrf.CsrfViewMiddleware',
    # 다른 미들웨어
]

# Django의 기본 비밀번호 해시 함수 사용하기
from django.contrib.auth.hashers import make_password

password = make_password('my_secure_password')
```

# 12. 비동기 작업에 Celery 사용하기


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
# Celery 설치하기
pip install celery

# Celery 인스턴스 생성하기
from celery import Celery

app = Celery('myproject', broker='redis://localhost:6379/0')

# settings.py에서 Celery 구성하기
CELERY_BROKER_URL = 'redis://localhost:6379/0'

# 작업 정의하기
@app.task
def my_task():
    # 작업 로직 작성
    pass

# 작업 호출하기
my_task.delay()
```

# 13. 테스트 작성하기

테스트를 작성하면 애플리케이션의 신뢰성과 안정성을 보장할 수 있어요. 장고의 내장 테스트 프레임워크를 사용하여 단위 테스트, 통합 테스트, 기능 테스트를 작성해보세요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


from django.test import TestCase
from .models import MyModel

class MyModelTest(TestCase):
    def test_str(self):
        my_model = MyModel(name='Test')
        self.assertEqual(str(my_model), 'Test')


## 14. Logging 사용

Logging을 사용하면 애플리케이션의 모니터링과 디버깅에 도움이 됩니다. 중요 이벤트와 오류를 캡처하기 위해 Django의 로깅 프레임워크를 구성하세요.

```python
# settings.py 업데이트
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': 'debug.log',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

# view에서 logging 사용
import logging

logger = logging.getLogger(__name__)

def my_view(request):
    logger.debug('디버그 메시지입니다')
    # 뷰 로직은 여기에
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 15. 최선의 실천 방법으로 배포하기

Django 애플리케이션을 배포하는 것은 제품 환경에서 원할하게 실행되도록 하는 여러 단계를 거칩니다. 견고한 배포 설정을 위해 Gunicorn, Nginx, Docker와 같은 도구들을 사용하세요.

```js
# 예시 Gunicorn 명령어
gunicorn myproject.wsgi:application --bind 0.0.0.0:8000

# 예시 Dockerfile
FROM python:3.9
ENV PYTHONUNBUFFERED 1
WORKDIR /app
COPY requirements.txt /app/
RUN pip install -r requirements.txt
COPY . /app/
CMD ["gunicorn", "myproject.wsgi:application", "--bind", "0.0.0.0:8000"]
```

이 15가지 팁을 따르면 Django로 견고하고 안전하며 효율적인 웹 애플리케이션을 만들 수 있습니다. 소규모 프로젝트나 대규모 애플리케이션을 개발하더라도 최선의 실천 방법을 준수하고 Django의 강력한 기능을 활용하면 애플리케이션이 유지보수 가능하고 성능이 우수하며 확장 가능하도록 보장할 수 있습니다. 즐거운 코딩 되세요!

Django로 튼튼한 웹 애플리케이션을 만드는 15가지 팁

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

데이터 엔지니어로서, 데이터 파이프라인을 다루고 성능을 최적화하는 데 수많은 시간을 보냈습니다. PySpark에 대해 꽤 잘 알고 있을 줄 알았지만, 몇 가지 부분에 대해 틀렸던 것을 깨달았습니다 — 특히 repartition() 함수에 관한 부분이 그렇습니다.

많은 분들처럼, 저도 repartition() 함수가 어떻게 작동하는지에 대해 많은 가정을 했습니다. 그러나 몇몇 가정이 사실은 크게 틀렸던 것으로 판명이 났습니다. 이 블로그 게시물에서는 PySpark에서 분할에 대한 일반적인 오해 몇 가지를 해소해보겠습니다. repartition() 함수에 집중하고, 실제로 데이터가 파티션으로 어떻게 분산되는지 살펴보겠습니다.

그러나 스크롤 다운하기 전에 — df.repartition(columnName)이 columnName의 값을 기반으로 데이터를 분배한다고 알고 계셨나요? 아래 이미지와 같은 방식으로 말이죠? 이것은 흔히 퍼지는 미신입니다! 사실은 대부분의 사람들이 생각하는 방식으로 작동하지 않습니다. 흥미를 느껴지나요? 이어서 진실을 밝혀보고 파티션 전략을 최적화하는 방법을 배워보세요!


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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-TheTruthAboutPySparksRepartitionPreparetoBeSurprised_1.png)

파이스파크에서는 두 가지 주로 사용되는 파티션 전략을 알고 있습니다. 첫 번째는 df.repartition()이고 두 번째는 df.repartitionByRange()입니다. 이 두 함수는 데이터프레임 내에서 데이터를 파티션 간에 재분배하기 위해 일정한 로직을 사용합니다. 오늘은 repartition() 함수에 중점을 둘 것입니다.

# 신화

일반적으로 SQL 언어에서는 데이터를 파티션 키(예: 국가)로 파티션하면 해당 데이터가 국가 별로 여러 청크로 분할될 것이라는 개념을 자주 접하게 됩니다. 예를 들어, 이것은 일반적으로 사용되는 T-SQL 코드입니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
SELECT
    Country,
    COUNT(Name) OVER (PARTITION BY Country) AS CountPerCountry
FROM sample_data;
```

Databricks의 Delta Tables을 사용하더라도 간단한 Spark SQL 절로 테이블을 파티션할 수 있어요:

```js
CREATE TABLE partitioned_country_table
USING DELTA
PARTITIONED BY (Country)
AS SELECT * FROM sample_data;
```

PySpark DataFrames를 사용할 때 파티션을 어떻게 볼지를 다시 고려하는 것이 중요해요. 확장 가능한 병렬 컴퓨팅을 위해 설계된 Spark에서는 파티션을 주로 데이터를 효율적으로 worker 노드에 분산시키는 데 사용하며 집계를 수행하는 데 사용되지는 않아요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

.repartition(columnName)을 사용하면 데이터가 columnName의 고유 값에 따라 자동으로 그룹화된다는 흔한 오해가 있습니다. 이 오해는 사람들이 "repartition"이란 용어가 데이터를 해당 열 값에 따라 별도의 그룹으로 재구성한다고 직감적으로 생각하기 때문에 발생합니다. 하지만 Spark에서는 .repartition(columnName)이 데이터를 재분배하여 병렬성을 달성하고 성능을 향상시키지만 모든 columnName 값을 가진 행이 반드시 동일한 파티션에 포함되는 것을 보장하지는 않습니다.

가짜 데이터로 이를 증명해 봅시다.

```python
from faker import Faker
import random
from pyspark.sql import SparkSession
from pyspark.sql.types import *
from pyspark.sql.functions import spark_partition_id, countDistinct

spark_session = (
    SparkSession.builder.master("local")
    .appName("Spark Repartitioning")
    .config("spark.sql.adaptive.enabled", "false")
    .getOrCreate()
)

# Faker 초기화
fake = Faker()

# 샘플 데이터 생성
def generate_data(num_records):
    data = []
    for _ in range(num_records):
        name = fake.name()
        country = fake.country()
        data.append((name, country))
    return data

data = generate_data(1000)  # 1000개 레코드 생성
data = spark_session.sparkContext.parallelize(data)

# 데이터의 스키마 정의
schema = StructType(
    [
        StructField("Name", StringType(), True),
        StructField("Country", StringType(), True),
    ]
)

# 데이터와 스키마를 사용하여 DataFrame 생성
df: DataFrame = spark_session.createDataFrame(data, schema)
df = df.repartition("Country").withColumn("partitionId", spark_partition_id())

(
    df.groupBy("partitionId")
    .agg(countDistinct("Country").alias("DistinctCount"))
    .filter("DistinctCount > 1")
    .show()
)

```

```python
+-----------+-------------+
|partitionId|DistinctCount|
+-----------+-------------+
|         31|            2|
|         85|            2|
|         65|            3|
|        155|            3|
|         26|            4|
|        103|            2|
|         91|            2|
|         22|            2|
|        157|            2|
|        177|            2|
|         52|            2|
|         13|            3|
|         86|            2|
|        178|            2|
|         20|            2|
|         40|            3|
|         57|            2|
|        120|            2|
|         96|            2|
|         48|            2|
+-----------+-------------+
상위 20개 행만 표시됨
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

보시다시피, 일부 DataFrame 파티션에는 파티션당 하나 이상의 나라가 포함되어 있어서, 처음에 기대했던 것과는 다릅니다. 그런데 왜 이런 일이 발생하는 걸까요?

이 진실은 PySpark의 배경에 숨어 있습니다. repartition() 함수는 내부적으로 HashPartitioner를 호출하여 (이 멋진 Stack Overflow 댓글에서 설명된대로) 데이터를 파티션으로 분산합니다. 이 파티셔너는 데이터를 파티션에 따라 분배하기 위해 다음과 같이 정의된 공식을 사용합니다: hash(partitionKey) % numPartitions

아래 다이어그램에 따라 데이터를 파티션에 분배합니다.

![다이어그램](/TIL/assets/img/2024-07-14-TheTruthAboutPySparksRepartitionPreparetoBeSurprised_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>


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

위의 다이어그램을 복제하는 PySpark 코드입니다.

```python
from pyspark.sql.functions import hash, col, lit, spark_partition_id, udf

data = [("Marshall Islands",), ("Tuvalu",), ("Somalia",), ("USA",)]

schema = StructType([StructField("Country", StringType(), True)])

# 파티션 수
num_partitions = 2

# 해시 및 파티션 계산
df2 = df.withColumn("hash", hash(col("Country")))
df2 = df2.withColumn("num_partitions", lit(num_partitions))
df2 = df2.withColumn(
    "hash(Country) % numPartitions",
    (col("hash") % col("num_partitions") + col("num_partitions"))
    % col("num_partitions"),
)
df2 = df2.repartition(num_partitions, col("Country"))
df2 = df2.withColumn("spark_partition_id", spark_partition_id())
df2.show()
```

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

보시다시피, 레코드가 어느 파티션에 끝날지 예측할 수 있으므로 .repartition() 함수가 더 이해하기 쉬워집니다.

# 이게 왜 중요한가요?

저는 직접 참여한 프로젝트에서의 실제 사용 사례로 생각해보겠습니다. 저희는 Databricks와 PySpark를 사용하여 수백 테라바이트의 매우 큰 데이터 세트를 이관했습니다. 데이터가 처리된 후에는 Spark MSSQL Connector를 사용하여 Azure SQL Server에 저장되었습니다. 테이블을 파티션별로 데이터를 저장할 때 높은 동시성을 보장하기 위해 경쟁과 대기 시간을 줄이기 위해 노력했습니다. 초기 접근 방식은 쓰기 프로세스 이전에 .repartition()을 사용하는 것이었는데, 이로 인해 일부 속도 이점을 얻었습니다. 그러나 여전히 락과 경합이 발생했습니다. 최종적으로 우리는 repartitionByRange()로 전환했고, 이 방법이 더 결정론적이며 우리의 SQL Server 테이블 파티셔닝 전략과 더 잘 부합한다는 것을 알게 되었습니다.

이것은 한 가지 사용 사례에 불과하지만, 이 개념을 이해하는 것은 잠재적인 병목 현상을 식별하는 데 도움이 됩니다. repartitionByRange() 대 repartition()과 그들의 성능 영향에 대한 장단점에 대한 구체적인 기사를 쓰기로 계획하고 있습니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 결론

PySpark에서의 Repartitioning은 파이프라인 성능에 중요한 측면입니다. PySpark 파티션 내 데이터의 분포는 병렬성 뿐만 아니라 리소스 활용에도 영향을 미칩니다. 리소스를 더 효율적으로 사용하기 위해서는 적절한 파티셔닝이 필요합니다.

repartition() 메서드가 모든 문제를 해결해 주지는 않지만, 그 동작을 이해하는 것이 중요합니다. 이 메서드는 데이터를 분할하는 데 있어 파티션 키를 기준으로 결정적으로 분할하는 것이 아니라, 작업 노드에 데이터를 골고루 분배하여 성능과 병렬화를 향상시키는 데 사용됩니다.

# 연락 유지하기


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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에서 제게 팔로우해주세요.
- LinkedIn에서 연락해주세요.

참고해 주셔서 감사합니다 :)

# 간단히 말해 🚀


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

In Plain English 커뮤니티의 일원이 되어 주셔서 감사합니다! 떠나시기 전에:

- 작가를 클랩하고 팔로우해주세요 ️👏️️
- 팔로우하기: X | LinkedIn | YouTube | Discord | Newsletter
- 다른 플랫폼 방문하기: Stackademic | CoFeed | Venture | Cubed
- PlainEnglish.io에서 더 많은 콘텐츠 만나보세요

PySpark의 Repartition 진실 놀랄 준비 하세요

데이터 사이언스 마스터를 위한 11가지 필수 Python Matplotlib 시각화

Django 개발자들이 자주 저지르는 10가지 실수와 해결 방법

# 요약

배경: 이미지 세그멘테이션은 특히 생체 의료 이미징 분야에서 정확성과 효율성을 요구하여 정밀한 분석이 필요합니다. Olaf Ronneberger 등에 의해 소개된 U-Net 아키텍처는 이러한 작업에 대한 중요한 해결책으로 부상하였습니다.

문제: 기존 이미지 세그멘테이션 기술은 고해상도 공간 세부 정보와 맥락적 이해 사이의 균형을 맞추는 데 도움이 필요하여 세그멘테이션 성능이 최적화되지 않을 수 있습니다.

접근 방식: 본 글에서는 합성 데이터셋을 활용한 U-Net 아키텍처의 구현을 탐구합니다. 특성 엔지니어링, 하이퍼파라미터 튜닝, 교차 검증을 포함한 포괄적인 프로세스를 통해 모델을 교육 및 평가합니다. U-Net 모델의 성능은 표준 메트릭과 시각화를 사용하여 평가됩니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

결과: U-Net 모델은 합성 데이터셋에서 높은 정확도(99.03%), 정밀도(99.07%), 재현율(98.99%), 그리고 F1 점수(99.03%)를 달성했습니다. 손실 및 정확도 플롯은 효과적인 학습과 과적합이 적음을 시사하며, 실제 및 예측된 마스크의 시각적 비교는 모델의 분할 능력을 보여줍니다.

결론: U-Net 아키텍처는 이미지 분할 작업에 매우 효과적이며, 우수한 성능 지표와 시각적 결과를 달성합니다. 고해상도 공간 세부 정보를 맥락적 이해와 결합할 수 있는 능력은 특히 생체 의료 이미지 분석과 같이 정밀한 이미지 분석이 필요한 분야에서 가치가 있습니다.

키워드: U-Net 아키텍처; 이미지 분할; 생체 의료 이미징; 딥 러닝; 신경망.

# 소개


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

의료 영상 이미지를 정밀하게 분석하여 이상을 식별하는 방사선 전문의로 상상해 보세요. 이 작업에는 예민한 시각과 몇 시간에 걸친 집중력이 필요합니다. 만약 이 프로세스를 자동화하여 작업량을 줄이고 정확성을 높일 방법이 있다면 어떨까요? U-Net [1]이 그 해결책으로 등장합니다. 이 건물주택은 의료 영상 분할에서 혁명을 일으킨 아키텍처의 놀라운 예다.

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

# U-Net의 탄생

U-Net은 2015년에 Olaf Ronneberger와 그 동료들에 의해 소개되었으며 주로 생체 의료 이미지 분할을 위해 설계되었습니다. U자 모양을 띤 이 아키텍처는 맥락을 포착하는 수축 경로와 정확한 지역화를 가능케 하는 대칭확장 경로로 구성되어 있습니다. 이 이중 경로 접근법은 특히 정확성이 중요한 분야에서 U-Net을 게임 체인저로 만들었습니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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. 인코더: 맥락 캡처

인코더 또는 저차원화 경로는 3x3 콘볼루셔널 계층 두 개(패딩이 없는 콘볼루션)을 반복적으로 적용한 후 각각 ReLU 및 2x2 맥스 풀링 연산을 적용하여 다운샘플링하는 과정으로 구성됩니다. 이 경로는 이미지의 주요 특징을 캡처하면서 공간적인 차원을 줄여 입력 데이터의 맥락을 이해할 수 있도록 합니다.

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

네트워크의 핵심에서 병목 계층은 인코더와 디코더 사이의 다리 역할을 합니다. 이 계층은 데이터를 더 처리하며 분할에 중요한 가장 추상적인 특징을 포착하는 합성곱 계층으로 구성되어 있습니다.

## 3. 디코더: 정확한 위치 지정

디코더 또는 확장 경로는 특성 맵의 업샘플링을 수행한 후 2x2 컨볼루션("업-컨볼루션")이 이어지는 반으로 특성 채널의 수를 절반으로 줄이는 작업을 수행합니다. 이 경로는 인코더에 의해 포착된 맥락을 수축 경로의 해당 계층에서의 고해상도 특징과 skip 연결을 통해 결합합니다. 이러한 skip 연결은 네트워크가 다운샘플링 중에 상실된 공간 정보를 보존하도록 도와주기 때문에 정확한 위치 지정을 보장합니다.

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

최종 레이어는 각 피처 벡터를 원하는 클래스 수에 매핑하는 1x1 컨볼루션입니다. 일반적으로 이어서 소프트맥스 활성화 함수가 사용됩니다. 그 결과는 입력 이미지의 관심 영역을 강조하는 분할된 출력입니다.

# 건너뛰기 연결의 힘

U-Net의 가장 혁신적인 기능 중 하나는 건너뛰기 연결의 사용입니다. 이러한 연결은 인코더와 디코더 경로의 해당 레이어를 연결하여 네트워크가 일반적으로 대략적이고 추상적인 피처를 세밀하고 상세한 정보와 결합하도록 하는 데 기여합니다. 이 설계 선택은 U-Net이 상대적으로 작은 데이터셋에서 훈련되었을 때라도 높은 정확도를 달성하도록 허용하여 분할 작업에서 뛰어난 성능을 발휘하게 만듭니다.

# 실제 응용 사례


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

U-Net이 처음에는 의료 이미지 분할을 위해 개발되었지만, 그 응용 분야는 훨씬 넓어집니다. 농업 분야에서는 위성 이미지를 분할하여 작물 건강을 모니터링하는 데 사용됩니다. 자율 주행에서는 U-Net이 도로 장면을 분할하여 차선, 차량 및 보행자를 식별하는 데 도움이 됩니다. U-Net의 다양성은 이미지 분할이 중요한 여러 영역에서 가치있는 도구로 만들어줍니다.

# 실제 예시

아래에는 합성 데이터셋에서 U-Net 아키텍처를 시연하는 완전한 코드 예시가 있습니다. 이 예시에는 특성 특성화, 특성 공학, 하이퍼파라미터 튜닝, 교차 검증, 예측, 평가 메트릭 및 결과 시각화가 포함되어 있습니다.

```js
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, KFold
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
import tensorflow as tf
from tensorflow.keras import layers, models as keras_models
from tensorflow.keras.optimizers import Adam

# 합성 데이터셋 생성
def create_synthetic_data(num_samples=1000, img_size=128):
    X = np.random.rand(num_samples, img_size, img_size, 1)
    Y = (X > 0.5).astype(np.float32)
    return X, Y

X, Y = create_synthetic_data()

# 데이터 분할
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)

# U-Net 모델
def unet_model(input_size=(128, 128, 1)):
    inputs = layers.Input(input_size)

    # 중략

# 모델 컴파일 및 훈련
def compile_and_train_model(X_train, Y_train, X_val, Y_val, epochs=50, batch_size=32, learning_rate=1e-4):

    # 중략

# 하이퍼파라미터 튜닝 및 교차 검증
kf = KFold(n_splits=5)
histories = []
trained_models = []

# 중략

# 테스트 세트에서 최종 모델 평가
best_model = trained_models[0]

# 중략

# 평가 메트릭
accuracy = accuracy_score(Y_test.flatten(), test_predictions_binary.flatten())
precision = precision_score(Y_test.flatten(), test_predictions_binary.flatten())
recall = recall_score(Y_test.flatten(), test_predictions_binary.flatten())
f1 = f1_score(Y_test.flatten(), test_predictions_binary.flatten())

print(f"정확도: {accuracy:.4f}")
print(f"정밀도: {precision:.4f}")
print(f"재현율: {recall:.4f}")
print(f"F1 점수: {f1:.4f}")

# 훈련 이력 시각화
plt.figure(figsize=(12, 4))

# 중략

# 예측 시각화
def visualize_predictions(X_test, Y_test, predictions, num_samples=5):
    plt.figure(figsize=(15, 5))

    # 중략

visualize_predictions(X_test, Y_test, test_predictions_binary)
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 코드 설명

- 가상 데이터셋 생성: 무작위 이미지와 이에 대응하는 이진 마스크로 가상 데이터셋을 생성합니다.
- 데이터 분할: 데이터셋을 학습 및 테스트 세트로 나눕니다.
- U-Net 모델 정의: U-Net 아키텍처를 인코더, 병목, 디코더 블록으로 정의합니다.
- 모델 컴파일 및 학습: 모델을 Adam 옵티마이저와 이진 크로스 엔트로피 손실 함수로 컴파일합니다. 학습 및 검증 데이터로 모델을 학습시킵니다.
- 하이퍼파라미터 튜닝 및 교차 검증: K-Fold 교차 검증을 사용하여 여러 모델을 학습하고 학습 히스토리를 기록합니다. 
- 평가: 최적 모델을 정확도, 정밀도, 재현율 및 F1 점수를 사용하여 테스트 세트에서 평가합니다.
- 학습 히스토리 그래프: 모델의 성능을 시각화하기 위해 학습과 검증 손실 및 정확도를 플롯합니다.
- 예측 시각화: 테스트 세트에서 몇 가지 샘플을 시각화하여 입력 이미지, 실제 마스크 및 예측된 마스크를 비교합니다.

이 코드는 가상 데이터셋을 사용하여 U-Net 모델을 구현하고 평가하는 포괄적인 예제를 제공하며, 모델 학습부터 성능 평가 및 시각화까지 모든 중요한 측면을 다룹니다.

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

U-Net 모델이 합성 데이터 세트에서의 성능이 시각적 및 양적으로 평가되었습니다. 결과를 자세히 해석해 봅시다.

## 손실 및 정확도 그래프

손실 그래프

- 훈련 손실 및 검증 손실: 둘 다 초기에 빠르게 감소한 후 낮은 값 주변에 안정화되며, 끝에 약간의 상승이 나타납니다. 훈련 및 검증 손실이 유사한 추세를 따르므로, 모델이 과적합이 없이 효과적으로 학습하고 있음을 나타냅니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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.99 정도에서 안정화됩니다. 훈련 및 검증 정확도 곡선의 밀접한 일치는 잘 일반화된 모델을 나타냅니다.

## 성능 메트릭

- 정확도: 0.9903: 모델이 픽셀 중 약 99.03%를 올바르게 식별합니다.
- 정밀도: 0.9907: 마스크 일부로 예측된 픽셀 중 약 99.07%가 올바릅니다. 이 높은 정밀도는 모델이 거의 잘못된 양성 오류를 만들지 않음을 나타냅니다.
- 재현율: 0.9899: 모델이 실제 마스크 픽셀 중 약 98.99%를 올바르게 식별합니다. 이 높은 재현율은 모델이 거의 잘못된 해로운 오류를 만들지 않음을 시사합니다.
- F1 점수: 0.9903: 정밀도와 재현율의 조화 평균으로, 두 지표 사이의 견고한 균형을 나타냅니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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 형식으로 변환된 내용입니다.

![예측 시각화](/TIL/assets/img/2024-07-14-TheRevolutionofImageSegmentationExploringU-NetArchitecture_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>

U-Net 모델은 합성 데이터셋에서 뛰어난 성능을 보여주었습니다. 높은 정확도, 정밀도, 재현율 및 F1 점수를 기록했죠. 훈련 및 검증 지표 간의 밀접한 일치는 모델이 잘 일반화되었고 균형있게 설정되었음을 시사합니다. 시각화 결과도 모델이 이미지를 정확하게 분할하고 실제 마스크와 근접하게 일치하는 것을 확인합니다.

이 예시는 이미지 세그멘테이션 작업에 U-Net의 힘을 잘 보여줍니다. 높은 성능 지표와 정확한 분할을 시각적으로 확인함으로써, 심지어 합성 데이터셋에서도 U-Net의 효과를 명확히 확인할 수 있습니다. 이는 정밀한 세그멘테이션이 필요한 생체 의료 영상과 같은 분야에서 U-Net의 응용에 대한 신뢰감을 제공합니다.

# 결론

U-Net은 이미지 세그멘테이션 분야에서 새로운 표준을 세웠습니다. 복잡한 세부사항을 포착하고 정확한 지역화를 제공하는 능력은 다양한 산업에서 필수품이 되었습니다. 기술이 발전함에 따라 U-Net의 원칙은 더욱 정교한 아키텍처를 영감으로 삼아 이미지 분석의 가능성을 확장시킬 것으로 기대됩니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

정밀도가 모든 차이를 만들 수 있는 세상에서 혁신적인 신경망 설계의 힘을 증명하는 U-Net은 복잡한 분할 도전 과제에 접근하고 해결하는 방법을 변화시키고 있습니다.

U-Net 아키텍처 탐험을 통해 유익한 정보를 얻으셨기를 바랍니다. U-Net 모델이 이미지 분할의 미래에 어떻게 영향을 미칠 것으로 보십니까? 아래 댓글란에 여러분의 생각과 경험을 공유해주세요! 만약 이 글이 마음에 들었다면 꼭 여러분의 네트워크와 공유하지 않으시기 바랍니다.

# 참고문헌

이미지 분할의 혁명 U-Net 아키텍처 탐구

다른 폴더에서 코드를 가져올 때 항상 빈 __init__.py 파일을 넣습니다. 이것은 대부분의 파이썬 개발자들에게 거의 반복적인 습관이 되었습니다 - 초보자든 마법사든. 그러나 우리는 __init__.py에 대해 정말로 알고 있을까요?

이 블로그 포스트에서는 __init__.py가 어떻게 작동하는지와 비어있지 않은 __init__.py가 우리 파이썬 개발자로서 어떻게 도움이 되는지 세 가지 방법을 살펴보겠습니다.

## __init__.py란 무엇인가요?

__init__.py는 폴더를 패키지로 취급해야 한다는 것을 파이썬 해석기에 알려주는 파이썬 파일입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

컴파일된 언어인 C 및 C++과 달리, Python의 인터프리터는 필요한 종속성을 실시간으로 가져옵니다. Python에게 코드를 다른 곳에서 사용할 것이라고 신호를 보내려면 폴더에 __init__.py를 넣으면 됩니다.

그래서 __init__.py를 게이트키퍼로 생각해보세요. 이 파일은 폴더를 가져올 수 있는 Python 패키지로 변환시켜줍니다.

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

하지만 __init__.py는 그 이상입니다. Python에서 클래스를 만들 때 종종 __init__ 함수를 생성해야합니다. 이 함수는 객체가 어떻게 구성되어야 하는지를 정의하며 클래스의 객체가 생성될 때 가장 먼저 실행됩니다. 같은 방식으로, __init__.py는 Python 패키지의 생성자입니다. 패키지가 가져올 때마다 먼저 실행됩니다. 빈 __init__.py는 Python 패키지의 빈 __init__ 생성자 메서드를 의미합니다. 괜찮지만 더 많은 일을 할 수 없다는 뜻은 아닙니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## __init__.py 주의해서 사용하기

__init__.py는 파이썬 패키지의 생성자이므로, __init__.py를 어디에 두는지에 대해 신중해야 합니다.

날짜 형식을 처리하는 몇 가지 사용자 정의 유틸리티 함수가 있는 datetime이라는 폴더가 있다고 가정해봅시다:

```python
# ./datetime/utils.py

def increment_date(date: int, increment: int) -> int:
    """밀리초 단위로 타임스탬프 증가"""
    return date + increment
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

우리는 그런 다음 __init__.py를 추가해서 main.py에서 코드를 가져올 수 있도록합니다:

```js
myfolder
│
├── datetime
│   ├── __init__.py
│   └── utils.py
└── main.py
```

```js
# main.py

from datetime.utils import increment_date
from datetime import datetime

def main():
    timestamp = datetime.timestamp(datetime(2024, 2, 27))
    print(increment_date(timestamp, increment=10))

if __name__ == "__main__":
    main()
```

만약 main.py를 실행하면 무엇이 일어날까요?


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

ImportError: `datetime` 모듈에서 `datetime`을 가져올 수 없습니다.

보통, Python 인터프리터는 패키지 발견 과정을 (1) 로컬 디렉토리, (2) 표준 라이브러리, 그리고 (3) 설치된 Python 모듈의 순서로 우선시합니다.

datetime이라는 이름의 폴더에 __init__.py를 넣음으로써, 우리는 datetime이라는 파이썬 표준 라이브러리를 재정의했기 때문에 datetime.datetime을 가져오는 명령문이 실패했습니다.

이 문제를 피하려면 매우 간단한 수정이 필요합니다: 다른 Python 표준 라이브러리나 설치된 Python 모듈과 동일한 이름을 가진 폴더 아래에 __init__.py를 넣지 않도록 항상 주의하십시오.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

__init__.py가 어떻게 작동하는지 이해하면, 이것을 활용하여 할 수 있는 좀 더 멋진 것들을 살펴보겠습니다!

## 1. 패키지 레벨 설정 정의하기

만약 코드 내 모든 Python 파일이 유사한 설정을 공유한다면 어떨까요? 로깅 레벨, 상수, 환경 변수 등. 당신의 패키지 내 모든 Python 파일 상단에 설정을 지정하는 대신, 이를 모두 __init__.py에 포함시킬 수 있습니다.

```python
# myfolder/__init__.py

import os
import logging

# 패키지 전체의 환경 변수를 로드합니다.
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", None)

# 패키지 레벨 상수를 설정합니다.
MODEL = "gpt-4"

# 로깅 구성을 설정할 수도 있습니다.
logging.basicConfig(level=logging.INFO)

# 패키지 내에서 편리하게 재사용할 수 있는 사용자 지정 데코레이터를 추가하세요.
def foo(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        logging.info(f"함수 호출 중: {func.__name__}")
        result = func(*args, **kwargs)
        logging.info(f"함수 {func.__name__} 실행 완료")
        return result
    return wrapper
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
# myfolder/bar.py

# 패키지 __init__.py에서 상대적인 임포트
from . import OPENAI_API_KEY, MODEL, foo

from openai import OpenAI
from typing import Optional

client = OpenAI()

@foo
def chat_with_openai(prompt: str, llm: Optional[str] = None) -> Any:
    """Prompt를 LLM에 보내고 응답을 반환합니다"""
    llm = llm or MODEL
    
    return client.chat.completions.create(
              model=llm,
              messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
              ]
            )
```

위 내용에 추가하여 다음과 같은 작업도 가능합니다:

- 기능 플래깅
- 고급 로거 구성 (예: 모든 로그를 폴더에 저장)
- 기본 매개변수 설정 (예: 출력 디렉토리가 제공되지 않은 경우 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. 패키지 가져오기 단순화

코드베이스가 복잡해지면 더 많은 클래스와 함수를 추가하게 될 것입니다. 코드를 응집된 단위로 분리하는 원칙에 따라, 아래와 같은 구조가 생길 수 있습니다:

```js
foo
│
├── llm_email_responder
│   ├── __init__.py
│   ├── base_email_responder.py
│   ├── mail_chimp_responder.py
│   ├── zoho_mail_responder.py
│   └── send_grid_responder.py
└── __init__.py
```

MailChimp에 대한 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>

```js
from foo.llm_email_responder.mail_chimp_responder import MailChimpResponder
```

곧 여러 줄의 비슷한 import 문이 생겨나게 되어 코드베이스의 내부 구조를 기억하기 어렵게 만들 수 있습니다. 

__init__.py는 import를 정리하고 코드베이스의 더 낮은 수준의 부분을 보호하면서 개발 경험을 단순화하는 데 사용할 수 있습니다.

```js
# ./foo/llm_email_responder/__init__.py

# 사용자가 더 높은 수준의 구현만큼 자주 사용하지 않을 것으로 예상되므로
# 가장 낮은 수준의 이메일 응답기는 건너뜁니다.
from .mail_chimp_responder import MailChimpResponder
from .zoho_mail_responder import ZohoResponder
from .send_grid_responder import SendGridResponder

__all__ = [
    "MailChimpResponder",
    "ZohoResponder",
    "SendGridResponder",
]
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

위의 __init__.py와 함께, 이제 다음과 같이 응답기에 액세스할 수 있습니다:

```js
from foo.llm_email_responder import MailChimpResponder
```

이것은 개발자 친화적 인터페이스에서 하위 수준의 코드를 노출하는 편리한 방법이지만, 하위 수준 코드베이스에 대한 변경은 반드시 __init__.py의 변경과 일치해야 함으로 유지 보수 노력이 증가할 것입니다. 또한 하위 수준의 코드 베이스를 노출하는 것이 일관된 아키텍처를 형성하는지 여부를 평가해야 합니다.

## 싱글톤 패턴


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

싱글톤 디자인 패턴을 적용하려면 __init__.py를 사용할 수도 있어요. 이렇게 하면 패키지 전체가 __init__.py에서 인스턴스화한 동일한 인스턴스를 사용하도록 강제됩니다.

만약 패키지가 원격 서비스에 연결을 설정하거나 대규모 데이터셋을로드하거나, 무거운 작업을 요구하는 어떤 전제조건이 필요하다면, 이 방법이 아주 편리할 거예요.

예를 들어 금융 보고서를 조작하는 LLM 필요를 처리하기 위해 Gemini Pro에 연결해야 한다고 해보죠.

```js
foo
│
├── report_analyser
│   ├── __init__.py
│   ├── outline_extraction.py
│   └── entity_extraction.py
└── __init__.py
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


# .foo/report_analyser/outline_extraction
from langchain_google_vertexai import VertexAI

def extract_outline(page: str, **kwargs) -> str:
    llm = VertexAI(
        model_name="gemini-pro", location="europe-west2", **kwargs
    )
    prompt_template = """...<Your prompt template here>..."""
    prompt = prompt_template.format_prompt(page=page)
    return llm.invoke(prompt)



# .foo/report_analyser/entity_extraction
from langchain_google_vertexai import VertexAI

def extract_entities(page: str, **kwargs) -> str:
    llm = VertexAI(
        model_name="gemini-pro", location="europe-west2", **kwargs
    )
    prompt_template = """...<Your prompt template here>..."""
    prompt = prompt_template.format_prompt(page=page)
    return llm.invoke(prompt)



# .foo/report_analyser/entity_extraction
from foo.report_analyser.outline_extraction import extract_outline
from foo.report_analyser.entity_extraction import extract_entities

def main():
    page = "Long page of document here"

    # A connection to VertexAI will be created for
    # extracting outline
    outline = extract_outline(page, temperature=0.2)

    # Another connection to VertexAI will be created
    # for extracting entities
    entities = extract_entities(page, temperature=0.2)


각 작업을 실행할 때마다 코드베이스가 VertexAI와 새로운 연결을 생성하여 불필요한 네트워크 오버헤드가 발생합니다. 만약 Gemini Pro에 대해 동일한 구성을 사용할 계획이라면, 대신 다음을 수행할 수 있습니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
# .foo/report_analyser/__init__.py
from langchain_google_vertexai import VertexAI

DEFAULT_LLM = VertexAI(
    model_name="gemini-pro",
    location="europe-west2",
    temperature=0.2,
)
```

```js
# .foo/report_analyser/outline_extraction
from . import DEFAULT_LLM

from typing import Dict

def extract_outline(
    page: str,
    custom_llm_parameters: Optional[Dict] = None
) -> str:
    
    if custom_llm_parameters is None:
        llm = DEFAULT_LLM
    else:
        llm = VertexAI(
            model_name="gemini-pro",
            location="europe-west2",
            **custom_llm_parameters
        )
    prompt_template = """...<Your prompt template here>..."""
    prompt = prompt_template.format_prompt(page=page)
    return llm.invoke(prompt)
```

코드를 개선하려면, __init__.py에서 LLM 연결을 생성하는 부분을 분리하여 별도의 파일로 만들어 LLM 연결 관리자를 만들 수 있습니다. @lru_cache와 결합하면 사용자 정의 구성을 더 효율적으로 처리하고 있는 것을 알 수 있을 것입니다.

__init__.py에 대해 무엇인지 배우고 더 잘 활용하는 방법에 대한 아이디어를 얻었기를 바랍니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

파이썬에 대해 더 알고 싶다면, 파이썬에 관한 다른 블로그를 확인해보세요!

다음에 또 만나요, Louis입니다.

__init__py 파일 제대로 이해하고 사용하기

![Tri-Solar Syzygy](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_0.png)

영화 예고편에 있는 내용이라면 스포일러가 아닙니다. 제가 말하고 싶은 것은 Trisolaris 행성 주민들이 표면에서 끌려 내려가는 장면을 언급한 것입니다.

여기 중요한 사항들만 알려 드릴게요. Trisolaris라는 행성이 세 개의 태양이 있는 천체계에 있다는 점입니다 (그래서 3-체 문제라고 불립니다). 어느 순간, 사람들 (실제로는 사람이 아니죠)이 행성 표면에서 끌려올라가는 장면이 있는데요. 책에서 이렇게 이야기하고 있어요.

이 부분이 플롯의 현실적인 면에서 옳은지 여부는 사실 중요하지 않아요 — 이겈 이야기이고, 때로는 이야기가 물리 법칙을 따르지 않기도 해요. 그래서 더 재미있는 거죠. 하지만 여전히 이 Tri-Solar Syzygy의 물리학을 살펴볼 거에요 (실은 '시지지'가 무엇인지는 잘 모르겠어요. 이제 물어보기도 부끄러워집니다).



<ins class="adsbygoogle"
     style="display:block"
     data-ad-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체 문제

만약에 중력 상호작용이 일어나는 두 물체가 있다면 (이렇게 해서 이진 별계에 있는 두 별이 될 수 있어요), 해석적으로 운동 방정식을 풀어낼 수 있어요. 초기 조건을 알고 있다면 두 물체의 미래 위치와 속도를 찾을 수 있는 식을 얻을 수 있어요. 놀랍게도, 이를 2체 문제라고 부를 수 있어요. 만일 더 자세한 유도를 원한다면, 제가 도와드릴 수 있어요.

하지만 만약 서로 상호작용하는 세 물체를 갖고 있다면 어떨까요? 예를 들어, 세 개의 별이 있다고 해 봅시다: 별 1, 별 2, 별 3. 이 경우에는 별 1과 2 사이의 상호작용, 2와 3 사이의 상호작용, 그리고 1과 3 사이의 상호작용이 존재할 거에요. 이는 2체 문제의 좀 더 복잡한 버전일 것 같지만, 이 시스템을 위한 해석적인 해결책은 없어요. (적어도 우리가 아는 바로는) 이를 방정식 형태로 풀 수 있는 방법은 불가능해요.

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>

각 시간 간격 동안의 계산은 비교적 간단합니다 — 하지만 그만큼 많은 계산을 해야 합니다. 누구나 그 모든 계산을 하고 싶어하진 않으니까, 컴퓨터에게 맡기는 게 편합니다 (그나저나 컴퓨터는 크게 불평하지 않아요 — 적어도 지금까진요).

여기 저의 매우 상세한 3체 문제의 수치해법입니다.

# 안정적인 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>

두 질량 간의 중력 상호작용을 다음 방정식으로 모델링할 수 있습니다:

![equation1](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_1.png)

여기서 M1과 m2는 벡터 r로 구분된 두 질량입니다. G는 만유인력상수이고 r-hat은 힘이 벡터가 되도록 하는 단위 벡터입니다. 그렇다면 두 개 이상의 질량이 있다면 어떻게 될까요? 그 경우, 총 힘은 각 질량에서 오는 힘의 벡터 합일 뿐입니다.

![equation2](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_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>

이제 우리는 원운동에 대해 생각해야 합니다. 삼성계의 가장 간단한 움직임은 원을 그리는 것이겠죠. 물체가 원 안에서 움직이고 있다면, 원의 중심을 향하는 가속도가 발생하며 그 크기는 다음과 같습니다:

![원운동 가속도](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_3.png)

원운동의 반지름은 r이고 속도는 v입니다. 각속도(ω)의 운동가속도를 계산하는 것도 가능합니다.

자, 이제 우리는 안정된 움직임을 준비했습니다. 세 개의 별이 같은 질량을 가지고 있으며 한 별이 고정되어 있고 다른 두 별이 그 고정된 별 주위를 공전하는 것으로 가정합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


![image1](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_4.png)

중간에 있는 별 1에는 두 개의 중력이 작용함을 알 수 있습니다. 그러나 대칭이라면, 별 2와 별 3이 반대 방향으로 같은 힘으로 작용하여 별 1이 정지 상태에 있을 수 있도록 하지요.

별 2를 보면, 왼쪽으로 두 개의 중력이 작용합니다 - 별 1과 별 3에서. 이 순방향 힘은 별 2가 왼쪽으로 가속화되도록 합니다. 이 순방향 힘이 별 2가 원운동 할 수 있도록 만드는 속도(v)를 계산할 수 있게 됩니다. 별 1은 별 2에서 거리 r 떨어져 있지만, 별 3는 2r의 거리에 있습니다.

![image2](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_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>

태양의 크기 (r)를 알고 있다고 가정해 봅시다. 그러면 별 2의 속도를 구할 수 있습니다 (이는 별 3의 속도가 될 것입니다).

![image](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_6.png)

이게 실제로 작동할까요? 한 번 시도해 볼 수 있습니다. 세 개의 같은 질량을 가진 태양으로 수치 계산을 해보겠습니다. 중간에 있는 별은 정지 상태에서 시작하고, 나머지 두 개의 별은 계산된 속도로 시작합니다. 그런 다음, 별의 움직임을 모델링하기 위해 수치 계산 방법을 사용할 수 있습니다. 전체 Web VPython 코드는 여기에서 확인할 수 있습니다. 애니메이션은 다음과 같이 보입니다:

![animation](https://miro.medium.com/v2/resize:fit:960/1*RA24sRZkOic5eOCj7FBVzg.gif)


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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개의 서로 작용하는 물체의 움직임을 쉽게 모델링할 수 있겠지만, 이 가정은 설정을 더 쉽게 만들 것입니다.

행성의 관점에서 볼 때, 세 별은 일직선으로 유지되어야 합니다. 이것은 삼합성이 두 별과 같은 각속도를 가지고 있을 때(가운데 별이 고정일 때) 발생합니다. 다음은 다이어그램입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_7.png)

당연히 이것은 실제 크기로 표현된 것이 아닙니다 (작은 행성은 볼 수 없겠죠). 이 행성에는 세 개의 중력 작용이 있습니다 (세 개의 별로 인한 것입니다). 그에 따라 행성의 가속은 각속도(ω)와 궤도 거리(r_p)에 따라 달라집니다.

이 위치에서 모든 중력은 가속과 같은 방향에 있으므로, 뉴턴의 제2 법칙에 대한 다음 방정식을 작성할 수 있습니다 (참고: 각 별의 질량은 M이고 행성의 질량은 m입니다).

![image](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_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>

행성의 각 운동 속도는 외부 별 중 하나의 각 운동 속도에서 구할 수 있습니다.

![image](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_9.png)

이제 행성 트리솔라리스의 공전 거리 (r_p)를 구하는 것은 여전히 어려운 방정식으로 보입니다. 괜찮아요. 실제로 이 방정식을 풀 필요는 없어요. 숫자적 해법을 찾을 수 있으며, r_p의 다른 값에 대해 방정식의 좌변과 우변의 값을 구하여 해의 값을 찾을 수 있어요. 이 두 변을 그래프로 그리면 교차하는 지점이 해를 주는 r_p의 숫자 값이 될 거에요. 한 번 확인해보세요.

![image](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_10.png)


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

스케일 조정을 해 보면서, 행성 공전 거리를 0.21065 AU로 결정했어요. 그럼, 그걸로 테스트해 볼게요. 여기 4번째 객체를 넣은 3체 문제 계산 결과입니다.

![image](https://miro.medium.com/v2/resize:fit:1000/1*EHiES60H5-45wmU7IZpYDQ.gif)

별의 회전 운동과 대부분 일치하면서 행성이 이동하는 모습을 보실 수 있어요. 애니메이션 끝 쪽에 조금씩 벗어나는데요 — 근데 괜찮아요. 이 삼중태양 허물기는 어차피 영원히 지속되지 않거든요.

# 삼중태양 허물기 모델링


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_11.png)

좋아요. 우리는 이러한 힘들을 계산할 수 있어요 (일부 가정을 가지고). 지구와 똑같은 행성이라고 가정해 봅시다 (왜냐하면요). 이것은 즉, 사람을 행성으로 당기는 중력 힘이 1킬로그램당 9.8 뉴턴이 될 것이라는 것을 의미해요. 세 개의 별로 인한 순박한 힘으로 인한 순박한 힘의 경우, 1.5 N/kg 정도일 것입니다 - 9.8 N/kg 보다 작아요. 네, 이것이 삼합운 돌아가는 내 특정 값에 대한 값이에요.

그런데 기다려 주세요! 중력 힘의 이 차이로 실제로는 당신이 트리솔라리스의 표면에서 더 가벼워진다는 느낌을 받지 못할 거예요. 왜냐하면요? 그것은 행성이 정지해 있지 않기 때문에 그렇습니다 - 사실 행성은 이미 원형 운동으로 움직이고 있기 때문에 별들 쪽으로 가속하고 있어요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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개인 라인의 누적 효과를 계산할 수 있어요. 하지만 약간의 잡수작을 필요로 할 거예요. 3개의 별과 중력 상호작용은 행성에 힘을 가해 가속시키는데, 이는 행성의 중심에서의 가속임을 명심해야 해요. 표면에 있는 비인간은 행성 중심에서의 가속도 값을 가질 것인데, 별들에 더 가까운 지점에서의 중력 힘을 받게 될 거예요. 네, 조금 복잡한 일이죠.

트리솔라리스 표면의 겉으로 보이는 중력 힘은 행성의 중심에서의 중력장과 표면에서의 차이로 나타날 거예요. 행성의 반지름이 6.3 x 10⁶ 미터인 것으로 가정해봅시다 (지구와 같다 가정). 그 경우, 별들에서 오는 유효한 힘은 1kg 당 0.00074 뉴턴을 향해 당겨주게 될 거예요.

그러니까, 질량이 70kg인 생명체는 보통 686 뉴턴의 무게를 느낄 수 있을 텐데요 — 그러나 세 개의 별이 일렬로 위치할 때 그들은 685.99 뉴턴만 느낄 거예요. 만약 숫자에 좀 미숙하다면, 그것은 무게 차이가 크지 않다는 거죠.

이제 맞추세요! 만약 한 사람 (실제 사람이 아닌)이 행성의 반대편에 있다면, 그들도 역시 겉으로 보이는 무게가 더 낮게 느껴질 거예요. 이 경우에 별들로부터의 중력 힘은 조금 더 낮아지겠지만, 행성의 중심의 가속도는 그들에게 지속적으로 멀어지는 것처럼 보일 거예요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이야기 한 번 더 들려줄게요. 정확히 여러분이 지구에 두 개의 조수가 있는 이유입니다. 그 이유는 달로부터 오는 중력에 의한 가속이 지구의 중심에서 발생하기 때문입니다. 지구의 중심에서의 가속은 지구 표면에서의 달로부터 오는 중력과는 다릅니다. 이러한 차이로 인해 물이 두 군데에서 풍겨져 두 개의 물 축적이 발생하는 것이죠. 여기 지구의 표면 가속과 실제 중력장 사이의 차이를 시각화한 그림이 있어요.

![Earth Visualization](/TIL/assets/img/2024-07-14-PhysicsoftheTri-SolarSyzygyfromThe3BodyProblemCouldPeopleReallyBePulledOffaPlanet_12.png)

만약 이 이미지를 생성하는 과정의 자세한 내용을 보고 싶다면, 전부 제공해 드리겠습니다.

그러면, 여기 주의! "3체 문제"는 넷플릭스 쇼로 제작된 책일 뿐이에요. 실제로는 존재하지 않습니다. 물리학이 완벽하진 않아도 괜찮아요. 물론, 행성의 크기나 궤도를 변경하면 효과적인 힘을 더 크게 얻을 수도 있겠지만, 제가 설정한 값들이 합리적으로 보인다고 생각해요.

삼체 문제의 트리플 별 직렬 현상 물리학 실제로 사람이 행성에서 끌려갈 수 있을까

자동 ARIMA 모델 사용 방법

![Image](/TIL/assets/img/2024-07-14-CrackingtheCodeHowSeniorDevsTackleProgrammingChallenges_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>

놀랍게도, 코딩을 하는 것이 프로그래밍 중에서 가장 어려운 부분은 아닙니다. 표면적으로 보면 프로그래밍은 간단해 보일 수 있지만, 컴퓨터가 이해할 수 있는 코드를 작성하는 것이랍니다.

하지만, 현실은 훨씬 더 복잡해요. 프로그래밍은 논리적 사고, 문제 해결 능력, 그리고 다루고 있는 문제와 도구에 대한 심층적인 이해를 필요로 합니다.

# 프로그래밍 마인드셋의 중요성

많은 초보자들은 프로그래밍의 핵심 부분을 배워야 합니다: 마인드셋입니다. 개발자처럼 생각하는 것이, 특히 초보자들에겐 프로그래밍을 어렵게 만드는 이유입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

코드를 작성하는 것 뿐만 아니라 문제해결 방식에 대해서도 중요해요. 일주일만에 JavaScript를 배운다는 것은 가능해 보일 수 있지만, 내부에 숨어있는 사회불안증(imposter syndrome), 늦은 밤 코딩 세션, 포기하고 싶은 순간들은 언급되지 않죠.

이러한 경험들은 튜토리얼이나 책에서 소개되는 것이 아니라, 실제로 체험해봐야 합니다.

# 프로그래밍에서의 개발자 마인드셋

# 요리 비유


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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이나 JavaScript와 같은 프로그래밍 언어를 알아간다는 것도 레시피를 암기하는 것과 비슷합니다.

모든 문법을 알아도, 더 중요한 질문은: 어떻게 효과적으로 활용할 수 있는지 아는지인 거죠?


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 예시: 프로그래밍에서 평균 계산하기

다음 예시를 살펴보세요: 변수, 반복문, 그리고 리스트가 어떻게 동작하는지 배웠습니다. 숫자들의 리스트를 생성하고 for 루프를 사용하여 각 숫자를 출력할 수 있습니다.

이제 이 숫자들의 평균을 찾아야하지만 sum 함수를 사용하지 않습니다. 이를 위해서는 sum 함수가 하는 일을 이해해야 합니다: 모든 요소를 모두 더합니다.

튜토리얼에서 얻는 기본 지식을 활용하여 for 루프를 사용하여 리스트를 순회하고 필요한 산술 연산을 수행할 수 있습니다. 이 예시는 튜토리얼이 기본을 가르쳐주지만 문제를 해결하기 위해 창의적으로 적용해야 함을 보여줍니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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>

이 기술은 실제로 가르쳐 주기 어려울 뿐만 아니라 자신으로 찾아내야 합니다.

# 프로그래밍의 고통

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

프로그래밍의 학습 곡선은 가파릅니다. 튜토리얼과 실무 경험을 균형있게 조합해야하기 때문이죠. 튜토리얼은 자전거 지지 바와 같아요. 결국 필요 없어질 거예요.

진정한 학습은 배운 것을 다양한 상황에 적용하기 시작할 때 시작됩니다.

# 프로그래머의 마인드셋을 갖추는 팁

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

프로그래밍 문제를 작은 관리 가능한 작업으로 나누어 시작해보세요. 이 방법을 사용하면 가장 어려운 문제조차 접근 가능해 보이고 명확한 시작점을 제공받게 될 거예요.

예를 들어, 리스트에서 가장 많이 나타나는 상위 세 개의 단어를 추적하고 표시하는 프로그램을 작성해야 한다면 다음과 같이 나눠보세요:

- 먼저, 리스트를 살펴보세요.
- 그 다음, 각 단어의 빈도수를 세어보세요.
- 마지막으로, 상위 세 개의 가장 많이 나타나는 단어를 결정하세요.

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

프로그래밍의 프로젝트 기반 학습(PBL)은 기술 향상과 문제 해결 능력 향상에 중요합니다.

실전 프로젝트를 통해 이론적 지식을 실제 응용에 적용하여 심층적인 이해와 실무 전문성을 키울 수 있습니다. 이 반복적인 과정은 프로그래밍 능력을 향상시키는 것뿐만 아니라 개발자에게 필수적인 비판적 사고와 창의성을 육성하는 데 도움이 됩니다.

각 완료된 프로젝트는 포트폴리오에 기여하여 여러분의 역량을 과시하고 잠재적인 고용주들에게 매력을 늘려줍니다.

이 접근 방식은 여러분의 기술을 향상시키는 것뿐만 아니라 취업 기회를 열어줍니다. 왜냐하면 고용주들은 실무 경험을 입증한 후보자와 성공적인 프로젝트 완료 이력이 있는 지원자를 가치 있게 여기기 때문입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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. 프로그래밍을 위한 파인만 기법

이 기법은 당신이 개념을 정말로 이해했다고 할 수 있는 것은 그것을 간단한 용어로 설명할 수 있는 경우에만 가능하다는 아이디어에 기반을 두고 있습니다.

이 기법은 복잡한 프로그래밍 개념을 기초적인 부분으로 나누어야 한다는 것을 강요하여 당신이 이해한 것과 더 많은 공부가 필요한 부분을 드러내게 합니다.

어떤 사람에게 개념을 가르치거나 설명하거나, 혹은 혼자 소리 내어 스스로에게 설명하는 것은 당신의 이해를 확고하게 하고 보다 더 기억력을 향상시킵니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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. 프로그래밍에서 실패를 수용하세요

프로그래밍에서는 실패를 학습 과정의 일부로 받아들이는 것이 중요합니다. 만난 모든 오류와 버그는 소중한 교훈을 제공하며 문제 해결 능력을 향상시키고 이해를 깊이 있게 합니다.

이러한 저하를 수용함으로써 탄력성을 육성하고 개선에 대한 적극적인 접근 방식을 취할 수 있습니다.

실패를 분석함으로써 개발자들은 코딩 관행을 개선하고 향후 동일한 문제가 발생하는 것을 방지하는 통찰을 얻을 수 있습니다. 이러한 마음가짐 변화는 프로그래밍 노력에서 지속적인 성장과 혁신을 촉진합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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. 프로그래밍을 꾸준히 연습하세요

연습을 꾸준히 이어나가세요. 한 번에 1시간 이상 같은 주제나 프로젝트에 집중하는 것이 좋습니다. 짧은 연습 시간은 작은 문제에 유용할 수 있지만, 보다 깊은 이해를 위해서는 더 오래 집중해야 합니다.

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

이 팁을 따라가고 계속 도전함으로써, 당신은 성공한 프로그래머가 되기 위해 필요한 마인드를 개발할 수 있을 것입니다. 앞으로 나아가며 계속 배우고, 필요할 때 프로그래밍 커뮤니티에서 도움을 요청하는 것을 주저하지 마세요. 즐거운 코딩하세요!

이 글이 마음에 들었다면 👏 를 클릭해주세요! 제 계정을 팔로우해주시면 감사하겠습니다! 즐겨 보는 부분을 강조하셔도 됩니다. 여러분의 참여가 제 영감입니다!

Posts