대학원생이 쉽게 설명해보기

몇일 간격으로 Modular 를 모니터링하긴 하는데,

1.0v 처럼 오피셜은 아니지만 0.1.0v으로 곧 local 환경에서 만날 날은 진짜 얼마 안남은 것 같다

https://www.modular.com/

관심있으면 이메일을 등록해두고, Docs를 읽어보자. 그것과 더불어 아래 Keynote는 천천히 보다보면 재밌다. 만든 사람이 직접 브리핑하기도 하고..

https://www.modular.com/keynotes/2023

문서같은 경우는 확실히 초반에 개발이 바빠서인지는 몰라도 전반적으로 언어에 대한 설명이 부족했는데,
그때의 Docs랑 지금 Docs는 완전히 다른 차원이라는 것은 몸소 느껴진다.

지금까지 봐온 새롭게 만들어진 언어들이 그랬듯이 이제 머지않아 공식 Docs가 생기고, 핵심 언어의 번역 프로젝트도 시작되지 않을까 생각한다.

위에 말이랑 비슷하지만 Docs가 모습을 갖춘다는 것은 이제 곧 공식적으로 된다는 것을 의미하는 것 같고, 마치 예전 TensorFlow를 보는 것 같아서 굉장히 느낌이 새롭다

- Mojo Docs : https://docs.modular.com/

- Mojo git : https://github.com/modularml/mojo

1. Python의 상위 호환(superset)이다.
2. AI 프로그래밍의 불편함을 해소하고자 시작된 프로젝트이다.
3. C++, Rust 등 low 언어 문법과 (high) Python 문법이 혼합되어 있으며(let, var, struct, 메모리 관리 기법 등),
   아직 Python 문법을 100% 지원하지는 않는다.
4. Python에서 함수 정의를 위해 사용하는 def 대신 좀더 strict한 fn을 제공한다.
    서로 기능은 동일하나, fn 이 def보다 좀 더 limited, controlled 하다고 한다. input, output의 타입은 필수로 명시하는 등.

struct Complex:
    var re: Float32
    var im: Float32

    fn __init__(inout self, x: Float32):
        """Construct a complex number given a real number."""
        self.re = x
        self.im = 0.0

    fn __init__(inout self, r: Float32, i: Float32):
        """Construct a complex number given its real and imaginary components."""
        self.re = r
        self.im = i

5. Python 대표 모듈은 당연히 사용가능하게끔 지원한다. NumPy, Pandas 등

문서에 나온 예제를 보면 언뜻 다음 느낌을 받을 수 있는데, 물론 자세한 것은 아니고 느낌이 그렇다는
ㅇ 파이썬이 가지고 있는 강점은 살리면서,
- 쉬운 문법, 사용자를 바라보는 철학, 다른 라이브러리와의 비교적 쉬운 혼합(binding)
ㅇ 파이썬에 존재하는 본질적인 단점을 해결하는 느낌이다.
- 시스템 프로그래밍, 타언어에 비해 불안정적인 배포

Docs에 매우 자세하게 많은 것들이 설명돼있으니 시간을 가지고 천천히 전부 읽어보면 도움이 많이 될 것 같다.

물론 아직 신규 언어라 다른 언어 문서에 비하면 내용이 적다고 생각할 수 있지만 기본적으로 파이썬과 C 언어를 읽을 수 있으면, 전부 이해할 수 있을정도로 쉽게 설명해놓았다.

뭔가 다른 언어에 파이썬이 겹쳐있는 느낌이라 매우 흥미롭게 느껴진다. 시간이 지날수록 Mojo가 어떻게 될지, Python은 어떻게 반응할지 엄청 궁금해지는 바이다.

데이터 분석 및 전처리시 자주 사용되진 않지만 필수적으로 알아두어야 할 방법들입니다.

- explode, Reverse explode, melt, cut, qcut

여기선 다루지 않지만 행(row), 열(column)을 쉽게 조작하게 도와주는 stack(), unstack() 함수도 유용합니다.

explode

list로 이루어진 데이터(column)를 다수의 행으로 펼쳐주는 방법, explode() 를 사용하면 손쉽게 해결할 수 있습니다.

df = pd.DataFrame({
    'SEG': ['A', 'B'],
    'VALUE': [[17, 23, 54], [19, 28, 51]]
})

df.explode('VALUE')

Reverse explode

위 방법의 반대입니다.
각 seg 별로 값을 list 형태로 합쳐줄 수 있습니다.

# as_index : index 해제
# agg : 각 SEG가 가지고 있는 VALUE를 tolist()함
ep_df.groupby('SEG', as_index = False).agg(lambda x: x.tolist())

melt

열을 행으로 펼쳐주고, 새로운 열을 생성합니다. 행과 열을 프로덕트(product)하여 column을 row value로 펼쳐줍니다. melt()를 활용합니다.

df = pd.DataFrame({
    'SEG': ['A', 'B'],
    'VALUE_1': [17, 23],
    'VALUE_2': [19, 28],
})

df.melt(id_vars = ['SEG'], value_vars = ['VALUE_1', 'VALUE_2'], 
		var_name = 'VALUE_SEG', value_name = 'VALUES')

stack() 을 활용하면 동일한 결과를 얻을 수 있습니다.

df.set_index('SEG').stack().to_frame(name = 'VALUES').reset_index()

cut, quct을 활용한 category encoding

숫자 형태 데이터에 category encoding을 수행하고 싶을때,

qcut(), cut() 을 활용하면 원하는 전처리를 수행할 수 있습니다.

df = pd.DataFrame({
    'AGES': [11, 16, 18, 
             21, 24, 29,
             30, 35, 36,
             40, 42, 43]
})

age_bins = [10, 20, 30, 40, 50]

df['AGE_SEG_cut'] = pd.cut(df['AGES'], age_bins)
df['AGE_SEG_qcut'] = pd.qcut(df['AGES'], q = 5)

원래 INDEX + MATCH 함수를 사용해서 VLOOKUP을 대체하는 등을 자주 사용하곤 하지만,
INDEX + COUNTA 함수를 조합해서도 유용하게 업무를 자동화할 수 있다.

< INDEX >
특정 범위와 찾을 값의 위치를 입력하면, 해당 값을 출력
INDEX(범위, 찾을 값의 위치)

< COUNTA >
해당 범위에 비어있지 않은 셀의 갯수를 출력
COUNTA(범위)

위 예시에서 1월 1일의 경우 아래와 같이 함수를 사용합니다 
=INDEX(J6:ZZ6, COUNTA(J6:ZZ6)-3)

이런식으로 조합해서 사용하면 '1월 5일', '1월 6일' 등 날짜가 바뀌어도(1월 4일 옆으로 열이 추가돼도)
최근 4일의 값을 가져오게끔 자동화를 시켜놓을 수 있어 매우 편리합니다.

아래 블로그의 방법이 파이썬스럽고 깔끔해보인다.

https://velog.io/@jongmin97/hackerRank-ACM-ICPC-Team

def acmTeam(topic):
    # Write your code here
    result = [0, 0]
    
    for i in range(len(topic) - 1):
        for j in range(i + 1, len(topic)):
            sum_pair = str(int(topic[i]) + int(topic[j]))
            count = sum_pair.count('1') + sum_pair.count('2')
            
            if count > result[0]:
                result[0] = count
                result[1] = 1
            elif count == result[0]:
                result[1] += 1
            
    return result

가장 원시적이라고 생각했던 방법이 좋은 방법 중 하나였다.

def queensAttack(n, k, r_q, c_q, obstacles):
    # Write your code here
    if n == 0:
        return 0
    
    # Timeout 방지
    obs = dict()
    if(obstacles): 
        for ob in obstacles:
            obs[ob[0],ob[1]] = 1
 
    row_move = [1, -1, 0, 0, 1, -1, 1, -1]
    col_move = [0, 0, -1, 1, -1, -1, 1, 1]
    
    tot_attack = 0
    
    for r_m, c_m in zip(row_move, col_move):
        r = r_q + r_m
        c = c_q + c_m
        
        while True:
            if (r, c) in obs:
                break
            if r < 1 or r > n or c < 1 or c > n:
                break
            
            r += r_m
            c += c_m
                
            tot_attack += 1    
            
    return tot_attack

def equalizeArray(arr):
    # Write your code herepopo
    num_dict = {}
    
    for i in arr:
        if num_dict.get(i):
            num_dict[i] += 1
        else:
            num_dict[i] = 1
            
    key_value = sorted(num_dict.items(), key = lambda x: x[1], reverse = True)[0][0]
    k_num = arr.count(key_value)
    
    return len(arr) - k_num

def jumpingOnClouds(c):
    # Write your code here
    current = 0
    needed_jump = 0
    
    while current < len(c):
        p = current + 1
        pp = current + 2
        
        if pp < len(c) and c[pp] != 1:
            current = pp
        elif p < len(c) and c[p] != 1:
            current = p
        else:
            break
            
        needed_jump += 1
        
    return needed_jump

def repeatedString(s, n):
    # Write your code here
    
    s_len = len(s)
    
    if s_len == 1 and s == 'a':
        return n
    else:
        a_num = 0
        for i in s:
            if i == 'a':
                a_num +=1
                
        a_num = a_num * (n // s_len)
        if n % s_len != 0:
            for i in range(n % s_len):
                if s[i] == 'a':
                    a_num += 1
            
        return a_num

1. K로 나눠지는지를 볼때 두 수의 합은 두 수의 나머지의 합을 봐도 무방함
2. 두 수의 합이므로 K // 2 의 범위에서 떨어지지 않는 수를 찾고, count가 더 많은 수를 더해줌
3. 짝수인 경우엔 하나만 고려해서 더해줌

def nonDivisibleSubset(k, s):
    # Write your code here
    r = [0] * k
    cnt = 0
    
    for i in s:
        r[i % k] += 1
            
    for i in range(k//2 + 1):
        if i == 0 or k == i * 2:
            cnt += bool(r[i])
        else:
            cnt += max(r[i], r[k - i])
    
    return cnt

상세 설명 ↓
https://cs.stackexchange.com/questions/57873/maximum-subset-pairwise-not-divisible-by-k