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

의미 검색이 자연어 강점을 강조하며 주목을 받는 동안, 클래식 키워드 검색은 여전히 가치 있는 도구로 남아 있습니다. Retrieval Augmented Generation이 유명해지거나, 때로는 사용자 의도가 분명하지 않을 수 있기 때문일지도 모릅니다. 이유가 무엇이든 의미 검색만이 인기 있는 주제인 것 같습니다.

정말 그게 그렇게 필요한가요? 모든 시간에 복잡한 검색이 필요한가요?

# 의미 검색과 키워드 검색의 차이점은 무엇인가요?



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

먼저 몇 가지 간단한 정의들을 살펴봐요.

키워드 검색(Keyword Search): 데이터 내에서 특정 키워드나 구에서의 정확한 존재에 의존하는 리터럴 일치 기반 시스템.

의미 검색(Semantic Search): 질의의 의미와 의도를 이해하려고 하는 보다 정교한 방법으로, 단어와 개념 간의 맥락과 관계를 고려합니다.

그래서 의미 검색과 키워드 검색의 주요 차이는 의미 검색이 검색 용어 뒤의 맥락과 의도에 초점을 맞추는 데 반해, 키워드 검색은 검색에 사용된 키워드에 기반하여 검색 기록을 일치시킨다는 것이에요.


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

# also a keyword search is all you need

“올드 스쿨” 방식인 키워드 검색이 빛을 발하는 시나리오를 살펴봅시다. 그리고 어떤 유형의 데이터에서 빛을 발하는지 알아봅시다.

1. 정밀함이 최고입니다: 클래식 키워드 검색은 정확히 무엇을 찾고 있는지 알 때 매우 명확한 결과를 제공합니다. 특정 문서 제목이나 정확한 구절이 필요한가요? 적절한 키워드를 목걸이처럼 연결하여 정확성을 확보할 수 있습니다.

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. **속도 악당**: 직접적인 매칭에 의존하기 때문에 클래식 검색 알고리즘은 쿼리를 더 빨리 처리합니다. 이 효율성은 과학 데이터베이스나 금융 거래 플랫폼과 같이 실시간 응답을 필요로 하는 대규모 데이터 세트나 응용 프로그램에 중요합니다.

4. **당신의 통제**: 검색어를 지정하여 예상치 못한 결과에 대한 여지를 남기지 않습니다. 데이터베이스를 키워드로 풍부하게 하는 경우, 검색 기준을 더욱 좁혀 설정할 수 있습니다. 이 통제는 규정 준수나 브랜드 안전 검사와 같이 특정 기준을 엄수해야 하는 작업에 가치가 있습니다.

![Image](/TIL/assets/img/2024-07-12-Maybekeywordsearchisallyouneed_1.png)

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>

6. 친숙한 친구: 전통적인 검색 방법에 익숙한 사용자들에게는 클래식한 접근 방식이 편안한 인터페이스를 제공합니다. 그들은 게임의 규칙을 이해하므로 학습 곡선 없이 필요한 것을 쉽게 찾을 수 있습니다.

7. 비용 효율적인 옵션: 클래식한 검색 인프라를 구현하고 유지하는 데는 의미론적 대응물에 비해 더 적은 계산 성능과 자원이 필요합니다. 이는 작은 조직이나 복잡하지 않은 검색 요구 사항을 가진 애플리케이션에게 예산 친화적인 솔루션이 됩니다.

# 컨셉 증명 — 나의 기사들을 키워드 검색하기

그래서 나는 직접 테스트해 보기로 결정했습니다!


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

100개의 미디엄 기사를 텍스트 파일로 저장하고 데이터베이스를 구축하기 시작했어요. 목표는(참 간단해 보일 수 있지만...) 내 기사들의 모든 키워드를 안내해주는 검색 창을 갖는 것이에요.

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

# 어려움

먼저 필요한 db의 종류를 결정해야 했어요. 이건 간단한 검색이니까 전통적인 데이터베이스가 적당할 거 같아요. 저는 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>

두 번째로 고려해야 할 사항은 데이터베이스 내의 관계입니다: 키워드를 검색하고 쿼리와 일치하는 텍스트 청크를 반환하고 싶습니다. 그러나 동일한 키워드가 매우 동일한 청크를 반환하면 해당 청크 중 하나만 원합니다. 이해를 돕기 위해 설명드리겠습니다:

저의 기사 'Hugging Face로 LLM을 통한 히치하이커 안내서'에는 많은 청크가 있고, 각각에는 3개 또는 4개의 키워드(예: hitchhiker, llm, guide, ai)가 있습니다.

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

첫 두 hits에서 청크가 동일하지만 다른 키워드를 가리키는 것을 볼 수 있습니다. 실제로 쿼리에서 요청한 것과 일치합니다. 동일한 적용은 세 번째와 네 번째 태그(키워드)에도 적용되며 동일한 문서 청크가 반환됩니다.


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

우리는 결과를 유일하게 유지하고 싶어해요 (이미 언급된 청크가 있으면 그 중 하나만 남겨둡니다).

# 데이터 준비 방법

데이터 수집 및 처리가 이 작업의 주요 관점입니다. 좋은 점은 우리가 풍부해질 때 필요한 단계를 사용하여 RAG 전략도 향상할 수 있다는 것입니다.

데이터 수집 중 (우리의 기사들) 우리는 사용자 지정 청크로 나누고, LangChain 문서 형식으로 저장하기 전에 그 특정 청크의 키워드를 추출하기 위해 KeyBERT (이 매우 빠릅니다)를 실행합니다.


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

그런 다음 키워드도 메타데이터로 추가합니다.

다음 단계는 데이터베이스를 생성하는 것입니다: 관계형 데이터베이스가 아니기 때문에, 각 청크마다 키워드 하나 당 레코드를 갖기를 원합니다.

허들 섹션으로 돌아가 볼까요: 같은 예제를 사용하면, 기사 "A Hitchhiker Guide to LLM with Hugging Face"의 첫 번째 청크에는 4개의 키워드가 있습니다 (예: hitchhiker, llm, guide, ai). 데이터베이스에는 이 청크에 대해 4개의 항목이 있어야 합니다. 즉, 하나는 hitchhiker, 하나는 llm, 하나는 guide, 그리고 마지막으로 ai에 대한 항목이 있어야 합니다.

데이터베이스가 엄청나게 커질 거에요!!! 하지만 누가 신경을 쓰겠어요? 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>

# 그래픽 인터페이스

정말 간단해야 해요.

검색을 간소화하기 위해 Streamlit에서 multiselect 라는 특별한 위젯을 사용할 거에요. 이 위젯은 가능한 선택 사항 목록을 전달할 수 있는 화제적인 대화형 입력 위젯으로, 여러 개를 선택할 수 있고, 또한 타이핑을 시작하면 기존 목록에서 일치하는 항목이 나타나요.

그래서 중요한 작업 중 하나는 db에서 모든 키워드 태그를 추출하고, 중복을 제거하는 거에요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
st.session_state.kwcollection = st.session_state.df['tag'].unique()
```

다중 선택 객체는 파이썬 리스트를 반환합니다. 이것은 매우 좋은데, pandas 데이터프레임을 .isin() 메서드로 필터링할 수 있기 때문입니다.

```js
dfsearch1 = st.session_state.df[st.session_state.df['tag'].isin(kw)]
```

여기서 kw는 다중 선택 객체에서 얻은 파이썬 리스트이며, st.session_state.df는 세션 상태 객체에 저장된 데이터프레임입니다. 이렇게 함으로써 전역 변수로 사용되며 Streamlit이 재 실행될 때마다 변경되지 않습니다.


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

세세한 질문이나 다양한 관점을 탐구하려면, 의미론적 검색은 명백한 장점을 제공합니다.

그러나 정밀도, 속도, 통제 및 익숙함이 중요할 때는, 특히 잘 구조화된 데이터와 함께 사용될 때, 이 검증된 방법은 올바른 사람의 손에 강력한 도구로 남아 있습니다.

이 기사를 즐겨보셨으면 좋겠습니다. 만약 이 이야기가 가치를 제공했고 조금이라도 지원하고 싶다면 다음을 해볼 수 있습니다:

- 이 이야기에 대해 많이 클랩하기
- 기억하기에 더 적합한 부분을 강조하기 (나중에 찾기 쉽고, 나는 더 나은 기사를 쓸 수 있습니다)
- 자체 인공지능 구축 방법을 배우려면 이 무료 eBook 다운로드하기
- 나의 링크를 사용하여 미디엄 멤버십 가입하기 (매월 $5로 무제한 미디엄 이야기 읽기)
- 미디엄에서 나를 팔로우하기
- 내 최신 기사 읽기 https://medium.com/@fabio.matricardi


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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의 Boost / AI 라이프 해킹 / 무료 GPT 대안 / AI 아트

키워드 검색이 모든 것을 해결해줄까

<img src="/TIL/assets/img/2024-07-12-5PythonCodingErrorsThatAreKillingYourSpeedAndHowtoFixThemToday_0.png" />

안녕하세요, 파이썬 개발자 여러분! 저는 구글 출신인 다니엘입니다. 현재는 Django를 사용하여 웹 애플리케이션을 개발하고 파이썬에 대한 집착을 키우는 데 시간을 할애하고 있습니다. 저는 주말에는 Medium에서 활발하게 활동하며 시간이 흐른 만큼 축적한 가치 있는 통찰을 전달하고, 여러분을 프로그래밍 대가로 변신시키기 위해 노력하고 있습니다.

솔직히 말해서, 무력한 거북이 속도로 작동하는 파이썬 스크립트로 인한 특정 유형의 좌절감이 있죠. 웹 사이트가 느려 보이거나 데이터 분석 업무가 몇 시간 동안 계속되는 경우든, 느린 코드는 모든 관련자들에게 나쁜 경험을 안겨주며 프로젝트의 성과를 위협할 수도 있습니다.

하지만 걱정하지 마세요! 이 글에서는 제가 보고(심지어 제가 직접 한 것) 온갖 성능 저하 요인을 분석해 보여드릴 것입니다. 그리고 어떤 것을 하지 말아야 하는지뿐만 아니라, 실제 해결책과 코드 예제를 제공하여 여러분의 스크립트를 부드럽고 강력한 파이썬 기계로 만들어 줄 겁니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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: 1999년처럼 루핑하기

알다시피, 제가 다른 개발자들처럼 잘 만들어진 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>

```js
numbers = [1, 2, 3, 4, 5, ... , 10000]  # A big list
total = 0
for number in numbers:
    squared = number * number
    total += squared
```

이렇게 해도 괜찮아 보이지만 실제로는 Python이 각 요소마다 많은 개별 계산을 수행하고 있습니다.

## 해결책: NumPy가 구해줄게요!

이것이 NumPy가 슈퍼히어로처럼 나타나는 곳입니다. 이것은 벡터화에 관한 모든 것입니다 — 한 번에 전체 배열에 대한 연산 수행하기. 그 예시를 다시 써보겠습니다:


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

```python
import numpy as np

numbers = np.array([1, 2, 3, 4, 5, ... , 10000])  
squared = numbers * numbers  # Vectorized squaring!
total = squared.sum()
```

Boom! Instead of processing element by element, NumPy takes care of the entire calculation in one go.

## Bonus: The Comprehensible Compromise

List comprehensions are like the stealthy middle ground:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
total = sum(number * number for number in numbers)
```

일반적인 루프보다 빠르지만, 강력한 숫자 계산을 위한 NumPy만큼의 세기는 아닐 수 있습니다.

# 실수 #2: 잘못된 도구 선택

망치 하나만으로 집을 짓는다고 상상해보세요. 집을 완성할 수는 있지만, 정말 혼란스러울 것입니다. 마찬가지로, Python에서 모든 작업에 대해 리스트만을 의존하는 것은 등이 뒤로 돌아가있는 채 프로그래밍하는 것과 같습니다.


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

## 예시: 내 전화번호는 어디에?

만약 다음과 같이 연락처 목록이 있다면:

```js
contacts = [
    {"name": "Alice", "phone": "123-4567"},
    {"name": "Bob", "phone": "789-0123"},
    # ... 추가 연락처
]
```

Bob의 전화번호를 찾으려면 목록을 훑어봐야 합니다. 모든 연락처를 확인해야 할 수도 있어요! 어떡하지?


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

## 문제 해결: 초능력을 지닌 데이터 구조들

- Dictionaries: 키를 이용한 신속한 검색 파트너 키(예: "이름")로 검색하는 경우, 사전이 당신의 신뢰할 수 있는 도우미가 될 것입니다.

```js
contacts_dict = {
    "Alice": "123-4567",
    "Bob": "789-0123",
    # ... 더 많은 연락처
}
bobs_number = contacts_dict["Bob"]  # 즉시 접근!
```

- Sets: 고유성 강제하기 고유한 웹사이트 방문자들을 추적해야 하는가요? Set은 중복을 자동으로 제거합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
unique_visitors = set()
unique_visitors.add("192.168.1.100")
unique_visitors.add("124.58.23.5")
unique_visitors.add("192.168.1.100")  # No duplicate added
```

파이썬 노하우 도구로는 순서가 있는 딕셔너리, 특별 큐를 위한 데크 등이 준비되어 있어요. 이 도구를 언제 사용해야 하는지 알아두면 좋은 스크립트와 훌륭한 스크립트를 구분할 수 있어요.

# 실수 #3: 어둠 속에서 최적화하기

코드가 느릴 것 같은 느낌을 익히 알고 계실 거예요. 그런데 그 이유가 왜 그런지는 모르겠다고요. 토치(Torch) 없이 누수하는 천장을 고치는 것과 유사합니다. 화가 난답니다! 여기서 프로파일러(Profiler)가 등장합니다.



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

## 예시: 예상하지 못한 범인

가정해 봅시다. 피보나치 수를 계산하는 복잡한 함수가 있다고 상상해 보세요. 수학을 정밀하게 다듬기 위해 많은 노력을 기울였지만 여전히 속도가 느립니다. 결과를 파일에 기록하는 방식이 마치 은밀한 것처럼 작용하는 것이 병목일 수도 있습니다.

## 해결책: cProfile이 구원해줍니다!

Python의 내장 cProfile 모듈이 성능 탐지 요원이 됩니다. 다음은 그 사용법입니다:


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

```python
import cProfile

def my_function():
    # 프로파일링할 코드 입력

cProfile.run('my_function()')
```

이 코드는 여러 가지 통계를 생성합니다. 주요 확인 사항은 다음과 같습니다:

- ncalls: 함수가 호출된 횟수.
- tottime: 함수 내에서 총 소요된 시간.
- cumtime: tottime과 유사하지만 해당 함수 내에서 호출된 모든 함수에서 소요된 시간을 포함합니다.

단서를 통해 정보 확인하기 위해 이러한 숫자들은 실제 병목 현상을 찾아내는 데 도움이 됩니다. 최적화 노력을 가장 큰 영향을 줄 수 있는 곳에 집중할 수 있도록 도와줍니다.


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

여기 뭐든지 처음부터 만드는 충동이 강하죠. 이해해요! 하지만 때로는 발명의 바퀴를 다시 만드는 것은 비행기에 타지 않고 나라를 걸어 다니기로 결정하는 것과 같아요. Python은 극도로 최적화된 내장 함수로 여러분을 지원해줄 거예요.

## 예시: 정렬해봅시다

숫자 목록을 정렬해야 하나요? 버블 정렬을 구현해 볼 수도 있지만... Python의 sorted()를 사용해보는 것은 어떨까요?


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
my_list = [5, 3, 1, 4, 2]

# The long way (probably pretty slow)
def my_bubble_sort(list): 
   # ... your sorting code here

# The Pythonic way
sorted_list = sorted(my_list)
```

아마도 사용자 정의 정렬 알고리즘은 내장 알고리즘의 효율성에 거의 미치지 못할 것입니다.

문제 해결법: 보물 창고를 발견하세요

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>

- itertools: 이터레이터 작업을 강화해주는 모듈 (효율적인 반복문을 위한 상급 루프라고 생각해보세요)
- heapq: 힙(heap)을 관리하기 위한 모듈 (우선순위 큐에 관심 있으신가요?)
- bisect: 정렬된 리스트를 유지하고 빠르게 동작하는 모듈

기억해주세요: 내장 함수를 배우는 데 시간을 투자하면 나중에 최적화하는 데 시간을 절약할 수 있습니다.

# 실수 #5: 하드 드라이브와 너무 많이 대화하기

컴퓨터의 메모리(RAM)를 초고속 작업 영역, 하드 디스크를 도시 반대편에 있는 저장 창고로 생각해보세요. 파일에 접근하거나 수정할 때마다 전달원을 왕복하도록 하는 것과 같습니다. 너무 많은 왕복으로 코드가 대기하는 것처럼 느껴지기 시작합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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("huge_log.txt", "r") as file:
    for line in file:
        # 각 라인을 천천히 처리합니다
```

각 라인을 읽을 때마다 하드 드라이브에서 별도의 가져오기가 필요합니다. 아야!


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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("huge_log.txt", "r") as file:
    contents = file.read() 
    # 메모리에서 내용 처리
```

- 버퍼링으로 구조화: 세밀한 제어가 필요할 때, 버퍼링이 도움이 됩니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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("huge_log.txt", "r") as file:
    while True:
        chunk = file.read(4096)  # Read in chunks
        if not chunk:
            break
        # Process the chunk
```

블록으로 생각하라, 바이트로는 아니다. "창고"로의 왔다갔다를 최소화하면 굉장한 영향을 미친다.

# 결론: 파이썬에 올인하세요!

자, 이제 우리의 속도 저하는 원인을 다시 한 번 요약해 봅시다:


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

- 루프 과부화: NumPy로 벡터화를 활용해보세요.
- 잘못된 도구: 룩업에는 사전, 고유성에는 세트... 현명하게 선택하세요!
- 맹목적 최적화: 실제 병목 현상을 확인하기 위해 cProfile로 프로파일링하세요.
- 직접 만들기 열풍: Python의 내장 함수들은 여러분의 친구입니다. 활용하세요!
- 디스크 부하 너무 많이: 전략적으로 읽고 현명하게 버퍼링하세요.

성능은 일회성 수정이 아닙니다. 이것을 마라톤 훈련처럼 생각해보세요: 코드를 프로파일링하고 핫 스팟을 최적화한 뒤, 이 과정을 반복하세요. 곧 여러분은 치타처럼 우아하게 실행되는 Python 스크립트를 가지게 될 것입니다.

## 행동 요구

이것을 실천하실 준비가 되셨나요? 여러분의 코드에서 이러한 실수를 찾아보세요! 여러분이 얻는 속도 향상에 대한 소식을 듣고 싶습니다. 결과를 댓글로 공유해주세요. 함께 최적화를 축하해봐요!


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

## 더 알고 싶나요?

만약 이 내용이 도움이 되었다면, 더 많은 Python 팁과 트릭을 보기 위해 제 Medium을 팔로우해주세요. 좋은 리뷰는 언제나 환영이에요 😉. 그리고, 컨텐츠를 좋아하신다면, Patreon에 가입하여 독점 혜택을 받거나, 제가 Python에 대해 종일 이야기를 나누는 Discord 커뮤니티에 가입해보세요.

## 즐거운 코딩되세요!

# 쉽게 이해할 수 있는 English 🚀


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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에서 더 많은 콘텐츠 확인 가능합니다

파이썬 속도를 떨어뜨리는 다섯 가지 코딩 실수 및 오늘 해결하는 방법

FinalMLP 추천 시스템을 위한 간단하지만 강력한 Two-Stream MLP 모델 사용 방법

# 거리 측정이란 무엇인가요?

아마도 맨해튼 거리 또는 유클리드 거리에 대해 들어보았을 것입니다. 이들은 두 주어진 데이터 포인트가 얼마나 멀리 떨어져 있는지 (또는 얼마나 다른지)에 대한 정보를 제공하는 두 가지 다른 측정 기준입니다.

![image](/TIL/assets/img/2024-07-12-GowersDistanceforMixedCategoricalandNumericalData_0.png)

간단히 말해서, 유클리드 거리는 점 A에서 점 B까지의 최단 거리입니다. 맨해튼 거리는 x와 y 좌표 간의 절대적인 차이들의 합을 계산하고, 대각선 방향으로 움직일 수 없고 위, 아래, 왼쪽 또는 오른쪽으로만 이동할 수 있는 격자 상에 위치한 것처럼 두 점 사이의 거리를 찾습니다.


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

거리 측정 항목은 종종 k-평균 클러스터링과 같은 클러스터링 알고리즘의 기초를 이룹니다. 이 알고리즘은 유클리드 거리를 사용합니다. 데이터 포인트 간의 유사성 또는 차이를 먼저 알아야 하므로 이 점이 타당합니다.

## 2점 사이의 거리 계산하기

이 프로세스를 보여주기 위해 유클리드 거리를 사용한 예제를 통해 시작하겠습니다.

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

위에 그린 차트를 사용하면 점 A의 좌표가 (50,50)이고 점 B의 좌표가 (300,500)이라고 가정해 봅시다:

```js
d(A,B) = sqrt ((300-50)^2 + (500-50)^2))
d(A,B) = sqrt (62,500 + 202,500)
d(A,B) ≈ 514.78
```

정말 간단하죠. 이제 Python 데이터 세트에서 데이터프레임을 사용하여 2개의 데이터 포인트(행) 사이에 유사도 점수를 계산하고 싶다면 어떻게 해야 할지 살펴봅시다.

## 인구 조사 데이터에서의 거리 (Distances in Census Income data)


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

앞으로 제 모든 예시를 설명하는 데에 UCI Machine Learning Repository에서 제공하는 인구 조사 소득 데이터 세트 (CC BY 4.0)를 사용할 것입니다.

이 데이터 세트는 다양한 인구 특징(나이, 인종, 성별, 직업 등)와 개인이 '$50K 미만' 또는 '$50K 이하'의 소득을 갖고 있는지를 나타내는 바이너리 대상 변수를 가지고 있는 분류 데이터 세트입니다.

이 데이터 세트를 통계 작업에 사용하지는 않겠지만, 유사한 특징을 가진 데이터 포인트 간에는 타겟 변수에 대한 유사성도 보일 수 있기 때문에 거리 측정 지표를 시연하는 데 좋은 예시가 됩니다.

이 데이터를 직접 가져오려면 다음 코드를 실행하세요:


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

# 데이터셋 불러오기
census_income = fetch_ucirepo(id=20)

# 데이터 (판다스 데이터프레임 형태)
X = census_income.data.features
y = census_income.data.targets

# 변수 정보
print(census_income.variables)
```

이 데이터셋에 포함된 특성 변수 중 하나는 "나이(Age)"입니다. 이 경우 나이는 17세에서 90세까지의 숫자 변수입니다. 다른 숫자 변수로는 "자본이득(Capital gains)"이 있습니다. 이 두 변수는 사람의 총 소득과 관련이 깊을 것으로 예상됩니다.

이제 이 두 열을 가지고 데이터 포인트/행에 대한 거리 추정을 얻을 수 있는지 확인해 봅시다.

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

이 두 데이터 포인트 사이의 거리를 찾으려면 위에서 정의한 식에 값을 입력해야 합니다.

각 열은 차원(x 또는 y)이 되고 각 행은 숫자 1 또는 2가 됩니다.

따라서 나이 열은 x가 되고 값(39, 50)은 x1 및 x2가 됩니다. 자본 이득 열은 y1 및 y2 값에 해당합니다.

```js
d(Row1, Row2) = sqrt((50-39)^2 +
(2174-0)^2))

d(Row1, Row2) = 2174.027
```


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

총 이동 거리가 자본 이득 열의 차이와 거의 동일한 것을 알 수 있습니다. 이는 값의 연령 범위가 값의 자본 이익 범위보다 훨씬 작기 때문입니다. 따라서 경우에 따라 유클리드 거리를 계산하기 전에 StandardScaler와 같은 것을 사용하여 데이터를 스케일링해야 할 수도 있습니다.

# Gower 거리: 방정식에 범주형 변수 추가

이제 만약 이 첫 번째 두 데이터 포인트 사이의 거리를 계산하려면 “workclass”와 “education”과 같은 범주형 변수도 포함해서 어떻게 해야 할까요?

여기서 Gower 거리가 중요합니다. Gower 거리는 숫자형 및 범주형 특성에 대해 서로 다른 거리 계산을 수행하여 특성간 유사성의 가중 평균을 취하여 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>

2가지 범주형 특성 간 유사도 점수를 계산할 때, 식은 매우 간단합니다. 값이 동일한 경우 점수는 1입니다. 다른 경우에는 점수가 0입니다.

두 객체(데이터 포인트) i와 j를 비교할 때, 수치/연속적인 특성 k를 비교하는 경우, 유사도 점수는 다음과 같습니다:

\[ \frac{|x_{ik} - x_{jk}|}{R(k)} \]

여기서 R(k)는 특성 k의 범위를 나타냅니다. 값의 차이의 절대값은 범위로 나눠줌으로써 특성을 정규화하고 0과 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>

이제 각 feature에 대한 점수가 있으므로, p개의 feature가 있는 두 개의 객체 i와 j에 대한 전체 Gower 거리가 계산됩니다:


… where w(ijk) is the weight for that feature (Default is 1).


## Python 구현


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

파이썬 구현은 배열 내 모든 객체를 서로 비교하여 Gower 거리를 반환하는 행렬을 생성합니다.

파이썬에서 이 작업이 어떻게 이루어지는지 보시려고 작은 예제를 소개하겠습니다. 그리고 이것이 대규모 데이터셋에서 어떻게 작동하는지 살펴보겠습니다.

```python
# 먼저 "pip install gower"를 실행했다고 가정합니다.
import gower
import numpy as np

# 특성 정의
features = ['age', 'capital-gain', 'education', 'workclass']

# workclass 열에 일부 누락된 데이터가 "?" 형태로 포함되어 있기 때문에
# 이를 먼저 제거했습니다.
X = X.loc[X['workclass']!='?']

# 가능한 다른 열에서는 널 값을 제거하고 인덱스를 재설정했습니다.
X.dropna(inplace=True)
X.reset_index(inplace=True)

# 정의된 특성만 선택합니다.
X = X[features]

# 처음 2개 행만 포함하는 작은 데이터프레임 생성
# 이 두 행을 Gower 거리를 사용하여 비교할 것입니다.
small_X = X.iloc[0:2,:]

# 나이 열을 부동 소수점으로 변환합니다. 왜냐하면 자본 이익은 실수이며,
# 숫자 열은 동일한 데이터 유형이어야 합니다.
small_X['age'] = small_X['age'].astype(float)

# gower 거리 행렬 생성
# cat_features는 각 열의 인덱스에 해당하는 목록입니다.
# 0은 열이 숫자임을 나타내고, 1은 범주형임을 나타냅니다. 처음 2개 열 (나이 및 자본 이익)
# 는 0으로 표시되고, 마지막 2개 열 (교육, 직업)은 1로 표시됩니다.
gower.gower_matrix(np.asarray(small_X),cat_features=[0,0,1,1])
```

gower.gower_matrix를 호출하면 이 배열이 반환됩니다.


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

```js
array([[0. , 1.5],
       [1.5, 0. ]], dtype=float32)
```

각 요소는 다음을 나타냅니다:

- 요소 [0,0] = 행 1과 행 1 간의 거리 점수
- 요소 [0,1] = 행 1과 행 2 간의 거리 점수
- 요소 [1,0] = 행 2와 행 1 간의 거리 점수
- 요소 [1,1] = 행 2와 행 2 간의 거리 점수

행 1을 행 1과 비교하면 features 측면에서 동일함을 보여주기 때문에 거리는 0으로 표시됩니다. 행 2를 행 2와 비교한 결과도 마찬가지입니다. 행 2를 행 1과 비교하면 행 1을 행 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>

이제 Gower 거리의 구성 요소를 이해했으니 전체 데이터 세트에 이 gower.gower_matrix 함수를 적용해 봅시다.

```js
# 참고: 인구조사 데이터 집합은 40,000개 이상의 행이 있습니다. 이 작업은 
# 계산 비용이 매우 높을 수 있습니다. 저는 제 자신의 코드에서 이 작업을 
# 첫 5000개 행에 대해서만 실행했지만, 데이터 세트에 따라 다를 수 있습니다.
gower.gower_matrix(np.asarray(X),cat_features=[0,0,1,1])
```

이렇게 하면 각 행을 모든 다른 행들과 비교한 Gower 거리 점수 행렬이 반환됩니다.

Gower 거리의 효과를 더 테스트하기 위해, 첫 번째 레코드와 가장 유사한 10개 레코드를 해당 특성을 사용하여 찾은 다음, 그들의 대상 값(소득 수준)이 유사한지 확인해 보겠습니다.


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

```js
# 데이터 세트의 첫 번째 행을 가져와 나머지 데이터와 비교합니다. 상위 10개 값의 인덱스를 반환합니다
gower_topn_index = gower.gower_topn(X.iloc[0:1,:], X.iloc[:,], n = 10)['index']

# 원본 df에서 인덱스를 쿼리합니다
X.iloc[gower_topn_index]
```

다음은 제 결과입니다:

<img src="/TIL/assets/img/2024-07-12-GowersDistanceforMixedCategoricalandNumericalData_5.png" />

여기서 첫 번째 레코드와 가장 유사한 레코드는 해당 레코드 자체입니다. 이는 Gower가 각각의 레코드를 모든 레코드와 비교하기 때문입니다. 레코드 1과 가장 유사한 상위 n개의 레코드를 가져오고 레코드 1을 제외한 결과를 얻고 싶다면, 초기에 상위 n+1을 가져와 X.iloc[gower_topn_index][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>

만약 y.loc[gower_topn_index]을 호출하면, 첫 번째 행에 대한 가장 유사한 상위 10개 레코드의 대응하는 타겟 값을 볼 수 있습니다.

![image](/TIL/assets/img/2024-07-12-GowersDistanceforMixedCategoricalandNumericalData_6.png)

여기서 가장 유사한 상위 10개 레코드 중에서 9개 중 6개가 첫 번째 레코드의 수입(≤50K)과 일치했음을 볼 수 있습니다. 9개 중 3개만 일치하지 않고 '50K'를 만들었습니다. 이것은 우리가 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>

다른 기계 학습 알고리즘과 마찬가지로 특성을 추가할수록 Gower metric의 정확도가 높아질 것으로 예상됩니다. 이는 레코드가 더욱 유사해진다는 것을 의미합니다. 이때 주의할 점은 범주형 특성이 종종 (연속 값이 아니라 0 또는 1이 될 것이기 때문에 0과 1 사이의 연속적인 값보다) 수치적 특성보다 더욱 중요하다는 것입니다.

이를 균형있게 유지하기 위해 수치적 특성에 더 높은 가중치를 부여하여 실험할 수 있습니다 (weight 인자를 사용).

weight 인자는 cat_features 인자와 유사하게 작동합니다. 여러분은 목록을 전달하고 각 열에 대해 가중치를 지정합니다. 예를 들어 weight = [2, 2, 1, 1]로 설정하면 수치적인 나이와 자본 이득이 포함된 처음 2개 열이 (마지막 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>

위에서 볼 수 있듯이, 고워 거리는 혼합 데이터 유형의 기능을 포함하는 두 개체 간의 거리를 계산하는 강력한 메트릭입니다. 이는 단순히 가장 유사한 레코드를 찾는 것에서부터 클러스터링 알고리즘에 사용될 때까지 다양한 용도가 있습니다. 더 많은 정보와 예제는 여기에서 찾을 수 있습니다.

## 읽어 주셔서 감사합니다

범주형 및 수치형 데이터를 위한 Gower 거리 설명

가끔은 파이토치(Pytorch)로 고급 색인 및 선택을 해야 할 때가 있습니다. 예를 들어 "텐서 A에서 텐서 B에 지정된 색인을 따라 요소를 선택하는 방법"과 같은 질문에 답변할 수 있습니다.

이 게시물에서는 이러한 작업을 수행하는 가장 일반적인 세 가지 방법인 torch.index_select, torch.gather 및 torch.take를 소개합니다. 우리는 이러한 방법을 자세히 설명하고 서로 비교합니다.

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

솔직히 말해서, 이 게시물의 동기 중 하나는 어떤 기능을 언제 사용해야 하는지를 잊어버려 구글링하거나 스택 오버플로우를 찾아보거나, 내 의견으로는 비교적 간단하고 그리 도움이 되지 않는 공식 설명서를 보는 것 때문입니다. 그래서 여기에서는 언급한 바와 같이 이러한 기능에 대해 심층적으로 알아보겠습니다: 언제 어떻게 사용해야 하는지 동기부여를 해주고, 2D 및 3D에서 예제를 제공하며, 결과적으로 선택된 요소를 그래픽으로 표시할 것입니다.


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

이 게시물이 해당 기능에 대한 명확성을 가져다 주고 추가 탐구가 필요 없도록 도와줄 것을 희망합니다 — 읽어 주셔서 감사합니다!

그리고 이제, 더 이상 어색함 없이 함수를 하나하나 살펴보겠습니다. 먼저, 모든 것을 2D 예제로 시작하여 결과 선택을 시각화한 후, 3D에서 조금 더 복잡한 예제로 넘어갑니다. 그 이후에는 간단한 파이썬에서 실행된 작업을 재구현합니다 — 이를 통해 이러한 함수가 무엇을 하는지에 대한 다른 정보원인 유사한 의사코드를 참고할 수 있게 됩니다. 마지막으로, 함수들과 해당 차이점들을 표로 요약합니다.

# torch.index_select

torch.index_select는 한 차원을 따라 요소를 선택하는 동시에 다른 차원을 유지합니다. 다시 말해, 다른 모든 차원의 모든 요소를 유지한 채 목표 차원에서 인덱스 텐서를 따라 요소를 선택합니다. 우리는 2D 예제로 이를 보여줍니다. 여기서는 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
num_picks = 2

values = torch.rand((len_dim_0, len_dim_1))
indices = torch.randint(0, len_dim_1, size=(num_picks,))
# [len_dim_0, num_picks]
picked = torch.index_select(values, 1, indices)
```

그 결과 텐서는 형태 [len_dim_0, num_picks]를 가집니다: 차원 0을 따라 각 요소에 대해 차원 1에서 동일한 요소를 선택했습니다. 이를 시각화해 봅시다:

![image](/TIL/assets/img/2024-07-12-AdvancedSelectionfromTensorsinPytorch_1.png)

이제 세 가지 차원으로 이동합니다. 이것은 기계 학습 / 데이터 과학의 세계에 더 가까워지며, 형상이 [batch_size, num_elements, num_features]인 텐서를 상상해 보겠습니다. num_elements 요소가 있고 num_feature 특징이 있으며 모든 것이 배치 처리됩니다. torch.index_select를 사용하여 모든 배치 / 특징 조합에 대해 동일한 요소를 선택할 수 있습니다:



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

batch_size = 16
num_elements = 64
num_features = 1024
num_picks = 2

values = torch.rand((batch_size, num_elements, num_features))
indices = torch.randint(0, num_elements, size=(num_picks,))
# [batch_size, num_picks, num_features]
picked = torch.index_select(values, 1, indices)
```

어떤 사람들은 index_select가 하는 일을 코드 형태로 이해하는 것을 선호할 수 있습니다. 따라서, 간단한 for 루프를 사용하여 이 함수를 다시 구현할 수 있는 방법을 설명해 드리겠습니다:

```js
picked_manual = torch.zeros_like(picked)
for i in range(batch_size):
    for j in range(num_picks):
        for k in range(num_features):
            picked_manual[i, j, k] = values[i, indices[j], k]

assert torch.all(torch.eq(picked, picked_manual))
```

# torch.gather



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

다음으로 torch.gather로 이동해 보겠습니다. gather는 index_select와 유사하게 작동하지만 이제 원하는 차원에서 요소 선택이 다른 차원에 따라 종속적입니다. 다시 말해 우리의 머신러닝 예제를 재사용하는 것입니다: 매 batch 인덱스마다, 그리고 매 feature마다, "element" 차원에서 다른 요소를 선택할 수 있습니다. 하나의 텐서에서 다른 텐서의 인덱스를 따르면서 요소를 선택합니다.

ML 프로젝트를 진행하면서 이런 사용 사례를 자주 만나게 되었는데, 하나의 구체적인 예시는 어떤 조건에 따라 트리에서 노드를 선택하고, 각 노드가 일부 feature로 지정된다고 할 때, 배치 차원에 선택할 요소를 넣는 인덱스 선택 행렬을 생성하고 해당 값을 feature 차원을 따라 반복하는 것입니다. 즉, 각 batch 인덱스마다 조건에 따라 다른 요소를 선택할 수 있으며, 우리의 예시에서 이 조건은 배치 인덱스에만 의존하지만 feature 인덱스에도 의존할 수 있습니다.

하지만 먼저, 2D 예제로 다시 시작해 보겠습니다:

```js
num_picks = 2

values = torch.rand((len_dim_0, len_dim_1))
indices = torch.randint(0, len_dim_1, size=(len_dim_0, num_picks))
# [len_dim_0, num_picks]
picked = torch.gather(values, 1, indices)
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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의 각 인덱스마다 차원 1의 다른 요소가 선택된다는 것을 관찰할 수 있습니다:

![image](/TIL/assets/img/2024-07-12-AdvancedSelectionfromTensorsinPytorch_2.png)

이를 바탕으로 세 가지 차원으로 이동하고, 또한 Python 코드를 통해 이 선택을 다시 구현해보겠습니다:

```python
import torch

batch_size = 16
num_elements = 64
num_features = 1024
num_picks = 5
values = torch.rand((batch_size, num_elements, num_features))
indices = torch.randint(0, num_elements, size=(batch_size, num_picks, num_features))
picked = torch.gather(values, 1, indices)

picked_manual = torch.zeros_like(picked)
for i in range(batch_size):
    for j in range(num_picks):
        for k in range(num_features):
            picked_manual[i, j, k] = values[i, indices[i, j, k], k]

assert torch.all(torch.eq(picked, picked_manual))
```


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

## torch.take

torch.take는 소개된 세 가지 기능 중 가장 이해하기 쉬운 것일 수 있습니다. 이 함수는 입력 텐서를 평평하게 취급하고 이 목록에서 요소를 선택합니다. 예를 들어, 입력 텐서의 모양이 [4, 5]이고 인덱스 6과 19를 선택할 때, 우리는 평평한 텐서의 6번째와 19번째 요소를 얻습니다. 즉, 제 2행의 2번째 요소와 맨 마지막 요소를 의미합니다.

2D 예시:

```js
num_picks = 2

values = torch.rand((len_dim_0, len_dim_1))
indices = torch.randint(0, len_dim_0 * len_dim_1, size=(num_picks,))
# [num_picks]
picked = torch.take(values, indices)
```


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

다음은 3D 선택 후 재구현입니다. 인덱스 텐서는 이제 임의의 모양을 가질 수 있으며, 결과 선택은 이 모양으로 제공됩니다:

```python
import torch

batch_size = 16
num_elements = 64
num_features = 1024
num_picks = (2, 5, 3)

values = torch.rand((batch_size, num_elements, num_features))
indices = torch.randint(0, batch_size * num_elements * num_features, size=num_picks)
# [2, 5, 3]
picked = torch.take(values, indices)

picked_manual = torch.zeros(num_picks)
for i in range(num_picks[0]):
    for j in range(num_picks[1]):
        for k in range(num_picks[2]):
            picked_manual[i, j, k] = values.flatten()[indices[i, j, k]]

assert torch.all(torch.eq(picked, picked_manual))
```


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

# 결론

이 게시물에서는 Pytorch에서 세 가지 일반적인 선택 방법인 torch.index_select, torch.gather 및 torch.take을 살펴보았습니다. 이러한 방법을 사용하면 조건에 따라 텐서에서 요소를 선택하거나 색인 할 수 있습니다. 모든 경우에 우리는 간단한 2D 예제로 시작하여 결과 선택을 시각적으로 표현했습니다. 그런 다음, 어느 정도 더 복잡하고 현실적인 3D 시나리오로 이동했습니다. 이 시나리오에서는 [batch_size, num_elements, num_features] 모양의 텐서에서 선택해야 하는 경우가 있습니다. 이는 모든 ML 프로젝트에서 일반적으로 발생할 수 있는 사용 사례입니다.

이 게시물을 마무리하면 이러한 함수들 간의 차이점을 테이블로 요약하고 싶습니다. 이 테이블은 간단한 설명 및 샘플 모양을 포함하며, 샘플 모양은 이전에 언급한 3D ML 예제에 맞게 조정되어 있습니다. 색인 텐서의 필요한 모양과 결과적으로 출력될 모양을 나열할 것입니다:

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

읽어 주셔서 감사합니다!

Pytorch에서 텐서 고급 선택 방법

2024년에 AI 엔지니어링을 시작한다면 이렇게 하세요

![HowToThinkLikeAnAlgebraist](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_0.png)

30년이나 40년 전에 열정적이고 재능 있는 고등학교 수학 학생이었다면, 당신이 교과과정의 일환으로 기초 그룹 이론을 공부했을 확률은 거의 확실했습니다. 안타깝게도 이제는 이러한 경우가 많지 않습니다. 많은 고등학교 교육과정에서 그룹 이론이 제외되었으며, 오늘날 많은 사람들은 수학 관련 학과를 전공할 때 처음으로 마주치게 됩니다.

이 점이 안타깝습니다. 그룹 이론은 대수학자처럼 생각하는 방법에 대한 훌륭한 입문입니다. 이러한 사고 방식을 통해 조직적이고 체계적이게 이산적이고 추상적인 객체를 처리할 수 있으며, 이는 고급 수학을 공부하는 데 필수적인 기술이자 삶 전반에서 극도로 유용한 기술입니다. 이러한 방식으로 생각하는 데는 익숙해지기에 시간이 필요하며, 학교에서 조금이라도 경험이 있는 사람들은 학위 수준에서 수학을 공부할 때 더 빨리 적응할 것입니다.

저는 1988년 케임브리지 대학 입학 시험지에서 이 문제를 발견했으며, 이 문제가 내 주장을 훌륭하게 설명해 주는 사례라고 생각합니다. 만약 이 문제에 대해 적절한 순서와 논리적으로 생각할 수 있다면, 해결책은 깔끔하고 매우 우아할 것입니다. 그러나 대수학자처럼 생각하는 방법에 대한 훈련이 없다면, 이 문제에 대처하는 데 어려움을 겪을 것입니다.


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

문제를 제시하기 전에 옛날에 고등학생들이 배우던 작은 양의 군 이론을 소개해드릴게요 😊

## 그룹이란 무엇인가요?

그룹은 수학에서 보는 일부 공통 구조를 추상화하고 일반화하는 방법입니다. 간단한 예로, 정수 집합을 살펴봅시다. 이 집합에서 덧셈 연산을 살펴보겠습니다. 정수와 이 연산에 대한 몇 가지 특성이 있습니다. 이러한 특성들은 당연하게 여기지만, 그들이 작동하고 유용성과 관련이 있습니다. 여기 몇 가지 특성이 있습니다:

- 정수는 덧셈에 대해 닫혀 있습니다. 즉, 모든 두 정수를 더하면 다른 정수가 나옵니다.
- 정수는 덧셈에 대해 결합적입니다. 즉, 세 개의 정수 a, b 및 c가 있을 때 a + (b + c) = (a + b) + c 가 성립합니다.
- 항등원인 0(영)이 존재합니다. 이 정수는 다른 어떤 정수에 더해져도 같은 정수를 반환합니다. 따라서 모든 정수 a에 대해 a + 0 = 0 + a = a 가 성립합니다.
- 임의의 정수 a에 대해 역원 -a가 존재합니다. 이는 정수와 그 역원을 아무 순서로 더하면 항등원 0이 나온다는 것을 의미합니다. 즉, 모든 정수 a에 대해 a + (-a) = (-a) + a = 0 가 성립합니다.


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

이러한 속성들을 일반 대수 구조를 정의하는 추상화된 개념으로 정의할 수 있습니다.

그룹은 다음과 같은 조건을 만족하는 객체 G로 이루어진 집합과 해당 객체들에 대한 연산인 *을 함께 하는 것으로 정의됩니다:

- g, h가 G에 속한다면 g*h도 G에 속합니다.
- 임의의 g, h, k가 G에 속할 때, g*(h*k) = (g*h)*k가 성립합니다.
- G에는 항등원인 e가 존재하며, 모든 g ∈ G에 대해 g*e = e*g = g가 성립합니다.
- 모든 g ∈ G에 대해 역원 g^(-1)이 존재하며, g * g^(-1) = g^(-1) * g = e가 성립합니다.

그룹이라는 개념은 우리가 일상 생활에서 유용하게 활용하는 수학적 구조를 추상화하는 방법으로 개발되었지만, 이 정의가 소개된 이후 몇 세기 동안, 수학자들은 이러한 속성을 따르며 거대하고 완전히 믿기 어려운 방식으로 유한 그룹을 형성하는 놀라운 구조들을 발견해왔습니다. 예를 들어, 몬스터 그룹은 1970년대에 발견되었으며 808,017,424,794,512,875,886,459,904,961,710,757,005,754,368,000,000,000개의 원소로 구성되어 있습니다.


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

## 문제

여기는 1988년 케임브리지 대학 입시시험의 한 문제입니다. 만약 원하신다면, 제가 풀이를 보여주기 전에 먼저 도전해보세요. 그룹에는 하나의 연산만 정의되어 있기 때문에 그룹에서 대수를 다룰 때 연산 표기를 생략하는 것이 일반적이며 편리합니다. 그렇기 때문에 g*h는 단순히 gh로 쓰이고 g*g는 g²로 쓰입니다.

![Image](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_1.png)

## 나의 풀이 — 파트 (i)


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

우리는 o(g) = n이라고 말을 들었습니다, 따라서 g^k = e인 더 작은 양수 정수 k ` n은 없습니다. 따라서 g^N = e이면 N ≥ n이어야 합니다.

우리는 숫자 N을 N = kn + j로 쓸 수 있습니다. 여기서 k ≥ 1이고 0 ≤ j ` n입니다. 그러면 다음을 말할 수 있습니다.


| g^j      | g^(n+j)     | g^(2n+j)    | ... | g^((k-1)n+j) |
|----------|-------------|--------------|-----|---------------|
| g^0      | g^n         | g^(2n)       | ... | g^((k-1)n)   |


그러나 우리는


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

그리고 0 ≤ j ≤ n이기 때문에 j = 0이어야 합니다. 왜냐하면 o(g) = n이기 때문이죠. 따라서 N = kn이고, 따라서 n은 N으로 나누어집니다.

## 내 해답 — Part (ii)

이 부분이 더욱 명확해지도록 우리의 연산 표기법을 사용해봅시다. 다음과 같이 말할 수 있습니다:



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


![How to think like an algebraist](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_4.png)

With the h element repeated m times. Now note that:

![How to think like an algebraist](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_5.png)

So this means we can make the following replacement:



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

h가 처음과 끝을 포함해 m번 나타납니다. 이제 우리가 이것을 원래 식에 넣으면

\<img src="/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_7.png" />

오른쪽에 m번 반복되어 있습니다. 따라서 필요한 결과를 얻을 수 있습니다.


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

## 나의 해결책 — Part (iii)

주어진 정보를 사용하면:

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

아래와 같이 변경해주셨으면 좋겠습니다.


![HowToThinkLikeAnAlgebraist_9](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_9.png)

아래의 내용대로 수정해 주십시오.

To find o(h), we can use the given fact that g⁵ = e. Consider the following logic:

![HowToThinkLikeAnAlgebraist_10](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_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>

아래와 같이 결과를 사용하여 이를 반복할 수 있습니다. 


![Part(ii)](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_11.png)


유사한 논리를 사용하여 계속하여 이 패턴을 유지하면 다음과 같은 결론을 내릴 수 있습니다: 


![Pattern Logic](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_12.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>

하지만 우리는 g⁵ = e임을 알고 있으므로, 다음과 같이도 말할 수 있습니다:

![image](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_13.png)

따라서:

![image](/TIL/assets/img/2024-07-12-HowToThinkLikeAnAlgebraist_14.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-12-HowToThinkLikeAnAlgebraist_15.png)

이제, Part (i)를 사용하면 h의 순서는 31로 나누어져야 합니다. 그런데 31은 소수입니다. 따라서 o(h) = 31입니다.

그룹 이론에 대한 소개 어땠나요? 자유롭게 의견을 남겨주세요!

대수학자처럼 사고하는 법

<table>
<tr>
  <th>Library</th>
  <th>Purpose</th>
</tr>
<tr>
  <td>Requests</td>
  <td>For sending HTTP requests</td>
</tr>
<tr>
  <td>BeautifulSoup</td>
  <td>For parsing HTML and XML</td>
</tr>
<tr>
  <td>Tkinter</td>
  <td>For building the GUI</td>
</tr>
</table>


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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**: 추출된 데이터를 위한 데이터베이스를 생성하는 데 사용됩니다.
- **Requests**: 웹사이트에 접근 권한을 요청하는 데 사용됩니다.
- **BeautifulSoup**: 웹상에서 데이터를 찾는 데 사용됩니다.

# 작업: 이메일 목록 추출 및 CSV로 변환하기

여러 주제에서 많은 이메일을 가져와야 했습니다.

"수동으로는 절대 할 수 없어" 라고 생각했습니다. 그렇게 하면 시간이 많이 걸리고 지루할 것이라고 생. 따라서 나는 파이썬 기술을 사용하기로 결정했습니다.


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

웹 사이트에는 다음과 같은 데이터가 있습니다:

![Data Table](/TIL/assets/img/2024-07-12-HowToEasilyExtractDataFromAWebsiteWithPython_1.png)

네, 과목 이름과 이메일이 포함된 표가 있습니다.

이 프로젝트의 목표는 이 데이터를 사용하여 CSV 파일을 생성하는 것입니다.


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

# 단계 1. 모듈 가져오기

먼저 사용할 Python 라이브러리를 가져와 봅시다:

- pandas.
- requests.
- BeautifulSoup.

```js
import pandas as pd
import requests
from bs4 import BeautifulSoup
```


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

# 단계 2. 데이터 찾기

## 2.1. 웹 스크래핑은 어떻게 작동되나요?

웹에서 데이터를 추출하는 것이 가능한 이유는 무엇인가요?

답은 HTML(HyperText Markup Language)에 달려 있습니다. HTML은 웹 브라우저에서 표시할 문서의 표준 마크업 언어입니다.


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

웹사이트 어디에서든 마우스 오른쪽 버튼을 클릭하고 Inspect를 선택하면 웹의 코드가 오른쪽에 표시됩니다:

![image](/TIL/assets/img/2024-07-12-HowToEasilyExtractDataFromAWebsiteWithPython_2.png)

파이썬은 (일부 라이브러리와 함께) 이 HTML 코드를 "읽고" 원하는 데이터를 찾는 것입니다.

더 자세한 내용은 향후 기사에서 확인해보세요.


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

## 2.2. HTML 가져오기 함수

우선, 웹 사이트에서 HTML 코드를 가져와야 합니다.

URL을 매개변수로 하는 get_html 함수를 생성하는 방법은 다음과 같습니다:

```js
import pandas as pd
import requests
from bs4 import BeautifulSoup

def get_html(url):

    try:
        response = requests.get(url) # 웹 사이트에서 HTML을 요청합니다
        return response.text

    except Exception as e: # 가능한 오류를 처리하기 위한 예외 처리
        print(f"웹 페이지를 가져오는 데 실패했습니다: {e}")
        return ""emails = set() # 중복을 피하기 위한 코드입니다
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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. 데이터 추출

다음 단계는 우리가 원하는 데이터를 추출하는 것입니다.

우리는 이전 함수에서 HTML 코드를 가져오는 extract_data 함수를 만들 수 있습니다. 이는 다음 단계를 포함합니다:

- BeautifulSoup 클래스 초기화.
- 테이블을 찾는 변수 설정.
- 데이터를 수집할 빈 리스트.
- 데이터를 검색하는 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>

```js
import pandas as pd
import requests
from bs4 import BeautifulSoup

def get_html(url):

    try:
        response = requests.get(url) # 웹사이트로부터 HTML을 요청합니다.
        return response.text

    except Exception as e: # 가능한 오류를 처리하기 위한 부분
        print(f"웹 페이지를 가져오는 데 실패했습니다: {e}")
        return "" # 중복을 피하기 위해 이메일 집합으로 설정

def extract_data(html):

    soup = BeautifulSoup(html, 'html.parser') # BeautifulSoup 클래스를 초기화
    table = soup.find('table') # 테이블을 찾습니다.
    data = [] # 데이터를 수집할 빈 리스트
    
    if table:

        rows = table.find_all('tr') # 모든 테이블을 찾습니다.

        for row in rows[1:]:  # 헤더 행을 건너 뜁니다.
            cols = row.find_all('td') # 테이블에서 셀을 찾습니다.

            if len(cols) == 4:  # 항상 4개의 열이 있다고 가정
                catedra_name = cols[0].text.strip() # 과목 이름
                email = cols[1].text.strip() # 이메일
                data.append({'catedra': catedra_name, 'email': email}) # 데이터 리스트에 추가
    
    return data
```

# 단계 4. 함수 호출 및 데이터 CSV로 저장

이제 모든 준비가 되었으므로 함수를 호출해야 합니다.

```js
import pandas as pd
import requests
from bs4 import BeautifulSoup

def get_html(url):

    try:
        response = requests.get(url) # 웹사이트에서 HTML 가져오기
        return response.text

    except Exception as e: # 가능한 오류 처리
        print(f"웹 페이지를 가져오는 데 실패했습니다: {e}")
        return "" # 중복을 피하기 위해 이메일 집합

def extract_data(html):

    soup = BeautifulSoup(html, 'html.parser') # BeautifulSoup 클래스를 초기화
    table = soup.find('table') # 테이블 찾기
    data = [] # 데이터 수집을 위한 빈 리스트
    
    if table:

        rows = table.find_all('tr') # 모든 테이블 찾기

        for row in rows[1:]:  # 헤더 행 건너 띄기
            cols = row.find_all('td')

            if len(cols) == 4:  # 항상 4개의 열
                catedra_name = cols[0].text.strip() # 과목 이름
                email = cols[1].text.strip() # 이메일
                data.append({'catedra': catedra_name, 'email': email})
    
    return data

url = "https://edipsicouba.net.ar/uncategorized/listado-mails-materias-electivas/"  # 여러분의 링크 설정

html = get_html(url) # get_html() 함수 호출하여 내용을 변수에 저장
data = extract_data(html) # extract_data() 함수 호출하여 결과를 변수에 저장

df = pd.DataFrame(data) # 데이터를 데이터프레임으로 변환
df.to_csv('mail_info.csv', index=False) # 데이터프레임을 CSV 파일로 저장

print("데이터가 성공적으로 추출되어 mail_info.csv로 저장되었습니다")
```


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

그게 다에요!

이렇게 하면 웹사이트의 테이블 안에서 데이터를 수집할 수 있어요.

또한, 이렇게 하면 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>

# 도와드릴 수 있는 방법:

- 새로운 무료 뉴스레터 'The Super Learning Lab'를 구독하세요.
- 곧 무료 학습 이북과 이메일 코스가 출시될 예정입니다!

![HowToEasilyExtractDataFromAWebsiteWithPython_3](/TIL/assets/img/2024-07-12-HowToEasilyExtractDataFromAWebsiteWithPython_3.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>

안녕하세요!

가져와주셔서 감사합니다! 아래는 이번 주 발간물 내용입니다:

- Ultralearning으로 무엇이든 배우기
- 초안 속 9가지 Ultra-learning 원칙
- Ultralearning을 활용하여 2개월 만에 무료로 독일어 배우기
- 학습을 슈퍼파워로 만들기
- 이것을 하지 않고 책을 읽는 것을 그만두세요

만날 날을 기대하며,

Axel

# 간단하고 쉬운 용어로 🚀


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
- 다른 플랫폼 방문하기: CoFeed | Differ
- PlainEnglish.io에서 더 많은 콘텐츠 확인하기

Posts