![Mojo Language](/TIL/assets/img/2024-07-14-AQuickIntroductiontoMojoaSupersetofPythonThatIsSuperFast_0.png)

2023년에 등장한 Mojo라는 새로운 언어가 눈에 띄게 화제가 되었습니다. Swift 프로그래밍 언어의 원조 아키텍트 인 크리스 라트너에 의해 만들어졌습니다. Mojo는 Python의 상위 집합으로 설계되었습니다. 구문은 Python과 매우 유사하여 Python 개발자들에게 매우 친숙합니다.

Mojo는 컴파일 언어이며 Python보다 훨씬 빠릅니다. 특히 ML/AI 관련 계산을 위해 최적화되어 있어 일반 Python 개발자들에게 흥미롭고 도움이 될 수 있습니다.

이 게시물에서는 Mojo의 매우 기본 개념을 소개하고 Python과 비교합니다. Python과 비교했을 때 Mojo의 구문과 효율성에 놀라실 것입니다.



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

## 왜 모조?

Mojo는 현재 AI 회사 모듈러(Modular)에서 개발한 프로프리어터리(소유권이 있는) 프로그래밍 언어로, 복잡성을 제거하고 AI 개발에 유연성과 속도를 더하는 확장 가능하고 통합된 AI 플랫폼을 구축하는 것을 목표로 합니다. 그리고 이 플랫폼을 위해 개발된 새로운 언어인 Mojo는 AI 인프라 확장 및 가속화 문제를 해결하기 위해 개발되었습니다. 이 언어는 현대 CPU 및 GPU를 포함한 이종 하드웨어에 이상적인 컴파일러 인프라인 MLIR로 구축된 첫 번째 프로그래밍 언어입니다. 요약하자면, Mojo는 AI를 위한 새로운 언어입니다.

## Mojo와 Python

Mojo는 Python의 슈퍼셋(또는 고급 버전)으로 디자인되었으며, TypeScript가 JavaScript의 슈퍼셋인 것과 유사합니다. 이것은 JavaScript를 크게 향상시키는 것처럼 Python 개발자들이 Mojo를 시작하는 것이 매우 쉽다는 것을 의미합니다.


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

파이썬은 머신 러닝/인공지능 및 기타 많은 분야에서 주목받는 언어입니다. 특히 데이터 관련 분야에서는 파이썬이 많이 사용됩니다. 그러나 파이썬은 저수준 성능과 동시성을 위한 글로벌 인터프리터 잠금(GIL) 등의 문제가 있습니다. 이러한 문제들은 오랫동안 파이썬 개발자들에게 머리아픈 문제였으며, 사람들이 파이썬이 느리고 동시성이 떨어진다고 말하는 부끄러운 이유입니다. 이는 또한 파이썬 개발을 제한시키는 중요한 사실이며, 이로 인해 파이썬이 모든 핵심 기능이 C와 같은 더 효율적인 컴파일된 언어로 개발된 '접착제 언어'로 끝나게 되었습니다.

Mojo는 파이썬의 인기와 간편함과 C 및 Rust와 같은 컴파일된 언어의 효율성 사이의 간극을 메우기 위해 디자인되었습니다. Mojo는 활발하게 파이썬 커뮤니티를 수용하고, 컴파일 및 메모리 관리와 같은 모든 복잡성을 숨겨 효율적인 코드 실행을 위해 배경에서 발생하는 작업을 쉽고 쉽게 만들려고 노력합니다.

이 게시물에서는 Mojo의 기본 사항을 직접 Python과 비교하여 안내합니다. 변수, 함수 및 구조체와 같은 언어 기본 사항을 소개할 것입니다. 마지막으로, 동일한 코드 조각에 대한 Mojo와 Python의 효율성을 비교하고 Python 코드를 Mojo에서 직접 실행하는 방법을 알려드릴 것입니다. 그러면 이 새로운 언어에 대해 더 나은 이해를 얻을 수 있고, 귀하의 특정 영역에서의 사용 가능성을 확인할 수 있을 것입니다.

## Mojo 설치


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

이 명령어를 사용하여 Linux 컴퓨터에 Mojo를 설치할 수 있어요:

```js
curl https://get.modular.com | sh - && \
modular auth mut_73b76eabd7a04555be4daa751d3e7088

modular install mojo
```

다른 플랫폼에 대한 지침은 여기서 찾을 수 있어요.

설치가 완료되면 콘솔에서 Mojo를 설정하는 지침이 표시될 거예요:


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


![Mojo Introduction 1](/TIL/assets/img/2024-07-14-AQuickIntroductiontoMojoaSupersetofPythonThatIsSuperFast_1.png)

Copy and run the corresponding commands for your shell so you can start using Mojo:

![Mojo Introduction 2](/TIL/assets/img/2024-07-14-AQuickIntroductiontoMojoaSupersetofPythonThatIsSuperFast_2.png)

The `print` command works the same as in Python, and we've just written our first "Hello World" code in Mojo!



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

모조 REPL을 종료하려면 Python의 quit()이나 iPython의 exit과 달리 콜론(:)을 누르고 quit를 입력해야 합니다.

## 변수

Python과 비슷하게, Mojo에서도 이름과 값을 가진 변수를 만들 수 있습니다:

```js
  1> x = 1 
  2.  
(Int) x = 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>

다음과 같이 선언된 변수는 변할 수 있으므로, mutable합니다:

```js
  2> x = 2 
  3. print(x) 
  4.  
2
```

그러나 Mojo는 엄격한 유형을 가지고 있기 때문에 변수의 유형을 변경할 수 없습니다:

```js
  4> x = "a" 
  5.  
[사용자] 오류: 표현식 [2]:1:5: 대입 중에 'StringLiteral' 값을 'Int'으로 암시적으로 변환할 수 없습니다
x = "a"
```


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

테이블 태그를 마크다운 형식으로 변경하십시오.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
  1> let x = 1 
  2. x = 2 
  3. print(x) 
  4.  
[User] error: Expression [0]:2:1: expression must be mutable in assignment
x = 2
```

Mojo는 현재 Python의 "상위집합"으로 설계되었지만 아직 완전히 그렇지는 않습니다. 따라서 Python처럼 보이지만 때로는 문법이 다를 수 있습니다. 예를 들어, 유형 주석을 위한 키워드가 다릅니다:

```js
  1> var x: Int = 1 
  2. var y: String = "a" 
  3. var z: Bool = True
```

## 함수들



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

Mojo 함수는 fn 또는 def 키워드로 선언할 수 있습니다.

함수를 선언할 때 def를 사용하면 인수 유형과 반환 유형을 지정할 필요가 없고 이름과 값만으로 변수를 생성할 수 있습니다. 이것은 파이썬에서 할 수 있는 것과 정확히 동일합니다:

```js
def sum_up(n):
    sum = 0
    for i in range(1, n+1):
        sum += i

    return sum
```

fn 키워드를 사용하여 정의된 동일한 함수는:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
fn sum_up(n: Int) -> Int:
    var sum: Int = 0
    for i in range(1, n+1):
        sum += i
    
    return sum
```

fn으로 정의된 함수는 엄격한 타입을 갖고 있으며 컴파일 시간에 함수가 올바른 타입을 입력 받고 반환하는지 확인합니다. def 키워드를 지원하는 것은 Python 사용자들이 Mojo의 구문을 이해하고 시작하기 쉽게 만들기 위한 것일 뿐입니다. Mojo 코드를 작성할 때 좋은 습관으로 간주되지는 않습니다. Mojo 코드를 더 읽어보면 대부분의 함수가 fn 키워드로 정의되어 있는 것을 보실 수 있습니다.

## Mojo 구조체

Mojo의 구조체는 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
class Dog:
    def __init__(self, name):
        self.name = name

    def run(self):
        print(f"{self.name} is running.")

dog = Dog('Teddy')
dog.run()
```

Mojo에서 해당하는 구조체는 다음과 같습니다:

```python
struct Dog:
    var name: String

    fn __init__(inout self, name: String):
        self.name = name

    fn run(self):
        print(self.name, " is running.")

let dog = Dog('Teddy')
dog.run()
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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__())에서 값을 할당해야 해요.
- __init__()의 첫 번째 인자는 관례상 self로 불리며, Python에서는 inout 키워드로 정의되어 있어요. 이는 self가 가변 참조임을 의미해요. 이것은 복잡한 개념이지만, 이 글에서는 그 정도까지 깊게 파고들 필요는 없어요.
- 아직 Mojo에서 f-string은 지원되지 않으므로 일반적인 프린팅을 사용해야 해요.

변수와 함수의 기본을 알면, 두 요소의 조합인 구조체의 구문을 배우는 것은 쉬워요. 그러나 Mojo의 구조체는 복잡한 개념이며, 더 깊이 파고들고 싶다면 Mojo의 모든 것을 다루고 있어요. 심지어 Int, String, Bool과 같은 기본 유형도 내부적으로는 구조체이며, 이것이 클래스/구조체와 같은 대문자로 시작하는 이유에요.

## Python과 Mojo 코드의 효율성 비교


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

알겠어요, 이제 Mojo의 매우 기본적인 구문을 알았으니, Python과 Mojo 코드의 효율성을 비교하고 최근 왜 많은 관심을 받고 있는지 살펴봅시다.

다음 코드를 sum_up.py라는 Python 파일에 넣어봅시다:

```python
def sum_up(n):
    sum = 0
    for i in range(1, n+1):
        sum += i
    
    return sum

def main():
    print(sum_up(1000_000_000))

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

그리고 이 코드를 sum_up.mojo라는 Mojo 파일에 넣어봅시다:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
fn sum_up(n: Int) -> Int:
    var sum: Int = 0
    for i in range(1, n+1):
        sum += i
    
    return sum

fn main():
    print(sum_up(1000_000_000))
```

Mojo 파일의 경우, 진입 지점으로 main() 함수를 정의해야 하지만 호출할 필요는 없습니다.

Linux에서는 time 명령어를 사용하여 명령어의 실행 시간을 측정할 수 있습니다. 먼저 Mojo 파일을 실행해봅시다. 그렇지 않으면 Python 파일을 먼저 실행하면 인내심을 잃을 수 있습니다 😅:

```js
$ time mojo sum_up.mojo 
500000000500000000

real    0m0,134s
user    0m0,161s
sys     0m0,004s
```


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

테이블 태그를 Markdown 형식으로 변경하였습니다.


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

Mojo는 컴파일된 언어이고 Python은 해석된 언어이기 때문에 이유가 달라요. 컴파일된 언어에서 동일한 코드는 Python에서보다 100배 빠를 수 있다는 것은 놀라운 일이 아닙니다. 그러나 Python과 구문이 매우 유사하고 Python 사용자에게 친숙하기 때문에 꽤 놀라운 것입니다. 만약 우리 모든 데이터 처리 및 ML/AI 코드가 코드를 최소한으로 변경하면서 100배 빠르다면 환상적일 것입니다.

## Mojo에서 Python 코드 직접 실행

장기적으로, Mojo가 성숙해지고 Python의 실제 상위 집합이되면 바로 Mojo를 사용하고 Python 코드를 Mojo에서 직접 실행할 수 있어야 합니다. 마치 TypeScript에서 유효한 JavaScript 코드를 작성할 수 있는 것처럼요.

그러나 현재는 Mojo에서 Python 모듈을 가져와서 Mojo 코드에서 Python 함수를 호출하고 Python 객체와 상호 작용할 수 있습니다. 위의 sum_up.py 모듈을 생성하고 Mojo에서 바로 실행하는 call_python_in_mojo.mojo라는 새 파일을 만들어 보죠.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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 모듈이 Mojo에서 찾을 수 있도록 경로를 추가해야합니다. 다음 명령어로 이 코드를 실행할 수 있습니다:

time mojo call_python_in_mojo.mojo

Python을 직접 실행하는 것과 속도가 같다는 것을 알 수 있습니다. 조금 실망스러운 일이죠. 하지만 Mojo가 아직 초기 개발 중이고 많은 기능이 아직 구현되지 않았다는 것을 감안해야 합니다. 시간이 흐를수록 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>

이 게시물에서는 Mojo라는 새로운 프로그래밍 언어의 매우 기초적인 부분을 소개했습니다. Mojo는 Python의 상위 집합으로 설계되어 Python과 매우 유사한 구문을 가지고 있습니다. 우리는 Mojo 코드의 간단한 구문과 놀라운 속도를 경험했는데, 이는 데이터 처리와 기계 학습에 매우 매력적일 수 있습니다.

그러나 Mojo는 아직 매우 새로운 언어이며 아직 완전히 성숙해지지 않았습니다. 보편적인 개발자들이 일할 준비가 되기까지 어느 정도 시간이 필요합니다. 그럼에도 불구하고, 이 언어를 계속 주시하고 AI의 새 시대를 놓치지 않기 위해 시간을 할애하는 가치가 있습니다. 그리고 준비가 되면 우리는 효율성을 향상시키기 위해 빠르게 전환할 수 있으며, 이는 게임 체인저 이벤트가 될 수도 있습니다.

## 관련 게시물:

- Python typing and validation with mypy and pedantic
- Python에서 쉘 명령어를 올바르게 실행하는 방법

초고속 언어 Mojo 간단 소개  Python의 슈퍼셋

![Window Operations](/TIL/assets/img/2024-07-14-5ExamplestoMasterPySparkWindowOperations_0.png)

내가 사용해 본 모든 데이터 분석 및 조작 도구에는 윈도우 연산이 있습니다. 일부는 다른 것보다 유연하고 능력이 높지만, 윈도우에서 계산을 할 수 있는 것이 필수적입니다.

데이터 분석에서 윈도우란 무엇인가요?

윈도우는 어떤 방식으로 관련된 행들의 집합입니다. 이 관련은 동일한 그룹에 속하거나 연속적인 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>

이 기사에서는 PySpark를 사용하여 창 작업에 대해 포괄적으로 이해할 수 있는 5가지 구체적인 예제를 살펴보겠습니다. 우리는 파티션과 함께 윈도우를 생성하는 방법, 이러한 윈도우를 사용자 정의하는 방법, 그리고 이를 통해 계산을 수행하는 방법을 배울 것입니다.

PySpark는 대규모 데이터 처리에 사용되는 분석 엔진인 Spark의 Python API입니다.

# 데이터

이 기사를 위해 모의 데이터로 샘플 데이터셋을 준비했고, 해당 데이터셋은 제 저장소에서 다운로드할 수 있습니다. 이 기사에서 사용할 데이터셋은 "sample_sales_pyspark.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>

자, spark 세션을 시작하고 이 데이터셋으로부터 DataFrame을 생성해 봅시다.

```js
from pyspark.sql import SparkSession
from pyspark.sql import Window, functions as F

spark = SparkSession.builder.getOrCreate()

data = spark.read.csv("sample_sales_pyspark.csv", header=True)

data.show(15)

# output
+----------+------------+----------+---------+---------+-----+
|store_code|product_code|sales_date|sales_qty|sales_rev|price|
+----------+------------+----------+---------+---------+-----+
|        B1|       89912|2021-05-01|       14|    17654| 1261|
|        B1|       89912|2021-05-02|       19|    24282| 1278|
|        B1|       89912|2021-05-03|       15|    19305| 1287|
|        B1|       89912|2021-05-04|       21|    28287| 1347|
|        B1|       89912|2021-05-05|        4|     5404| 1351|
|        B1|       89912|2021-05-06|        5|     6775| 1355|
|        B1|       89912|2021-05-07|       10|    12420| 1242|
|        B1|       89912|2021-05-08|       18|    22500| 1250|
|        B1|       89912|2021-05-09|        5|     6555| 1311|
|        B1|       89912|2021-05-10|        2|     2638| 1319|
|        B1|       89912|2021-05-11|       15|    19575| 1305|
|        B1|       89912|2021-05-12|       21|    28182| 1342|
|        B1|       89912|2021-05-13|        7|     9268| 1324|
|        B1|       89912|2021-05-14|       17|    22576| 1328|
|        B1|       89912|2021-05-15|       16|    20320| 1270|
+----------+------------+----------+---------+---------+-----+
```

## 예제 1

우선, 파티션과 정렬 열을 기준으로 윈도우를 생성합니다. DataFrame에서는 각 제품의 누적 판매량을 각 상점별로 계산하려면 윈도우를 다음과 같이 정의합니다:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
window = Window.partitionBy("store_code", "product_code").orderBy("sales_date")
```

누적 판매량을 계산하려면 이 윈도우 위에 sum 함수를 적용하기만 하면 됩니다:

```js
data = data.withColumn("total_sales", F.sum("sales_qty").over(window))
```

이 코드는 "total_sales"라는 새 열을 만들며, 이전에 정의한 윈도우 상에서 계산된 판매 수량의 누적 합계를 포함합니다.


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

" B1" 스토어의 첫 30개 행을 확인해봐서 누적값이 올바르게 계산되었는지 확인해보세요:

```js
data \
.filter((F.col("store_code")=="B1")) \
.select("store_code", "product_code", "sales_date", "sales_qty", "total_sales") \
.show(30)

# output
+----------+------------+----------+---------+-----------+
|store_code|product_code|sales_date|sales_qty|total_sales|
+----------+------------+----------+---------+-----------+
|        B1|       89912|2021-05-01|       14|       14.0|
|        B1|       89912|2021-05-02|       19|       33.0|
|        B1|       89912|2021-05-03|       15|       48.0|
|        B1|       89912|2021-05-04|       21|       69.0|
|        B1|       89912|2021-05-05|        4|       73.0|
|        B1|       89912|2021-05-06|        5|       78.0|
|        B1|       89912|2021-05-07|       10|       88.0|
|        B1|       89912|2021-05-08|       18|      106.0|
|        B1|       89912|2021-05-09|        5|      111.0|
|        B1|       89912|2021-05-10|        2|      113.0|
|        B1|       89912|2021-05-11|       15|      128.0|
|        B1|       89912|2021-05-12|       21|      149.0|
|        B1|       89912|2021-05-13|        7|      156.0|
|        B1|       89912|2021-05-14|       17|      173.0|
|        B1|       89912|2021-05-15|       16|      189.0|
|        B1|       89915|2021-05-01|       20|       20.0|
|        B1|       89915|2021-05-02|        0|       20.0|
|        B1|       89915|2021-05-03|       10|       30.0|
|        B1|       89915|2021-05-04|       13|       43.0|
|        B1|       89915|2021-05-05|       21|       64.0|
|        B1|       89915|2021-05-06|        4|       68.0|
|        B1|       89915|2021-05-07|       20|       88.0|
|        B1|       89915|2021-05-08|       16|      104.0|
|        B1|       89915|2021-05-09|       21|      125.0|
|        B1|       89915|2021-05-10|        2|      127.0|
|        B1|       89915|2021-05-11|       15|      142.0|
|        B1|       89915|2021-05-12|       15|      157.0|
|        B1|       89915|2021-05-13|       14|      171.0|
|        B1|       89915|2021-05-14|        3|      174.0|
|        B1|       89915|2021-05-15|        1|      175.0|
+----------+------------+----------+---------+-----------+
```

첫 15개 행은 제품 89912에 속하므로 총 판매액 열은 판매 수량 열의 값들의 누적 합을 보여줍니다. 16번째 행에서 제품 코드가 변경되어 누적 합이 초기화됩니다. 이는 우리가 스토어 코드와 제품 코드로 분할된 윈도우를 생성했기 때문입니다.

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

창을 생성한 후에는 다양한 집계를 계산할 수 있어요. 예를 들어, 앞에서 정의한 창에 대해 max 함수를 적용하면, 결과는 주어진 상점의 제품의 누적 최대 가격이 될 거예요.

창을 생성하는 코드를 작성할 테니까, 위를 계속 찾지 않아도 돼요.

```js
# 창 정의
window = Window.partitionBy("store_code", "product_code").orderBy("sales_date")

# 누적 최대 가격
data = data.withColumn("max_price", F.max("price").over(window))

# 결과 확인
data \
.filter((F.col("store_code")=="B1")) \
.select("store_code", "product_code", "sales_date", "price", "max_price") \
.show(15)

# 결과
+----------+------------+----------+-----+---------+
|store_code|product_code|sales_date|price|max_price|
+----------+------------+----------+-----+---------+
|        B1|       89912|2021-05-01| 1261|     1261|
|        B1|       89912|2021-05-02| 1278|     1278|
|        B1|       89912|2021-05-03| 1287|     1287|
|        B1|       89912|2021-05-04| 1347|     1347|
|        B1|       89912|2021-05-05| 1351|     1351|
|        B1|       89912|2021-05-06| 1355|     1355|
|        B1|       89912|2021-05-07| 1242|     1355|
|        B1|       89912|2021-05-08| 1250|     1355|
|        B1|       89912|2021-05-09| 1311|     1355|
|        B1|       89912|2021-05-10| 1319|     1355|
|        B1|       89912|2021-05-11| 1305|     1355|
|        B1|       89912|2021-05-12| 1342|     1355|
|        B1|       89912|2021-05-13| 1324|     1355|
|        B1|       89912|2021-05-14| 1328|     1355|
|        B1|       89912|2021-05-15| 1270|     1355|
+----------+------------+----------+-----+---------+
```

"max_price" 열의 값은 증가하거나 동일하게 유지돼요. 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>

## 예제 3

lag 및 lead는 일반적으로 사용되는 윈도우 함수 중 일부입니다. 시계열 데이터를 분석할 때 자주 사용합니다. 현재 행의 앞이나 뒤에 오프셋된 값을 반환합니다.

- lag("sales_qty", 1) : 1행 전
- lag("sales_qty", 2) : 2행 전
- lead("sales_qty", 1) : 1행 후
- lead("sales_qty", 2) : 2행 후

lag의 음수 값을 사용하여 오프셋을 지정할 수 있으므로 lag("sales_qty", 1)은 lead("sales_qty", -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
# 창을 정의합니다
window = Window.partitionBy("store_code", "product_code").orderBy("sales_date")

# 전일 판매 수량
data = data.withColumn("prev_day_sales_lag", F.lag("sales_qty", 1).over(window))
data = data.withColumn("prev_day_sales_lead", F.lead("sales_qty", -1).over(window))

# 다른 제품-매장 쌍에 대한 출력 확인
data \
.filter((F.col("store_code")=="A1") & (F.col("product_code")=="95955")) \
.select("sales_date", "sales_qty", "prev_day_sales_lag", "prev_day_sales_lead") \
.show(15)

# 출력 결과
+----------+---------+------------------+-------------------+
|sales_date|sales_qty|prev_day_sales_lag|prev_day_sales_lead|
+----------+---------+------------------+-------------------+
|2021-05-01|       13|              NULL|               NULL|
|2021-05-02|        3|                13|                 13|
|2021-05-03|       22|                 3|                  3|
|2021-05-04|       17|                22|                 22|
|2021-05-05|       20|                17|                 17|
|2021-05-06|       14|                20|                 20|
|2021-05-07|       10|                14|                 14|
|2021-05-08|       10|                10|                 10|
|2021-05-09|       15|                10|                 10|
|2021-05-10|       15|                15|                 15|
|2021-05-11|        8|                15|                 15|
|2021-05-12|        9|                 8|                  8|
|2021-05-13|       13|                 9|                  9|
|2021-05-14|        6|                13|                 13|
|2021-05-15|       21|                 6|                  6|
+----------+---------+------------------+-------------------+
```

첫 번째 행의 전일 값은 NULL입니다. 이는 해당 행이 이전 날짜를 가지고 있지 않기 때문에 발생합니다.

## 예시 4

행을 기반으로 한 창을 정의한 후, rowsBetween 메소드를 사용하여 범위를 좁힐 수 있습니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-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
window = Window \
.partitionBy("store_code", "product_code") \
.orderBy("sales_date") \
.rowsBetween(-3, -1)
```

첫 번째 매개변수가 시작이고 두 번째 매개변수가 끝입니다. 각 행에 대한 마지막 세 행을 포함하는 창을 사용자 정의했습니다. "-1"은 현재 행의 이전 행을 가리키고 "-3"은 현재 행의 세 번째 이전 행을 나타냅니다.

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

지난 세 날 동안의 평균 판매 수량을 계산하려면 이 윈도우에 mean 함수를 적용하기만 하면 됩니다.

```js
# 윈도우 정의
window = Window \
.partitionBy("store_code", "product_code") \
.orderBy("sales_date") \
.rowsBetween(-3, -1)

# 평균 계산
data = data.withColumn("last_3_day_avg", F.mean("sales_qty").over(window))

# 데이터 표시
data \
.filter((F.col("store_code")=="A1") & (F.col("product_code")=="95955")) \
.select("sales_date", "sales_qty", "last_3_day_avg") \
.show()

# 결과
+----------+---------+------------------+
|sales_date|sales_qty|    last_3_day_avg|
+----------+---------+------------------+
|2021-05-01|       13|              NULL|
|2021-05-02|        3|              13.0|
|2021-05-03|       22|               8.0|
|2021-05-04|       17|12.666666666666666|
|2021-05-05|       20|              14.0|
|2021-05-06|       14|19.666666666666668|
|2021-05-07|       10|              17.0|
|2021-05-08|       10|14.666666666666666|
|2021-05-09|       15|11.333333333333334|
|2021-05-10|       15|11.666666666666666|
|2021-05-11|        8|13.333333333333334|
|2021-05-12|        9|12.666666666666666|
|2021-05-13|       13|10.666666666666666|
|2021-05-14|        6|              10.0|
|2021-05-15|       21| 9.333333333333334|
+----------+---------+------------------+
```

예를 들어, 네 번째 행인 "2021-05-04"의 경우, 지난 세 행(13, 3, 22)의 값의 평균인 13.75입니다.

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

입력 데이터의 각 행에서 정의된 창 내의 열의 누적 평균 값을 계산해야 하는 경우를 생각해보세요. 각 행에 대해 계산은 창의 첫 번째 행과 현재 행 사이의 행을 포함해야 합니다.

이를 위해 unboundedPreceding으로 시작점을 정의할 수 있습니다. 마찬가지로, 창의 끝까지 가려면 unboundedFollowing을 사용할 수 있습니다.

<img src="/TIL/assets/img/2024-07-14-5ExamplestoMasterPySparkWindowOperations_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>

```js
# 윈도우 정의
window = Window \
.partitionBy("store_code", "product_code") \
.orderBy("sales_date") \
.rowsBetween(Window.unboundedPreceding, -1)

# 평균 계산
data = data.withColumn("누적평균", F.mean("sales_qty").over(window))

# 데이터 출력
data \
.filter((F.col("store_code")=="A1") & (F.col("product_code")=="95955")) \
.select("sales_date", "sales_qty", "누적평균") \
.show()

# 결과
+----------+---------+------------------+
|sales_date|sales_qty|   누적평균       |
+----------+---------+------------------+
|2021-05-01|       13|              NULL|
|2021-05-02|        3|              13.0|
|2021-05-03|       22|               8.0|
|2021-05-04|       17|12.666666666666666|
|2021-05-05|       20|             13.75|
|2021-05-06|       14|              15.0|
|2021-05-07|       10|14.833333333333334|
|2021-05-08|       10|14.142857142857142|
|2021-05-09|       15|            13.625|
|2021-05-10|       15|13.777777777777779|
|2021-05-11|        8|              13.9|
|2021-05-12|        9|13.363636363636363|
|2021-05-13|       13|              13.0|
|2021-05-14|        6|              13.0|
|2021-05-15|       21|              12.5|
+----------+---------+------------------+
```

누적평균 열에는 현재 행까지의 모든 행의 평균 판매량이 포함됩니다 (현재 행은 제외됨). 현재 행을 누적 평균 계산에 포함하려면 다음과 같이 윈도우를 정의할 수 있습니다:

```js
window = Window \
.partitionBy("store_code", "product_code") \
.orderBy("sales_date") \
.rowsBetween(Window.unboundedPreceding, Window.currentRow)
```

# 마지막으로



<ins class="adsbygoogle"
     style="display:block"
     data-ad-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를 사용하여 이러한 작업을 수행하는 방법을 배웠습니다.

읽어 주셔서 감사합니다. 피드백이 있으시면 언제든지 알려주세요.

PySpark 윈도우 연산을 마스터하기 위한 5가지 예제

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

레딧에서 재미있는 질문이 있었습니다(삭제되었어요). 이 질문은 텅 빈 지구의 물리학에 대해 물었습니다. 질문이 완전히 명확하지는 않았고 중요한 부분이 빠져 있었지만, 저는 답변할 거예요. 사실, 이 질문의 다른 버전을 만들어서 답변할 거에요.

# 중력과 고체 지구.

좋아요, 텅 빈 지구에 대해 생각해보겠지만 한 가지 중요한 것에 대해 이야기해야 해요. 중력에 대해 이야기할 거예요. 중력을 질량을 가진 물체 사이의 가 attract한 힘으로 모델링하겠어요(시간-공간 곡률로 모델링하지 않을 거예요). 이를 통해 우리는 다른 작은 물체에 의한 단위 질량 당 중력을 계산할 수 있어요. 이것을 중력장이라 하며(Newtons per kilogram 단위를 갖습니다) 벡터 g입니다.


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

이 작은 작은 물체로 인한 중력장은 물체의 값(m)과 그 물체로부터의 거리(r) 양쪽에 따라 달라집니다. 이것은 그 물체를 향하는 벡터이며 우리는 이를 다음과 같은 식으로 쓸 수 있습니다.

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

여기서 G는 값이 6.67 x 10^-11 N*m²/kg²인 범용 중력 상수입니다. 또한, r-hat가 포함되어 있음을 주목해 주세요. 만약 r이 물체에서 중력장을 찾으려는 지점까지의 벡터라면, r-hat는 전체 표현을 벡터로 만드는 단위 벡터입니다. 네, 중요합니다.

만약 점 물체가 아닌 물체가 있다면 어떻게 이 경우의 중력장 값을 찾을 수 있을까요? 마침내, 중력은 중첩 원리를 따른다는 사실이 있습니다. 이것은 하나 이상의 작은 점 물체로 인한 중력장은 각 물체의 중력장의 벡터 합이라는 것을 의미합니다. 따라서, 모든 이상한 모양의 물체에 대해 나는 그 물체를 여러 작은 물체들로 나누어 중력장을 계산할 수 있습니다.


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

실제 지구의 중력장을 모델링하는 데 이 아이디어를 사용해봅시다. 재밌는 건, 지구를 구성하는 1000개의 미세한 물체가 전체 지구를 1/1000만큼의 질량을 가진 것처럼 가정할 수 있다는 것이에요. 물론, 이것은 실제로는 사실이 아니에요. 지구의 밀도는 표면보다 중심에 더 높기 때문에요. 하지만, 괜찮아요 (나를 믿어봐).

우리의 지구를 나타내기 위해 5000개의 물체를 여기에 준비했어요. (네, 이건 Web VPython으로 만들었어요).

![Earth Model](/TIL/assets/img/2024-07-14-WhatWouldHappenIftheEarthWasHollowandHowDoWeKnowItsNot_2.png)

지구 표면( x축 상)에서 중력장을 찾기 위해 중첩 원리를 사용하면, g = `-10.0, 0.33, -0.73` N/kg를 얻게 돼요. 9.8 N/kg의 예상치와 완전히 일치하지는 않지만, 5000개의 물체만 사용했을 때는 충분히 가까운 값이에요.


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

만약 지구 전체를 엄청나게 작지만 매우 질량이 많은 하나의 지점으로 대체한다면 어떨까요? 만약 이 작은 지점의 질량이 지구와 같다면, 이는 지구와 동일한 중력장 값을 만들 것입니다. 사실, 구 형태의 균일한 분포 외부의 중력장은 점 질량으로 인한 중력장과 정확히 같습니다. 이는 꽤 유용한 아이디어입니다.

이제 우리는 몇 가지 질문에 준비되었습니다.

# 만약 지구의 외부 10퍼센트만 남았다면 어떻게 될까요?

심지어 이것도 완벽한 질문은 아니지만 너무 길게 만들고 싶지 않았어요. 그래서, 지구 내부 일부가 마법같이 사라진다고 상상해보세요. 그 후에, 우리는 지름의 10퍼센트인 지구 바깥 부분만 남게 됩니다. 지구의 반지름이 6.37 x 10^6 미터이기 때문에 표면의 두께는 637 킬로미터가 될 것입니다.


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

이제 지구를 5000개의 작은 질량으로 나누는 방법은 위와 같습니다. 그러나 이러한 질량들은 지구의 외부 부분에만 있을 것입니다. 또한 이러한 모든 질량의 합은 전체 지구의 질량이 아니라 더 적은 값을 가질 것입니다.

표면 근처 물질의 밀도는 대략 3500 킬로그램/미터³입니다. 이 밀도와 남아있는 지구의 부피(남은 부분)를 이용하여 1.03 x 10²⁴ 킬로그램의 질량을 구할 수 있습니다. 네, 이는 전체 지구의 질량보다 약 20% 낮습니다.

이제 5000개의 점 질량을 만들어 봅시다. 확인해보세요.

![이미지](https://miro.medium.com/v2/resize:fit:904/1*hKcOCkFW0e1bC5I-Sq4YCg.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>

지구 표면에서 중력장 계산을 다시 실행하니, 값이 딱 1.4 N/kg이 나왔어요. 일반적인 지구의 중력보다 훨씬 낮은 값이 나온 이유는 질량이 줄어들었기 때문이에요.

그런데 기다려봐요! 또 다른 흥미로운 상황이 생겼어요. 만약 지구 안으로 들어간다면 어떻게 될까요? 우리가 계산한 내부의 특정 위치(중심에는 아니고 중심절반 정도로)의 중력장 값은 `8.88e-3, -1.46e-3, -0.22` N/kg이에요. 5000개의 질량만 사용했기 때문에 정확히는 아니지만 0에 가까울 거예요.

네, 지구 안에 들어가면 중력장이 0이 돼요. 슈퍼히어로나 붕떨어진 풍선처럼 자유롭게 움직일 수 있을 거에요(단, 공기가 있다는 전제 하에).

# 만약 내부를 제거하는 대신 그냥 눌러넣는다면요?


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

다른 방법으로는 지구를 구멍난 형태로 만들 수 있어요. 중심에 있는 물질을 모두 바깥부분으로 쫙 누르면 돼요. 이 방법의 차이점은 총 질량이 변하지 않는다는 거에요. 이 말은 지구 표면에서 중력장이 여전히 9.8 N/kg일 것이라는 거예요. 사실 대부분의 부분에서 구멍난 지구와 단단한 지구의 차이를 구별하기 어려울 거에요.

# 그럼, 지구가 구멍난 게 아닌 걸 어떻게 알죠?

그거 좋은 질문이에요. 지구에 대해 알아낸 거나 이게 단단한지 아니면 구멍난 것인지를 알아내는 게 참 신기해요. 표면 주변에 서서는 진짜로 알 수가 없죠. 구멍이 있는지 아니면 단단한지 알려면 속을 들여다봐야 할 텐데요 — 하지만 1킬로미터만 파봐도 멀리 못 갈 거예요. 그래서, 지구가 단단하다는 것을 시사하는 흥미로운 실험을 하나 보여드릴게요.

지구를 보기 전에 이해해야 할 중요한 개념이 몇 가지 있어요. 첫 번째로는 만유인력의 개념입니다 (이것을 방금 위에서 사용했죠). 1666년에 이삭 뉴튼은 행성이 원형으로 움직이게 하는 힘이 지구에서 물체들을 떨어뜨리는 힘과 같다고 제안했어요. 그래서 질량을 가진 두 물체는 서로 인력을 발생시켜요. 이 힘은 거리와 두 물체의 값을에 따라 달라져요.


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

이 실험은 쉬운 것이 아닌 것 같네요. 아마도 처음으로 마주한 문제는 뭘까요 - 우리가 수직 방향을 결정하는 데 수줄기를 사용하는데, 그것의 반류를 어떻게 찾을까요. 어이쿠. 잘 찾기 힘들죠. 재밌는 점은, 별의 위치를 사용하여 수직 방향을 결정하는 것입니다.

그 다음 큰 문제는 뭘까요 - 산의 질량을 어떻게 찾을까요? 산의 밀도와 부피를 알고 있다면 질량을 찾는 것은 그리 어렵지 않습니다. 하지만 부피를 찾는 것은 정말 어렵죠. 모양이 잘 정돈된 산을 찾고 주변에 다른 산들이 그렇게 가깝지 않은 산을 찾는 것이 좋습니다 (다른 산들이 중력을 발생시킬 수 있어요).

1774년에 스코틀랜드의 산인 셸할리온 산이 선택되었습니다. 신중한 측정 덕분에, 수질기의 반류가 일상보다 작은 것을 발견했습니다. 그들은 산의 밀도가 2500 킬로그램/미터³이라는 가정으로, 지구의 밀도를 4500 kg/ m³로 계산했습니다. 참고로, 지구의 실제 밀도는 더 높습니다 - 5500 kg/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>

캐벤디시가 중력 상수(G)를 측정한 후 지구의 질량(밀도)에 대한 더 나은 값이 얻어졌지만, 이건 나중 이야기입니다. 이것이 어떻게 달성되었는지에 대한 엿보기가 여기 있습니다.

지구가 비어있다면 어떤 일이 벌어질까 그리고 그렇지 않다는 사실은 어떻게 알 수 있을까

강화 학습을 이용한 동적 가격 책정 최적화 방법

네트워크 과학으로 예측한 다음에 죽을 왕좌의 게임 캐릭터는 누구

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

최단 경로 찾기는 컴퓨터 과학에서 기본적인 문제로, 네트워크 라우팅 프로토콜부터 그래프 분석까지 다양한 알고리즘과 응용프로그램의 기초를 형성합니다. 현실에서는 물류 및 통신 네트워크에서 효율적인 경로를 찾고 여행 시간을 최소화하는 데 핵심적인 문제입니다.

이 문제가 이렇게 중요하기 때문에 많은 사람들이 이를 해결하는 방법에 대해 고민했습니다. 이는 다양한 가정과 실행 시간을 가진 다양한 알고리즘의 동물원으로 이어졌습니다. 이 글에서는 벨만-포드 알고리즘의 작동 방식과 Python 및 Rust에서의 구현 방법을 보여 드리고자 합니다.

# (Shimbel-)벨만-포드(-무어) 알고리즘


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

알고리즘의 이름부터 헷갈릴 수 있어요. 문헌에서는 벨만-포드 알고리즘으로 알려져 있지만 많은 사람들이 관여했습니다. Alexander Schrijver의 논문 "조합 최적화의 역사에 대하여"에 따르면, Alfonso Shimbel은 1955년에 동등한 알고리즘을 개발했고, Richard Bellman과 Lester Ford Jr.은 각각 1958년과 1956년에 이 알고리즘을 설명했습니다. 이후 Edward F. Moore가 1959년에 알고리즘의 변형을 발표했어요. 하지만 걱정하지 마세요, 이 알고리즘 자체는 그 역사보다 이해하기 쉬워요.

이들의 알고리즘은 여러분이 주어진 그래프의 고정된 노드에서 시작하여 다른 각 노드까지의 최단 경로 문제를 해결해요. 다음과 같은 그래프를 예시로 삼아볼게요:

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

총 6개의 방향성이 있는 에지로 연결된 네 개의 노드를 볼 수 있어요. 각 에지는 가중치가 있습니다. 예를 들어, 3에서 0으로 가는 에지의 가중치는 1이에요. 노드 0에서 노드 2로의 최단 경로는 직접적인 0-2가 아닌 총 비용이 (-1)+1+0 = 0인 0-1-3-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>

## 아이디어

알고리즘은 시작 노드로부터 i개 이하의 엣지를 사용하여 다른 모든 노드까지의 최단 경로의 길이를 배열 형태로 유지하는 간단한 아이디어를 중심으로 돌아갑니다.

이 배열을 i = 0, 1, ...부터 순차적으로 계산합니다. 각 반복에서 i에 대한 정보는 이전 반복 i-1의 배열과 그래프의 엣지를 사용합니다.

## 예시


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

자 그럼 이제 작은 예제를 사용해보자. 노드 0에서 다른 모든 노드로 가는 최단 경로 길이를 찾고 싶다고 가정해보자. 나중 단계에서 실제 경로도 재구성할 것이지만, 일단은 일 노드 간의 경로 길이에만 관심을 갖자.

거리 배열을 [0, ∞, ∞, ∞]로 시작한다. 즉, 우리는 최대 edge 0을 사용하여 0 노드에서 0 노드로 총 길이 0만큼 도달할 수 있다는 것이다. 이것은 우리가 정한 정의다. 두 번째 항목은 0 노드에서 1 노드로 최대 edge 0을 사용하여 ∞ 길이로 도달할 수 있음을 의미하는데, 즉 해당 노드에 도달할 수 없다는 것이다. 동일한 이유로 0 노드에서 2와 3으로 가는 것도 동일하다.

거리를 해당 노드 옆에 써보자:

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

다음 반복에서는 최소경로 길이를 포함하는 다른 배열 [a, b, c, d]를 채우려고 합니다. 이 배열은 노드 0에서 최대 한 개의 엣지를 사용하여 다른 모든 노드까지의 최단 경로 길이를 포함합니다. 이전 배열을 사용하여 이를 어떻게 계산하는지 살펴봅시다. 예를 들어, 노드 0에서 1까지의 최단 경로 길이를 알고 싶다면 두 가지 가능성이 있습니다:

- 0에서 1까지 엣지를 사용하지 않고 이동하거나

- 0에서 1까지 추가 엣지를 사용하여 이동합니다.

옵션 1은 이전 배열 [0, ∞, ∞, ∞]에서 볼 수 있듯이 길이가 ∞입니다. 두 번째 옵션의 길이는 -1이며 그래프를 통해 노드 0에서 노드 1로 -1의 비용으로 이동할 수 있습니다. 분명히 이전에 보았던 ∞보다 -1이 더 작으므로 배열에 이를 넣어 보겠습니다. 다른 노드에 대해 동일한 작업을 수행하면 업데이트된 배열 [0, -1, 1, ∞]이 됩니다. 이제 이 반복이 완료되었습니다.

그래픽적으로表시하면:


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

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

다음 이터레이션에서는 같은 게임을 다시 합니다. 노드 0에서 다른 모든 노드로 가는 최단 경로 길이가 최대 두 개의 변을 사용하여 [a, b, c, d]를 채우고 싶습니다. 예를 들어, 노드 0에서 노드 3까지의 최단 경로 길이를 계산해 봅시다. 노드 0에서 노드 3으로 가는 여러 옵션이 있습니다:

- 단일 변을 사용하여 0에서 3으로 이동: 길이는 이전 이터레이션의 배열에서 볼 수있는대로 ∞입니다.
- 먼저 노드 1로 이동한 다음 1에서 3으로 가는 변을 사용할 수 있습니다. 하나의 변만 사용하여 노드 1로 가는 데 드는 비용은 배열에서 확인할 수 있는대로 -1입니다. 노드 1에서 노드 3으로 한 단계 더 가는 데 드는 비용은 그래프에서 확인할 수 있는대로 1입니다. 따라서 이미 이전 옵션보다 작은 비용인 0으로 노드 0에서 노드 3에 도달할 수 있습니다.
- 먼저 노드 2로 이동한 다음 2에서 3으로 가는 변을 사용할 수 있습니다. 따라서 노드 0에서 노드 3으로 2 단계로 도달하여 비용은 1 + 2 = 3입니다.

다른 옵션이 없으므로 두 번째 옵션에서 최단 경로 길이는 0입니다. 다른 노드에 대해도 수행하면 배열 [0, -1, 1, 0]을 얻을 수 있습니다.


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


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

이전 배열 [0, -1, 1, 0]에서 시작하는 한 번 더의 반복 작업을 합니다. 이번 반복에서는 노드 0에서 노드 2로의 최단 경로 길이가 변하는 것 외에는 큰 변화가 없습니다. 이전 배열에서 볼 수 있듯이, 최대 두 개의 엣지를 사용하여 길이가 1인 것을 알 수 있습니다. 그러나 처음에 우리는 실제로 길이가 (-1) + 1 + 0 = 0인 0–1–3–2의 최단 경로를 보았습니다. 우리는 현재 반복에서 이 경로 길이를 찾을 것이며, 그러면 알고리즘이 종료됩니다. 이것은 네 개의 노드를 가지면 최단 경로가 최대 세 개의 엣지만을 포함해야 하거나 일반적으로 N 노드를 가지면 N— 1개의 엣지를 포함해야 하기 때문입니다.

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

마지막 문장에서 조금 거짓말을 한 것 같아요. 음의 순환이 존재할 수 있다는 건데요, 예를 들어 노드 u에서 자신으로 돌아와 경로의 총 길이가 0보다 작은 것입니다. 이 경우 순환을 돌 때마다 경로의 길이를 줄일 수 있기 때문에 최단한 경로가 없는 것이죠. 음의 순환을 찾으려면 N개의 노드가 있을 때 N번째 반복을 실행해야 합니다. 음의 순환하지 않는다면 이 반복에서 우리 배열이 변하지 않아야 합니다. 이것이 여전히 변경된다면, 어딘가에 음의 순환이 있다는 것을 알 수 있습니다. 이를 복원할 수도 있지만, 여기서는 그렇게 하지 않겠습니다.

# 구현

작은 코드량에 대한 많은 글입니다. 두 가지 다른 프로그래밍 언어인 Python과 Rust로 어떻게 하는지 살펴봅시다.

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

여기 있습니다. 제가 경로 길이 뿐만 아니라 가장 짧은 경로를 재구성할 수 있는 다른 배열 prev도 계산합니다.

```js
N = 4
graph = {0: {1: -1, 2: 1}, 1: {3: 1}, 2: {3: 2}, 3: {0: 1, 2: 0}}
start = 0

dists = [float("inf") for i in range(N)]
prev = [None for i in range(N)]

dists[start] = 0
prev[start] = start

for _i in range(N):
    for node, edges in graph.items():            # 모두에 대해 반복
        for next_node, weight in edges.items():  # `node`에서 시작하는 모든 간선에 대해 반복
            candidate_length = dists[node] + weight
            if candidate_length < dists[next_node]:
                dists[next_node] = candidate_length
                prev[next_node] = node # `node`에서 `next_node`로 이동하는 것이 이전 경로보다 나은 것

for node, edges in graph.items():
    for next_node, weight in edges.items():
        if dists[node] + weight < dists[next_node]:
            print("음의 사이클이 감지되었습니다!")

print(dists)
print(prev)
```

출력은 다음과 같습니다.

```js
[0, -1, 0, 0]
[0, 0, 3, 1]
```


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

첫 번째 배열은 노드 0부터 노드 0, 1, 2 및 3으로 가는 가장 짧은 경로가 각각 0, -1, 0 및 0임을 나타냅니다.

노드 0에서 노드 2로 길이가 0인 경로를 어떻게 얻을 수 있을까요? 두 번째 배열 prev를 살펴봅시다. 거기서 prev[2] == 3 이므로 노드 3에서 노드 2로 이동합니다. 따라서 경로는 3–2로 끝납니다. 또한 노드 3에서 노드 1로 이동한다는 것을 알 수 있습니다. 따라서 경로는 1–3–2로 끝납니다. 그리고 노드 1에서 노드 0으로 이동한다는 것을 알 수 있습니다. 따라서 전체 경로는 0–1–3–2 입니다.

좋아요, Rust에서 같은 작업을 해봅시다!

## Rust


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

한 줄 씩 번역해 보았습니다. Rust에 관심이 있는 분들에게 도움이 될 수도 있을 것 같아요.

```rust
use std::collections::HashMap;

fn main() {
    const N: usize = 4;
    let graph: HashMap<usize, HashMap<usize, f32>> = HashMap::from([
        (0, HashMap::from([(1, -1.), (2, 1.)])),
        (1, HashMap::from([(3, 1.)])),
        (2, HashMap::from([(3, 2.)])),
        (3, HashMap::from([(0, 1.), (2, 0.)])),
    ]);
    let start: usize = 0;

    let mut dists = [f32::INFINITY; N];
    let mut prev = [None::<usize>; N];

    dists[start] = 0.0;
    prev[start] = Some(start);

    for _i in 0..N - 1 {
        for (node, edges) in graph.iter() {
            for (next_node, weight) in edges.iter() {
                let candidate_length = dists[*node] + *weight;
                if candidate_length < dists[*next_node] {
                    dists[*next_node] = candidate_length;
                    prev[*next_node] = Some(*node);
                }
            }
        }
    }

    for (node, edges) in graph.iter() {
        for (next_node, weight) in edges.iter() {
            if dists[*node] + *weight < dists[*next_node] {
                println!("Negative cycle detected!");
            }
        }
    }

    println!("{:?}", dists);
    println!("{:?}", prev);
}
```

## 실행 시간과 메모리

이 알고리즘은 그래프의 노드 수를 의미하는 N과 그래프의 간선 수를 의미하는 E에 대해 O(N · E) 시간에 실행된다는 것을 확인할 수 있어요. 이는 모든 N 노드를 순회하는 루프와 모든 E 간선을 순회하는 내부 루프가 중첩되어 있기 때문에 나타나는 직접적인 결과입니다.


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

메모리 사용량 측면에서는 추가로 크기가 N인 두 개의 배열과 몇 개의 상수만 저장하면 되므로 추가 메모리 복잡도는 O(N)이 됩니다.

프로그래밍 언어의 성능 측정가들을 위해: 내 Python 버전은 평균적으로 노드당 10개의 이웃을 갖는 랜덤 1000개 노드 그래프에서 3초가 걸렸지만, Rust 버전은 동일한 그래프에서 0.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>

더 빠른 알고리즘인 다익스트라 알고리즘을 사용할 수는 없지만, 우리 예시에는 사용할 수 없습니다. 다익스트라 알고리즘은 양의 간선 가중치를 전제로 하기 때문이죠. 그래서 약간의 음의 간선 가중치를 더해 다른 알고리즘을 사용해야 했어요. 😉

그래서 최단 경로 알고리즘을 구현하거나 이를 대신 처리해주는 라이브러리를 사용해야 할 때, 그 알고리즘이 어떻게 작동하는지 이해하게 되었으면 합니다.

오늘 새롭고 흥미로운 가치있는 것을 배우셨기를 바랍니다. 읽어주셔서 감사합니다!

벨만-포드 알고리즘으로 최단 경로 찾는 방법

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

토픽 모델링(즉, 텍스트 데이터 코퍼스에서의 토픽 식별)은 라텐트 디리클레 할당(LDA) 모델이 발표된 이후 빠르게 발전해왔습니다. 그러나 이 클래식한 토픽 모델은 단어들 간의 관계를 잘 포착하지 못합니다. 왜냐하면 단어 가방이라는 통계적 개념에 기반하기 때문입니다. 최근에는 임베딩 기반의 Top2Vec와 BERTopic 모델이 사전 훈련된 언어 모델을 활용하여 토픽을 생성함으로써 이러한 단점을 극복하고 있습니다.

이 기사에서는 Maarten Grootendorst의 (2022) BERTopic을 사용하여 정치 연설 원고에서 토픽을 대표하는 용어를 식별할 것입니다. 이 모델은 다양한 코퍼스에서의 토픽 모델링 지표에서 전통적이고 현대적인 대부분의 토픽 모델을 능가하며, 기업, 학계(Chagnon, 2024) 및 공공부문에서 활용되어왔습니다. 우리는 다음을 파이썬 코드를 통해 살펴볼 것입니다:

- 데이터를 효과적으로 전처리하는 방법
- Bigram 토픽 모델을 생성하는 방법
- 시간이 지남에 따라 가장 빈번한 용어를 탐색하는 방법.


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

예제 데이터 세트로는 Efat et al. (2023) 논문의 일환으로 공개된 Empoliticon: Political Speeches-Context & Emotion 데이터 세트를 사용합니다. 해당 데이터 세트는 국제 저작권 4.0 라이센스에 따라 출시되었으며 미국, 영국, 중국 및 러시아 대통령/총리의 정치 연설 2010개의 대본을 포함하고 있습니다. 주제 모델을 더 집중시키기 위해 하위 집합에는 러시아 리더들의 556개 연설만 포함되어 있습니다:

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

# 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. 못 읽는 문자(mojibake) 오류 수정

못 읽는 문자(mojibake)는 문자 인코딩 오류로 인해 나타나는 혼란스러운 텍스트를 의미하는 일본어 단어입니다. 다음은 예시입니다:

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

클리닝을 시작하기 전에 이 단계를 포함하는 것이 유용합니다. 인코딩 관련 오류를 수정하는 것은 간단합니다:

2.2. 특수 문자, 구두점 및 숫자 정리

이 단계는 인코딩 오류를 수정한 후에 바로 이어져야 합니다. 가장 간단한 방법은 cleantext 라이브러리를 사용하는 것입니다. 또한 소문자화를 고려하세요. 데이터 집합에서 "노동"과 "Labor"가 같은 의미인가요? 그렇다면 lowercase 매개변수를 추가하고 클리닝 함수를 적용하십시오:

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>

일반적으로 불용어 목록을 제거하는 것은 필수적입니다. 프로젝트의 초점에 따라, 가치를 더하지 않는 추가적인 불용어 목록에서 데이터를 정리하는 것도 유용할 수 있습니다. BERTopic의 문서에 작성된 것처럼:

대신, 주제 모델 생성 중 임베딩을 생성한 후 문서를 전처리하는 데 CountVectorizer를 사용합니다.

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

nr_topics parameter은 7로 설정되어 있으며, 6개의 토픽을 생성합니다. 나머지 토픽은 이상치를 유지하는 데 사용됩니다.

# 4. 토픽 시각화

다음 단계에서는 결과를 더 잘 표현하기 위해 히트맵으로 데이터를 시각화해보겠습니다. 결과는 다음과 같습니다:

![Topic Modelling with BERT topic in Python](/TIL/assets/img/2024-07-14-TopicModellingwithBERTtopicinPython_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>

아래와 같이 하겠습니다. 토픽 모델에서 바이그램과 그 확률을 추출하여 6개 주제에 대한 데이터 프레임을 작성할 것입니다:

다음으로, 이 코드는 Figure 1에 히트맵을 생성합니다.

## 5. 시간별 토큰 빈도

이제, 시간에 따른 바이그램의 발전에 대한 관점을 추가할 것입니다. 러시아 지도자의 연설에서 어떤 연도에 바이그램이 가장 자주 사용되었는지 살펴볼 것입니다. Figure 2의 히트맵은 각 연도별로 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>


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

The arabica library, which is now forthcoming in the Journal of Open Source Software (Koráb & Poměnková, 2024), was developed for this purpose. Here is the code generating the heatmap in Figure 2:

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

# Conclusions



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

이 기사는 BERTopic을 사용한 토픽 모델링에 대해 간단히 소개했습니다. 이 모델의 프레임워크는 다양한 확장, 세밀 조정 및 시각화 방법을 제공합니다(문서 참조). 주요 결과를 요약해보겠습니다:

- 토픽 모델은 방어 정책(토픽 1), 경제 발전(토픽 2), 제2차 세계대전(토픽 3), 내부 정책(토픽 4), 건강 및 인구통계(토픽 5), 교육(토픽 6)에 대해 6가지 명확한 토픽을 보여줍니다.
- Arabica와 BERTopic을 결합하면 외교 및 방위 정책 토픽(“군사”, “러시아 연방”, “법 집행”)이 2012년 이전에 더 자주 논의되었음을 볼 수 있습니다. 반면 교육 및 건강관련 주제가 특히 2010년 이후에는 적게 논의되었습니다.
- Arabica가 절대 빈도를 반환하기 때문에 데이터셋에는 제2차 세계대전, 외교 및 방위 정책 용어가 더 많이 포함되어 있습니다. 그러나 지역적 맥락을 알지 못하면 결과를 잘 해석하기 어렵습니다.

이전 기사에서 간단한 LDA를 사용한 토픽 모델링 접근 방식에 대해 설명한 바 있습니다. 이 튜토리얼의 완전한 코드는 내 GitHub에 있습니다.

제 작품을 즐기신다면 커피를 사주시고 글쓰기를 지원할 수 있습니다. 또한 새 기사 발행 알림을 받기 위해 이메일 목록을 구독할 수도 있습니다. 감사합니다!


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

# 참고 자료

[1] Blei, Ng, Jordan (2003). Latent Dirichlet Allocation. Journal Of Machine Learning Research 3, pp. 993–1022.

[2] Chagnon, Pandolfi, Donatelli, Ushizima (2024). Benchmarking topic models on scientific articles using BERTeley. Natural Language Processing Journal 6.

[3] Efat, Atiq, Abeed, Momin, Alam (2023). Empoliticon: NLP 및 MLBased Approach를 사용한 정치 연설에서 컨텍스트 및 감정 분류. IEEE Access, vol. 11.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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] Grootendorst (2022). Bertopic: Neural Topic Modeling With A Class-Based TF-IDF Procedure. Computer Science.

[5] Koráb, Poměnková (2024). Arabica: A Python package for exploratory analysis of text data. In The Journal of Open Source Software. Journal of Open Source Software. https://doi.org/10.5281/zenodo.10866697.

Python에서 BERT를 사용한 토픽 모델링 방법

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

우리 모두가 아는 대로, 데이터 과학은 우리의 세계에 매우 새로운 학문입니다. 이로 인해 이는 일할 때 매우 흥미로운 분야가 됩니다. 그러나 이로 인해 문제가 발생하기도 합니다. 오늘은 그 중 하나인 문제에 대해 이야기하고 싶습니다: 데이터 과학 결과나 개념을 설명할 때 잘못된 용어를 사용하는 문제입니다.

제가 항상 다뤄야 하는 다섯 가지 자주 오용되는 단어와 전형적인 오용에 대한 설명이 있습니다. 이를 통해 데이터 과학 결과의 전달 및 구현에서의 함정에 대해 더 많이 인식하게 된다면 좋겠습니다.

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

와우, 사람들은 세상을 예측하는 걸 정말 좋아하네요, 그렇죠? 2010년쯤 유행하기 시작한 이후로, p-단어처럼 흔히 들어본 말은 없는 것 같아요. 계수가 통계적으로 유의미한 변수인 x는 선형 모델에서 중요하다고 하더라도, 그 변수가 예측력이 있는 것은 아닙니다. 그건 상당히 무리인 주장이죠.

훈련된 통계 모델에서 유의미한 영향을 끼치는 변수들도, 그 효과가 미미해서 사실상 중요하지 않을 수도 있어요. 따라서, 그 변수들을 '예측적으로' 설명한다는 것은 현실을 잘못 표현할 수도 있어요. 새로운 데이터에 대한 테스트 과정이 필요한데, 이를 통해 모델이나 변수들을 실제로 '예측적인지' 설명할 수 있어요. 며칠 전에 로지스틱 회귀 모델 결과를 사람이 '예측적이다'라고 설명했을 때, 저는 훈련 및 테스트 데이터를 나누지 않았고, 예측을 시도하고 있지도 않았는데요. 규칙적으로, 왼쪽에 빼놓은 테스트 샘플을 사용하여 예측 효과를 확인하지 않으면 변수나 모델을 '예측적으로' 설명하지 마세요.

## 2. R-squared

R-squared는 대체로 선형, 가법적 모델의 모델 품질 측정으로만 적용됩니다. 그런데 제가 종종 확률 모델이나 분류기에 '높은 R-squared'를 갖고 있다고 하는 사람들을 듣곤 해요. 그게 무슨 뜻일까요? 심플한 일반화된 선형 모델조차도 전체적인 모델 품질을 정의하는 여러 방법이 있어요. 이러한 모델들에는 적어도 5가지 다른 유사 R-squared 메트릭스가 있고, 그 결과는 크게 다를 수 있으며 해석하기 어려울 수 있어요. 예측 정확도 메트릭스인 ROC AUC, F1-score와 같은 지표까지 더해져서 혼란스러울 수 있죠.


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

확률 모델링을 하다보면 odds(승산) 용어를 자주 만날 것입니다. 이 모델의 계수를 해석할 때 odds가 자연스럽게 발생합니다. 그러나 odds는 확률을 의미하지 않습니다. 이 오해는 odds 비율을 사람들에게 설명할 때 정말 나쁠 수 있습니다. 모델에서 변수가 300%의 odds 비율을 가진다면, 사람들은 종종 해당 변수의 단위 증가가 결과의 확률을 세 배로 만든다고 생각합니다. 정말 멋지게 들리죠! 그것은 틀렸습니다. 결과에 미치는 확률의 영향은 사전 확률이 무엇이었느냐에 달려 있습니다. 이미 매우 높은 경우, 300%의 odds 비율은 거의 영향을 주지 않을 것입니다. 매우 낮은 경우, 실제로 300%의 영향을 줄 것이지만, 작은 것의 300%는 아마도 여전히 작을 것입니다. 더 읽고 싶다면 이 주제에 대한 제 기사를 확인하세요.

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

통계 검정에서 잘못 사용되는 또 다른 p 단어는 입증(Prove)이다. 가설을 입증하거나 반박하지 않습니다. 귀무 가설(null hypothesis)을 기각하거나 기각하지 못합니다. 많은 사람들이 제대로 이해하지 않는 철학이며, 이는 분명히 의미론적인 것이 아닙니다.

예를 들어, 12세에서 16세 사이의 소년과 소녀가 친구의 평균 수가 동일한지 테스트하고 싶다고 가정해봅시다. 해당 연령대의 충분한 샘플을 조사하여 모든 소년과 소녀 사이의 평균 친구 수에 차이가 없다는 귀무가설을 세우고, 우리가 가진 표본의 통계적 특성을 고려하여 그 귀무가설이 얼마나 진실일지 확인합니다. 무작위로 설정된 확률 막대(알파)를 사용하여(`보통 5% 정도) 귀무가설을 기각할 수 있다고 선언할 수도 있습니다.

소년과 소년이 서로 다른 평균 친구 수를 가진다는 것을 증명했다고 말할 수 없습니다. 두 그룹이 같은 친구 수를 가질 가능성은 낮다고 말할 수 있거나 '통계적 검정이 알파 0.05에서 귀무가설을 기각했다'라고 말할 수 있습니다. 입증은 100% 확신을 의미하며, 표본을 다룰 때는 그 정도에 도달할 수 없습니다.

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

통계적 파워라는 또 다른 p로 시작하는 용어는 종종 사람들이 그 의미를 이해하지 못하는 사람들 사이에서 사용되는 것입니다. 많은 사람들이 무언가가 높거나 낮은 통계적 파워를 갖고 있다고 말하지만, 실제로 의미하는 것은 낮거나 높은 p-값 또는 높거나 낮은 표본 크기입니다. 통계적 파워가 무엇인지 정의할 수 있는지 스스로에게 묻는 것이 중요합니다.

통계적 파워는 사실 대안 가설이 참일 때 널 가설을 기각할 확률을 나타냅니다. 이것은 기본적으로 널 가설의 기각이 얼마나 신뢰할 수 있는지 나타내는 측정 지표입니다. 이는 p-값 이상으로 많은 요소에 의해 결정되며, 샘플 크기, 알파, 효과 크기를 사용하여 계산됩니다. 실제로 더 높은 알파나 낮은 샘플 크기를 갖는 결과가 더 높은 통계적 파워를 가질 수 있는 것은 완전히 가능합니다.

데이터 과학이나 통계학에서 자주 오용되는 용어가 있나요? 그러한 경우가 있다면 언제든지 댓글을 남겨주세요.

데이터 과학에서 자주 오해받는 5가지 단어

자유 링크 — 이 LinkedIn 게시물을 좋아해 주세요

AutoGen은 Microsoft에서 개발한 프레임워크로, 특히 LLM 에이전트를 조정하는 다중 에이전트 애플리케이션 개발을 간소화하기 위해 설계되었습니다.

다중 에이전트 애플리케이션은 여러 LLM 또는 다중 모달 에이전트 또는 엔티티가 전체 워크플로에서 상호 작용하여 특정 목표나 작업을 달성하는 시스템을 의미합니다. 이러한 에이전트는 LLM 에이전트, 검색에이전트 또는 독립적인 결정을 내리거나 기능 호출 또는 조치를 취할 수 있는 다른 에이전트일 수 있습니다.

AutoGen에 대해 더 알고 싶다면 이전 기사를 참조해주세요: AutoGen In-depth yet Simple.


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

미스트랄 AI는 2023년 4월에 메타와 구글 연구원 출신인 프랑스의 AI 회사입니다. 이 회사는 오픈 대형 언어 모델 (LLM)을 제작하는 데 중점을 두며 오픈 소스 AI 모델의 중요성을 강조합니다.

이 기사에서는 AutoGen Studio의 직관적인 노코드 플랫폼과 지역 통합 미스트랄 AI 모델의 혁명적인 융합에 초점을 맞출 것입니다. 이 조합은 AI를 응용프로그램에 쉽게 통합하는 데만 그치는 것이 아니라, 다양한 생성적 AI 에이전트를 어떻게 상호 작용, 배포하며 현실적인 업계 업무 흐름에서 혜택을 누르는 데에 도움을 주는 데 있습니다.

# AutoGen Studio의 인터페이스 탐색:

## AutoGen Studio 설치


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

AutoGen Studio는 오픈 소스 코드로 여기에서 사용할 수 있으며 pip를 통해 설치할 수 있습니다.

```js
pip install autogenstudio
```

## Autogen Studio 실행

설치가 완료되면 터미널에 다음을 입력하여 웹 UI를 실행할 수 있습니다:


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


autogenstudio ui --port 8082


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

AutoGen Studio는 다중 에이전트 AI 응용 프로그램의 생성 및 관리를 용이하게 하는 간소화되고 사용자 친화적인 인터페이스를 제공합니다. 이 인터페이스는 Skills, Models, Agents 및 Workflows와 같은 몇 가지 섹션으로 분할되어 있으며, 각각이 응용 프로그램 개발에 필수적인 역할을 합니다.

## Skills



<ins class="adsbygoogle"
     style="display:block"
     data-ad-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 함수를 개발하고 저장할 수 있습니다. 여기는 응용 프로그램의 기능이 정의되고 개발되는 프로그래밍 환경입니다.

## 모델

모델 섹션은 GPT-4 및 기타 로컬 또는 사용자 정의 모델을 구성하고 관리할 수 있는 사용자 모델입니다.

사용자는 Mistral AI와 같은 모델을 설정할 수 있으며, 스튜디오가 로컬 AI 모델 통합 및 관리를 지원한다는 것을 나타냅니다. 이러한 유연성을 통해 OpenAI의 GPT-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>

# 에이전트

'에이전트' 섹션은 재사용 가능한 에이전트를 구성하는 데 사용됩니다. 사용자는 로컬 어시스턴트, 주 에이전트, 사용자 프록시 등 다양한 에이전트의 역할을 생성하고 정의할 수 있으며, 이들이 앱의 워크플로우 내에서 상호 작용하는 방식을 조율할 수 있습니다.

# 워크플로우

'워크플로우' 섹션은 마법이 일어나는 곳입니다. 사용자는 시스템이 작업을 처리하는 방식을 정의하는 복잡한 워크플로우를 설계할 수 있습니다. 이곳에서 모든 구성 요소가 하나로 결합됩니다: 'Skills'는 논리를 제공하고, 'Models'는 AI의 지능을 제공하며, '에이전트'는 작업을 수행하며, '워크플로우'는 모든 것을 일관된 시스템으로 연결합니다.


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

플랫폼의 인터페이스는 직관적이며 각 섹션이 명확히 표시되어 있고 시각적 레이아웃을 통해 네비게이션을 간단하게 유도합니다. 새로운 에이전트, 모델 또는 기술을 추가하는 경우, 일반적으로 몇 번의 클릭만으로 간단한 프로세스로 진행됩니다. 생생한 색상과 현대적인 디자인 요소의 사용으로 사용자 경험을 쾌적하고 사용하기 쉽게 만듭니다.

## 지역 미스트랄 AI 모델 통합

지역 미스트랄 AI 모델을 AutoGen Studio의 생태계에 통합하는 것은 매우 쉽고 직관적입니다. 사용자는 자신의 지역 모델을 스튜디오에 추가하고 앱 내의 다른 구성 요소와 상호작용하는 방법을 정의할 수 있습니다. GPT-4 비전, GPT 3.5, GPT 4 turbo와 같은 다중 모달 모델의 파워와 미스트랄 AI와 같은 지역 모델을 결합해야 하는 사용자들에게 특히 유용합니다.

요약하자면, AutoGen Studio는 다중 에이전트 AI 기반 응용 프로그램을 구축하기 위한 포괄적이고 접근하기 쉬운 도구로, 다양한 AI 모델 및 사용자 정의 기술을 수용하여 개발자와 비즈니스에게 다재다능한 선택지를 제공합니다.


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

# 로컬 Mistral AI 모델 설정하기:

로컬 Mistral AI 모델 설정은 여러 단계로 이루어져 있으며, 각 단계마다 시스템이 Ollama사의 Mistral 모델과 같은 대규모 언어 모델을 로컬에서 실행할 수 있는 환경으로 준비됩니다. 각 단계와 그 필요성에 대한 설명은 다음과 같습니다:

- Ollama 설치: Ollama는 대규모 언어 모델에 액세스할 수 있는 플랫폼입니다. Ollama를 설치하는 것은 첫 번째 단계이며, Mistral 모델이 실행될 환경입니다. 이를 통해 사용자는 Llama 2, Code Llama, Mistral과 같은 기존 모델을 실행하거나 사용자 정의 및 배포할 수 있습니다. Ollama는 다음 링크에서 다운로드할 수 있습니다: https://ollama.ai/

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

2. Ollama Mistral 실행: Ollama 플랫폼에서 아래 명령을 실행하여 Mistral 모델을 시작합니다. 이 명령은 모델을 설정하고 필요한 데이터를 로드하며 쿼리 처리를 담당하는 서비스를 시작합니다.

```js
ollama run mistral
```

2. LiteLLM 설치: LiteLLM 라이브러리는 http 엔드포인트에서 언어 모델을 실행하는 데 도움을 주는 도구입니다. LiteLLM을 설치하거나 업그레이드하면 라이브러리의 최신 버전을 사용할 수 있어서 호환성과 기능의 관점에서 중요합니다.

```js
pip install litellm --upgrade
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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. Gunicorn 설치: Gunicorn은 UNIX 시스템용 Python WSGI HTTP 서버로, Python 웹 애플리케이션을 실행하는 데 사용됩니다. LiteLLM 프록시를 실행하는 데 필요하며 이를 통해 귀하의 언어 모델에 로컬 HTTP 요청을 보낼 수 있습니다.

```js
pip install gunicorn
```

4. Ollama/Mistral 모델을 사용하여 LiteLLM 실행: 이 단계는 모델을 초기화하고 실행할 준비를 하는 과정입니다. 이 명령은 LiteLLM이 Ollama가 제공하는 Mistral 모델을 사용하도록 지시합니다. 상호작용을 위해 모델을 준비하여 쿼리를 시작하고 응답을 받을 수 있게 합니다.

이 프로세스가 끝나면 로컬의 Mistral 모델이 0.0.0.0:8000에서 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>

이러한 각 단계는 로컬에서 AI 모델과 상호 작용할 수 있는 완전한 작업 환경을 설정하는 데 필요합니다. 이 로컬 설정을 통해 개발자는 클라우드 서비스와 지속적으로 통신할 필요 없이 AI 모델을 테스트하고 통합할 수 있습니다. 이는 개발 속도, 오프라인 기능, API 호출 비용 절감 등에 도움이 될 수 있습니다.

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

# AutoGen 및 Mistral AI와의 Workflow Orchestration:


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

파이썬 스크립트를 작성하여 사인 파형을 그래프로 그리고 'sine_wave.png' 파일로 저장하는 상황에서 AutoGen과 Mistral AI를 함께 사용하여 원활한 워크플로우를 만들 수 있습니다. AutoGen Studio는 멀티 에이전트 애플리케이션을 구축하고 관리하기 위한 인터페이스로 작용하며, Mistral AI는 로컬 모델을 통해 처리 능력을 제공합니다.

다음은 두 플랫폼의 기능을 활용하여 오케스트레이션하는 방법입니다:

## 1. 워크플로우 생성:

- AutoGen Studio에서 사인 파형 이미지를 생성하는 특정 작업을 위한 새로운 워크플로우를 시작합니다.
- 우리는 워크플로우에 "Local mistral Agent Workflow"와 같은 이름을 구성합니다.
- 워크플로우 사양에는 송신자 및 수신자 에이전트가 포함되어 있으며, 'userproxy'가 요청을 시작하는 송신자로, 'primary_assistant'가 요청을 처리하고 출력을 제공하는 수신자로 지정될 수 있습니다.
- 사용자 프록시의 역할은 사용자와 상호 작용하고 primary_assistant가 생성한 코드를 실행하는 것입니다. 코드에 오류가 발생하면 해당 오류를 primary_assistant 에이전트에 보냅니다.
- primary_assistant 에이전트는 로컬 Mistral AI 모델을 활용하여 우리 시나리오에서 코드를 생성합니다. 코드에 오류가 있으면 사용자 프록시 에이전트가 보낸 실행 오류에 따라 코드를 조정합니다.


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

## 2. 모델 구성:

- '미스트랄 로컬 모델'이라는 모델이 AutoGen Studio 내에 설정되어 Mistral AI와 상호 작용하도록 구성됩니다.
- 모델의 API 엔드포인트는 Mistral AI가 실행 중인 로컬 서버 주소로 구성됩니다 (예: http://0.0.0.0:8000).
- 이 설정을 통해 AutoGen Studio가 데이터를 Mistral AI 모델로 보내고 처리된 결과를 받을 수 있습니다.

## 3. 세션 실행:

- AutoGen Studio의 'Playground' 인터페이스에서 사용자는 '로컬 미스트랄 에이전트 워크플로'를 선택하여 새 세션을 시작합니다.
- 사용자는 삼각파 플롯을 생성하기 위한 명령 또는 요청을 입력합니다.
- 요청은 사용자 프록시 에이전트가 주요 어시스턴트 에이전트로 전송되어 Mistral AI 모델을 활용합니다. 이렇게 하여 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>

## 4. 결과 및 검토:

- Mistral AI에서 스크립트를 실행하면 'sine_wave.png' 파일이 생성되어 디스크에 저장됩니다.
- AutoGen Studio 인터페이스에서는 세션 진행 상황 및 결과가 표시되며, 'sine_wave.png' 파일과 'sine_wave'를 플로팅하는 파이썬 코드가 생성됩니다.
- 사용자는 결과를 검토하고, 널리 사용할 수 있도록 워크플로를 게시하거나, 처음부터 다시 시작하려면 모델을 삭제하거나, 스크립트를 개선하고 워크플로 매개변수를 더 세밀하게 조정하기 위해 추가적으로 반복할 수 있습니다.

# 결론:

AutoGen Studio와 로컬 Mistral AI 모델은 GenAI 에이전트의 워크플로를 조정하는 데 주요한 진전을 보여줍니다. 이 아키텍처는 AutoGen Studio의 직관적인 디자인과 Mistral AI의 우수한 성능을 결합하여, 다중 에이전트가 기여할 수 있는 환경을 구축합니다.


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

AutoGen Studio와 로컬 Mistral AI 모델의 장점:

- 쉬운 통합: 로컬 Mistral AI 모델이 AutoGen Studio에 쉽게 통합되어 다양한 LLM 모델을 한 배포로 효율적으로 활용하는 과정을 간소화합니다.
- 맞춤 및 유연성: 개발자들은 AI 모델을 특정 요구 사항에 맞게 맞춤화하여 하나의 프로젝트의 다양한 필요에 완벽히 맞는 맞춤형 솔루션을 제공할 수 있습니다.
- 향상된 성능: AutoGen과 함께 로컬에서 AI 모델을 실행하면 지연 시간이 줄어들고 응답 시간이 향상되어 실시간 애플리케이션 및 민감한 작업에 중요합니다.
- 데이터 개인 정보 보호 및 보안: AI 모델의 로컬 실행은 데이터에 대한 완전한 통제를 제공하며 외부 환경에 노출되어서는 안 되는 민감하거나 전문성이 있는 정보에 대해 핵심적인 역할을 합니다.
- 비용 효율성: 클라우드 기반 AI 서비스에 대한 의존을 최소화하여 데이터 전송 및 LLM API 사용과 관련된 비용을 크게 절감할 수 있습니다.
- 오프라인 기능: 로컬 Mistral AI 모델을 사용하면 인터넷 연결이 없어도 시스템이 작동되는 것을 보장하여 AI 기반 솔루션의 오프라인 기능을 허용합니다.
- UI로 복잡한 AI 워크플로우 작성: 사용자는 AutoGen Studio의 노코드 인터페이스를 활용하여 AI 기반 워크플로우를 직관적으로 설계하고 관리할 수 있습니다.

이 기사에서는 AutoGen Studio와 로컬 Mistral AI 모델의 통합이 GenAI 워크플로우의 세계에서 혁명적인 발전을 가져왔습니다. 성장하는 고급 AI 애플리케이션 수요를 충족시키는 사용자 친화적이고 유연하며 비용 효율적인 솔루션을 제공하여 AI 애플리케이션을 만들기가 언제보다 쉬워졌습니다.

# 떠나기 전에! 🦸🏻‍♀️


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

- 만약 이 글이 유익하다고 느끼신다면, 이 LinkedIn 글을 ‘좋아요’해 주세요. 또한 무료 친구 링크를 LinkedIn 글에서 찾을 수 있습니다. 여러분의 참여는 이 글을 더 홍보하는 데 도움이 될 것이며, 여러분의 지지는 저에게 큰 원동력이 됩니다. ✍🏻🦾❤️
- 이 글을 50번 클랩해 주시면, 정말로 저를 도와주시고 다른 사람들에게 이 글을 알릴 수 있습니다. 👏
- 제 최신 글을 보려면 Medium, LinkedIn에서 팔로우하고 구독해주세요. 🫶

# 흥미 있는 주제라면, 더 많은 글을 읽어보실 수 있습니다.

코드 없는 GenAI 에이전트 워크플로우 오케스트레이션 로컬 Mistral AI 모델과 함께하는 AutoGen Studio 사용법

선형 회귀는 머신 러닝 세계에서 가장 기본적인 알고리즘 중 하나이며, 분석의 ABC와 같습니다.

하늘의 별무리를 통해 가장 적합한 선을 만든다고 생각해보세요. 여기서 각 별은 데이터 점을 나타냅니다.

오늘은 선형 의존성의 클래식 예시 중 하나인 키와 몸무게를 활용해 실제 세계 머신 러닝에 대해 알아보겠습니다 👇🏻

# 기본 원리 이해하기


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

그러니까 이 작업을 어떻게 수행할 수 있는지 살펴보겠습니다...

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


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

파이썬의 df.info()로 간단히 살펴보면 수천 개의 항목이 있고 중요한 것은 결측값이 없다는 것입니다.

그리고 데이터의 분포는 어떤가요?

키에 대한 종모양 곡선 하나와 몸무게에 대한 종모양 곡선 하나를 생각해보세요. 두 곡선 모두 나비 날개만큼 대칭적인데요 — 바로 여기가 우리의 정규 분포입니다.



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

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

# #2. 최적 선을 찾는 방법

우리의 최적 선을 얻기 위해서는 여러 가지 방법이 있습니다. 오늘날 대다수의 사람들은 scikit-learn을 활용하여 미리 빌드된 선형 회귀 알고리즘을 적용할 것입니다.

그러나 이번에는 최초로 세 가지 다른 방법을 시도해 봅시다:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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 DIY — 모두 스스로 알고리즘 생성.
- 1 최종 방법은 scikit-learn 활용하는 것.

## 접근 방법 #1: 최소 제곱법 (OLS)

최소 제곱법(OLS)의 목적은 예측 오차의 제곱을 최소화하여 최적의 계수 A와 B를 결정하는 것입니다 — 이것이 바로 선형 회귀의 비용 함수인 MSE입니다.

미적분을 활용하여 비용 함수의 최소값을 찾기 위해 편미분의 성질을 이용합니다. 그리고 이러한 편미분이 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>

위 수학 문제를 해결하여 A와 B에 대한 정확한 닫힌 수학 공식을 얻게 되면, 가장 정확한 선형 모델로 향하는 직접적인 경로를 얻을 수 있습니다.

![링크](/TIL/assets/img/2024-07-14-SimplifyingLinearRegressionABeginnersGuidewithareal-worldPracticalExample_3.png)

이것은 이러한 수학적인 닫힌 해결책을 찾기 위해 몇 줄의 코드를 정의하는 것으로 번역됩니다. 그래서 매우 직관적입니다.

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

경사 하강은 비용 함수를 최소화하는 데 사용되는 중요한 최적화 알고리즘으로, 예측 모델의 가장 정확한 가중치 값을 찾는 데 도움을 줍니다.

언덕 꼭대기에 서 있는 것으로 상상해보세요. 여러분의 목표는 아래의 계곡에 있습니다. 이것은 비용 함수의 최솟값을 나타냅니다.

이를 달성하기 위해 가중치 A와 B에 대한 초기 추정치로 시작하여 이 추정치를 반복적으로 개선합니다.

이 과정은 언덕을 내려가는 것과 유사합니다. 각각의 단계에서 우리는 주변 환경을 평가하고, 각각의 다음 단계가 계곡 바닥에 더 가까워지도록 우리의 궤적을 조정합니다.


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

이러한 단계는 학습 속도에 의해 안내됩니다 — 방정식에서 lr로 상징되는 중요한 하이퍼파라미터입니다. 이 학습 속도는 매개변수 A와 B에 대한 조정이나 단계의 크기를 제어하여 최소값을 초과하지 않도록 합니다.

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

각 단계에서 비용 함수의 A 및 B에 대한 편도함수인 dA와 dB를 계산합니다. 이 도함수는 우리에게 비용 함수가 가장 빨리 감소하는 방향을 가리키는데, 이것은 비유적인 언덕에서 가장 가파른 하강 경로를 찾는 것과 유사합니다.

각 반복에서 A와 B에 대한 업데이트된 방정식은 다음과 같습니다.


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

지침대로 테이블 태그를 마크다운 형식으로 변경하겠습니다.


This meticulous process is repeated until we reach a point where the cost function’s decrease is negligible, suggesting we’ve arrived at or near the global minimum — our destination where the predictive error is minimized, and our model’s accuracy is maximized.

![Image](/TIL/assets/img/2024-07-14-SimplifyingLinearRegressionABeginnersGuidewithareal-worldPracticalExample_5.png)

This translates into defining two main functions:

- The function to compute MSE



<ins class="adsbygoogle"
     style="display:block"
     data-ad-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를 업데이트하는 기능

우리는 코드를 다음과 같이 초기화합니다:

- A = 0
- B = 0
- 학습률 0.0001(학습률은 알고리즘이 더 빠르게 또는 더 느리게 학습할 수 있도록 합니다).
- 최대 반복 횟수

그래서 최종 코드는 다음과 같습니다:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-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: Sci-Kit Learn — 파이썬의 강력한 무브

파이썬을 좋아하는 사람들을 위해, Sci-Kit Learn은 머신 러닝을 위한 스위스 아미 나이프입니다. 회귀, 분류, 클러스터링 등을 위한 다양한 도구로 가득합니다.

우리가 해야 할 일은 LinearRegression 라이브러리를 가져와서 객체를 만들고, 데이터로 훈련시키는 것뿐입니다.

몇 줄의 코드로 이를 구현할 수 있습니다:


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


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

With the data we crunched, A turned out to be around 7.17, and B was approximately -350.73.

What does this mean?

For every inch of height, the weight increases by about 7.17 units, minus our intercept value.



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

데이터 분석의 매력은 그 간단함에 있습니다.

복잡한 모델을 사용하는 것이 중요한 게 아니라, 올바른 모델을 올바른 상황에 사용하는 것이 중요한 거죠.

이 개념을 소화하면, 당신은 데이터 속에 숨겨진 이야기를 발견하는 길에 여러분이 잘 나아가고 있습니다.

호기심을 가져라, 데이터 우주를 계속 탐험해 보세요! 🤓


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

다음의 GitHub 저장소에서 코드를 확인할 수 있어요.

ForCode’Sake를 팔로우하면 이와 유사한 기사를 더 많이 볼 수 있어요! ✨

MLBasics 이슈가 마음에 드셨나요? 그렇다면 DataBites 뉴스레터에 가입하여 최신 내용을 이메일로 받아보세요!

유니크한 콘텐츠를 약속합니다!


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

데이터 과학자 또는 데이터 엔지니어가 되기 위한 훌륭한 데이터 과학 로드맵을 확인해보세요! 🤓

또한 ML, SQL, Python 및 DataViz에 관한 매일 게시하는 치트 시트를 확인할 수 있는 X, Threads 및 LinkedIn에서 저를 만날 수도 있습니다.

Posts