서울숲 일별 평균 대기오염도 데이터베이스는 2022년 서울숲 대기오염도 측정소에서 매일 기록한 대기오염 정보를 담고 있습니다.

measurements 테이블의 pm10 컬럼에는 다양한 대기오염도 측정 기준 중에서도 미세먼지(PM10) 농도가 기록되어 있습니다. 이 데이터를 이용하여 당일의 미세먼지 농도보다 바로 다음날의 미세먼지 농도가 더 안좋은 날을 찾아주세요. 결과는 아래 컬럼들을 포함해야 합니다.

• today: 당일 (YYYY-MM-DD)
• next_day: 다음날 (YYYY-MM-DD)
• pm10: 당일의 미세먼지 농도
• next_pm10: 다음날의 미세먼지 농도

풀이

WITH t AS
  (SELECT measured_at today,
          lead(measured_at) over(order by measured_at) next_day,
          pm10,
          lead(pm10) over(order by measured_at) next_pm10
  FROM measurements
  )

SELECT *
FROM t
WHERE next_pm10 > pm10;

이번에 SQL감을 다시 찾으려 solvesql 풀었던 문제를 다시 풀어 보고 있다. 사실 문제를 봤을때 원래는 머릿속에서 풀이가 정리되었지만, 지금은 바로 떠오르지는 않았다.

그래도 조금 생각해봤을때, 윈도우 함수의 lead를 생각나서 적용했다. 문제를 잘못봐서 WHERE 구문을 반대로 작성해서 2번 정도 틀렸다ㅜㅜ 그래도 일주일 정도 1문제씩 풀면 원래 실력은 다시 나올것 같다.

솔직히 취준 기간 동안 서류에서 탈락을 많이 해서 자존감이 낮아진 상황이었는데, 다행히 서류합격을 해서 코테를 볼 수 있었다.

처음 본 코테는 기존의 코테 사이트의 문제와는 조금 거리가 있었고 실무에서 사용할 만한 쿼리를 요구했다.

그런 쿼리들은 프로젝트나 개인 공부를 통해 여러번 작성한 경험이 있어서 그렇게 어렵게 느껴지진 않았다.

결과는 당연히 합격!

인터뷰를 준비할 때는 지원동기, 자기소개, 프로젝트나 지금까지 했던 경험을 정리하면서 준비했던 것 같다

면접 당일에 찍은 사진!

면접 결과는???

안탑깝게도 탈락... 사실 메일 제목을 보고 어느정도 예감해서 크게 충격은 없었다. 그래도 면접까지 갔다는 거는 최소한 서류나 내 실력은 크게 문제 없다는 생각을 들게 해줘서 좋았다.(합격했으면 더 좋았겠지만)

그래도 조금 더 힘을 내자!

문제 설명

각 세대별 자식이 없는 개체의 수(COUNT)와 세대(GENERATION)를 출력하는 SQL문을 작성해주세요. 이때 결과는 세대에 대해 오름차순 정렬해주세요. 단, 모든 세대에는 자식이 없는 개체가 적어도 1개체는 존재합니다.

이 문제에서는 generation 컬럼을 만들기 위해서는 recursive CTE 작성이 필수

RECURSIVE CTE

WITH RECURSIVE 쿼리문을 작성하고 내부에 UNION을 활용해서 재귀를 구성한다

주의사항 종료 조건이 없다면 무한 루프 발생 (무조건 WHERE 등으로 제한 필요)

DBMS마다 RECURSIVE 키워드를 써야 할 수도 있고 안 써도 되는 경우도 있음 (예: PostgreSQL: WITH RECURSIVE, MySQL: WITH RECURSIVE, SQL Server: WITH)

MySQL은 기본적으로 1000회 재귀 제한 (max_recursion_depth)

UNION ALL 대신 UNION을 쓰면 중복 제거되나 성능 저하 가능

정답 쿼리

WITH recursive t as (
    SELECT id, 1 generation
    FROM ecoli_data ed
    WHERE parent_id is null

    UNION ALL

    SELECT ecoli_data.id, generation + 1
    FROM ecoli_data
    JOIN t on ecoli_data.parent_id = t.id
)

SELECT count(*) `count`, generation 
FROM t
WHERE id not in (SELECT parent_id
                FROM ecoli_data
                WHERE parent_id is not null)
GROUP BY 2

리뷰

Anchor 쿼리: 최초 대장균 개체 (parent_id가 없는 개체)를 generation 1로 시작

Recursive 쿼리: 부모 개체를 따라가며 generation을 1씩 증가시킴

마지막 조회하는 구문에서 not null 조건을 안넣으면 in 조건에서는 어떤 것도 반환하지 않음

🎯 문제 목표 다음 조건을 모두 만족하는 대장균 개체의 수(COUNT)를 구하라.

2번 형질을 보유하지 않음

1번 또는 3번 형질을 보유함

1번과 3번을 동시에 보유해도 포함

접근 방식

초반에는 genotype에서 나머지 연산자를 활용해서 쿼리를 작성함 -> 쿼리를 이해하기 어려워서 비트 연산자 활용해서 문제를 풀었음

정답 쿼리

SELECT count(*) `count`
FROM ecoli_data
WHERE genotype & 2 = 0
AND (genotype & 4 > 0 or genotype & 1 > 0)

genotype & 2 인 이유: 2번 형질을 포함하지 않아야 하니까 = 0으로 조건 genotype & 4 > 0 or genotype & 1 > 0: genotype & 4 = 1로 하면 세번째 비트 값만 켜질 때만 필터링되서 > 0으로 설정하면 모두 포함됨

문제 2: 프로그래머스

DEVELOPERS 테이블에서 Front End 스킬을 가진 개발자의 정보를 조회하려 합니다. 조건에 맞는 개발자의 ID, 이메일, 이름, 성을 조회하는 SQL 문을 작성해 주세요. 결과는 ID를 기준으로 오름차순 정렬해 주세요.

접근 방식

비트 연산자를 사용해 어떤 스킬이 포함되어 있는지 확인 Front End 기술이 포함된 경우만 필터링 하고 & > 0을 활용해 기술을 포함하는지 확인 Exists 사용 이유: Exists는 조건을 만족하는 서브쿼리 결과가 1개라도 존재한면 true (Front End 기술이 1개라도 있으면 결과에 포함)

정답 쿼리

SELECT id, email, first_name, last_name
FROM developers d
WHERE exists (SELECT 1
             FROM skillcodes s
             WHERE category = 'Front End'
             AND (s.code & d.skill_code) > 0
             )
ORDER BY 1;

문제 3: 프로그래머스

부모의 형질을 모두 보유한 대장균의 ID(ID), 대장균의 형질(GENOTYPE), 부모 대장균의 형질(PARENT_GENOTYPE)을 출력하는 SQL 문을 작성해주세요. 이때 결과는 ID에 대해 오름차순 정렬해주세요.

접근 방식

부모의 genotype 컬럼을 추가하는 CTE 구문을 작성한 후, 비트 연산자를 활용해서 자식의 genotype이 부모의 genotype을 포함한 것만 필터링.

정답 쿼리

WITH t as
    (SELECT id, parent_id, genotype, (SELECT genotype
                                     FROM ecoli_data
                                     WHERE ed.parent_id = ecoli_data.id) parent_genotype
     FROM ecoli_data ed
    )


SELECT id, genotype, parent_genotype
FROM t
WHERE (genotype & parent_genotype) = parent_genotype
ORDER BY 1;

WHERE (genotype & parent_genotype) = parent_genotype genotype이 parent_genotype의 genotype을 포함

문제4: 프로그래머스

DEVELOPERS 테이블에서 GRADE별 개발자의 정보를 조회하려 합니다. GRADE는 다음과 같이 정해집니다.

A : Front End 스킬과 Python 스킬을 함께 가지고 있는 개발자 B : C# 스킬을 가진 개발자 C : 그 외의 Front End 개발자 GRADE가 존재하는 개발자의 GRADE, ID, EMAIL을 조회하는 SQL 문을 작성해 주세요.

결과는 GRADE와 ID를 기준으로 오름차순 정렬해 주세요.

접근 방식

CTE 절에서 case 구문을 이용해 grade 컬럼을 만들어야한다 case 구문에서는 비트 연산자를 활용해 가진 기술이나 카테고리의 포함여부를 확인

초반에는 case 순서를 C -> B -> A로 설정해서 C로 설정된 row의 경우 C의 조건이 맞던 무시하기 때문에 A가 1명도 없었다

복합조건을 앞에 배치해야한다는 사실을 잊고있어서 조금 시간이 걸렸다 case 구문을 A -> B -> C로 설정하니 잘 작동되었다.

정답 쿼리

WITH t as
    (SELECT *,
        case when exists (SELECT 1
                         FROM skillcodes s
                         WHERE category = 'Front End' and (s.code & d.skill_code) > 0)
                  and exists (SELECT 1
                             FROM skillcodes s
                             WHERE name = 'Python' and (s.code & d.skill_code) > 0)
             then 'A'

            when exists (SELECT 1
                          FROM skillcodes s
                          WHERE name = 'C#' AND (s.code & d.skill_code) > 0) 
             then 'B'

             when exists (SELECT 1
                         FROM skillcodes s
                         WHERE category = 'Front End' AND (s.code & d.skill_code) > 0)
             then 'C'
             end grade
FROM developers d
)

SELECT grade, id, email
FROM t
WHERE grade is not null
ORDER BY 1, 2;

문제

Leetcode: Find Product Recommendation Pairs [medium]

고객들의 구매 데이터를 분석하여, 같은 고객이 함께 구매한 상품 쌍(product pair) 중공통 구매자가 2명 초과인 상품 조합을 찾아보세요.

각 상품 쌍에 대해 다음 정보를 출력해야 합니다:

• product1_id, product2_id: 함께 구매된 상품 ID

• product1_category, product2_category: 각각 상품의 카테고리

• customer_count: 두 상품을 모두 구매한 고객 수
  또한, customer_count가 2명 초과인 조합만 필터링하고, customer_count 기준으로 내림차순 정렬하세요.
  출력 결과 product1_id | product2_id | product1_category | product2_category | customer_cnt

ProductPurchases 테이블

ProductInfo 테이블

문제 접근 방식

처음에는 제품 쌍(product1, product2)별 product_id와 category 정보를 먼저 구성한 뒤, 이를 기반으로 JOIN을 이용해 함께 구매한 사용자 수를 구하고자 했습니다. 하지만 처음 구상한 방식대로는 잘 되지 않아 시행착오가 있었습니다.

특히 CROSS JOIN은 평소에 자주 사용하지 않던 연산이라, 조합을 구성하는 부분에서 논리적으로 정리가 잘 되지 않았던 점이 아쉬웠습니다.

최종적으로는 SELF JOIN과 CROSS JOIN을 활용하여 제품 간 조합을 구성하고, 중복 조합(예: 101–102 vs 102–101)을 제거하기 위해 조인 조건에 a.product_id < b.product_id를 추가하는 방식으로 문제를 해결했습니다.

이 조건 덕분에 순서만 다른 동일한 조합이 중복으로 포함되는 것을 방지할 수 있었고, 불필요한 계산도 줄일 수 있었습니다.

정답 쿼리

WITH t as 
    (
        SELECT user_id, pp.product_id, category
        FROM productpurchases pp
        JOIN productinfo pri on pp.product_id = pri.product_id
    ),

    t2 as 
    (
        SELECT a.product_id product1_id, b.product_id product2_id,
            a.category product1_category, b.category product2_category
        FROM t a
        CROSS JOIN t b on a.product_id < b.product_id
        GROUP BY 1, 2
    ),

    t3 as
    (
        SELECT a.product_id product1_id, b.product_id product2_id,
                count(distinct a.user_id) customer_count
        FROM productpurchases a 
        JOIN productpurchases b on a.user_id = b.user_id and a.product_id < b.product_id
        GROUP BY 1, 2

    )

SELECT t2.product1_id, t2.product2_id,
        product1_category, product2_category, customer_count
FROM t2
JOIN t3 on t2.product1_id = t3.product1_id and t2.product2_id = t3.product2_id
WHERE customer_count > 2
ORDER BY 5 desc, 1, 2;

쿼리 최적화

사실 내가 처음 작성한 정답 쿼리는 구조가 깔끔하다고 보긴 어려웠고, 특히 t와 t2 테이블은 하나로 합쳐도 되겠다는 생각이 들었다.

이런 생각을 바탕으로 ChatGPT를 활용해 쿼리를 다시 구성해 보았고, 불필요한 단계들을 줄이고 의도에 더 집중된 구조로 개선할 수 있었다.

# 기존 주문 테이블에 카테고리 추가

WITH purchases_with_cat AS (
    SELECT pp.user_id, pp.product_id, pi.category
    FROM productpurchases pp
    JOIN productinfo pi ON pp.product_id = pi.product_id
),

# 앞에서 생성된 테이블을 바탕으로 self join 하여 제품 1, 2 별 주문 고객 수를 구함

product_pairs AS (
    SELECT
        a.product_id AS product1_id,
        b.product_id AS product2_id,
        a.category AS product1_category,
        b.category AS product2_category,
        COUNT(DISTINCT a.user_id) AS customer_count
    FROM purchases_with_cat a
    JOIN purchases_with_cat b
        ON a.user_id = b.user_id
       AND a.product_id < b.product_id
    GROUP BY a.product_id, b.product_id, a.category, b.category
)

SELECT
    product1_id,
    product2_id,
    product1_category,
    product2_category,
    customer_count
FROM product_pairs
WHERE customer_count > 2
ORDER BY customer_count DESC, product1_id, product2_id;

가장 큰 차이점은 cross_join을 하지 않아서 메모리에 좋을 것 같다라는 생각을 했다.

그 동안 취업 준비하면서 코딩 테스트 문제를 하루에 2~3개씩 풀어보면서 한 번 틀렸거나 특별하게 풀었던 문제 정리

Hacker Rank: Occupations

문제

테이블 이름: OCCUPATIONS 컬럼: Name, Occupation 목표:

• Occupation 열을 피벗(pivot)하여 각 직업(Doctor, Professor, Singer, Actor)을 열(Column)로 만들고,
• 각 Occupation에 해당하는 사람들의 Name을 알파벳 순으로 정렬하여 세로로 나열합니다.
• 이름의 수는 직업마다 다를 수 있으므로, 짧은 직업군에는 해당하지 않는 칸은 NULL로 채웁니다.
• 컬럼 순서는 Doctor, Professor, Singer, Actor 순서로 고정입니다.

풀이

1. CTE t에서 row_number() 사용
   • 각 직업별 이름을 알파벳 순서로 정렬
   • 각 이름에 번호를 부여해서, 나중에 group by
2. case when 을 이용해 직업별로 하나의 컬럼 생성
3. group by num
   • 같은 순서에 해당하는 이름들을 하나의 행으로 묶음
4. max() 사용 이유
   • 각 그룹에서 case when으로 필터링된 name은 하나뿐이므로, max()를 사용해서 그 값 추출
   • 만약 해당 직업에 num 순서에 사람이 없으면 null 반환

정답 쿼리

WITH 
t1  as (SELECT *, row_number() over(partition by occupation order by name) as num
        FROM occupations
)

SELECT 
    max(case when occupation = 'doctor' then name else null end),
    max(case when occupation = 'professor' then name else null end),
    max(case when occupation = 'singer' then name else null end),
    max(case when occupation = 'actor' then name else null end)
FROM t1
GROUP BY num;

틀린 이유: 집계함수를 사용해서 그룹화된 1개의 값만을 가져오는 방법을 모르고 풀었었다

SQL은 집계함수(MAX, MIN 등)를 써야만 SELECT에서 GROUP BY 없이 컬럼을 출력할 수 있다

Leet Code: Primary Department for Each Employee

문제: Employee_id 당 department_id가 여려개 존재한 경우 primary_flag가 "Y"인 경우의 department_id를 추출

각 직원 아이디별로 primary 부서 아이디 추출

초반 문제 접근:

CTE 나 서브쿼리를 이용해 id가 2개 이상인 직원을 필터링해서 기존 테이블과 조인하려 했음

문제 풀이 방식:

초반 문제 접근으로 쿼리를 짜면 쿼리가 복잡해지고 메모리 낭비도 심할꺼란 생각이 들었다. "윈도우 함수를 이용해서 primart_flag에 순위를 주면 어떨까?"라는 생각을 기반으로 정답 쿼리를 만들게 됨. 가독성 측면이나 메모리 측면에서도 더 효율적이라고 생각이 됨.

정답 쿼리

WITH t as
    (SELECT employee_id, department_id, row_number() over(partition by employee_id order by primary_flag) num
    FROM employee
    )

SELECT employee_id, department_id
FROM t
WHERE num = 1;

태블로는 기본적으로 합계로 집계한다 - 필요한 집계 방식으로 변경해야 한다

마크

데이터 포인트를 어떻게 표시할지 제어하는 요소 색상, 크기, 레이블, 세부 정보, 도구 설명, 도형이 있다.

1. '국가/지역'을 넣어 국가별 색상을 구분
2. '세그먼트'를 넣어 세그먼트별 도형 구분
3. '세그먼트'를 레이블로 표시
4. '국가/지역'을 레이블로 표시
5. '주문 Id'를 카운트(고유)로 집계 방식을 변경해서 레이블 표시

데이터 타입

배송 날짜의 데이터 타입이 불연속형이라 데이터가 몇년의 데이터임에도 25년1월이 아닌 월별로 구분되어 있다.

데이터 컬럼을 통해 연속성으로 변경을 눌러 연속형으로 변경해야 한다.

필터

특정한 조건을 걸어 그에 해당하는 데이터만을 플롯에 나타낼 수 있다

구간차원

구간차원을 나누어서 데이터를 일정한 구간으로 나눌 수 있다. 데이터 컬럼에서 우클릭 -> 만들기 -> 구간차원

구성비율

마크에 넣은 데이터를 우클릭 -> 퀵 테이블 계산 -> 구성 비율

데이터 셋

데이터는 18개의 피처를 기반으로 채무불이행여부(0, 1)을 예측하는 문제이다.

전처리

우선 "현재 직장 근속 연수" 컬럼에서 근속 연수에 대한 숫자만 추출하기 위해 정규 표현식을 이용해서 숫자만 추출했다.

# 현재 직장 근속 연수 -> 숫자만 추출
def year_int(x):
    return re.findall(r'\d+', x)[0]

df['현재 직장 근속 연수'] = df['현재 직장 근속 연수'].apply(year_int)
test['현재 직장 근속 연수'] = test['현재 직장 근속 연``수'].apply(year_int)

범주형 변수 전처리

범주형 데이터에 포함되는 컬럼인 "주거 형태", "대출 목적", "대출 상환 기간"에 LabelEncoder, One-Hot Encoder 전부 적용해 본 결과 원-핫인코딩의 결과가 가장 좋아 최종적으로 pandas get_dummies 메서드를 이용해 원-핫 인코딩을 진행했다.

df = pd.get_dummies(df, columns=['주거 형태', '대출 목적', '대출 상환 기간'])
test = pd.get_dummies(test, columns=['주거 형태', '대출 목적', '대출 상환 기간'])

소득/대출 변수 전처리

소득/대출 관련 변수에 log1p를 적용시켜 이상치 완화, 분포 정규화를 시켰다.

log_columns = ["현재 미상환 신용액", "월 상환 부채액", "현재 대출 잔액"]
for col in log_columns:
    X[col] = np.log1p(X[col])
    test[col] = np.log1p(test[col])

스케일링

스케일링의 경우 StandardScaler, MinMaxScaler 전부 해본 결과 MinMaxScaler를 적용시켰다. 클래스 불균형을 보완하기 위해 SMOTE를 사용했는데 -> SMOTE를 사용하지 않아도 괜찮을 정도의 비율이였다.

X = df.drop('채무 불이행 여부', axis=1)
y = df['채무 불이행 여부']

mm = MinMaxScaler()
X = mm.fit_transform(X)

mm = MinMaxScaler()
test_scaled = mm.fit_transform(test)

smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X, y)
X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.3, random_state=42)

모델 설계

사실 간단한 이진 분류 문제이기 때문에 처음에는 머신러닝을 이용해서 모델을 설계했지만 가장 높은 모델(LightGBM)의 점수가 0.57정도 밖에 되지 않아 딥러닝으로 모델을 설계했다.

모델은 3개의 은닉층을 가지고 활성화 함수는 출력층은 sigmoid 함수, 은닉층에는 leaky relu 함수를 사용했다. 조기 종료 옵션, 드롭아웃을 적용해 모델이 과적합을 방지했다.

model = keras.Sequential([
    layers.Dense(128, activation='leaky_relu'),
    layers.Dropout(0.3),
    layers.Dense(64, activation='leaky_relu'),
    layers.Dropout(0.3),
    layers.Dense(32, activation='leaky_relu'),
    layers.Dense(1, activation='sigmoid')
])

early_stopping = EarlyStopping(
    monitor='val_loss',
    patience=5,
    min_delta=0.001,
    restore_best_weights=True
)

model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0015),
              loss='binary_crossentropy', metrics=['AUC'])

history = model.fit(X_train, y_train, epochs=100, validation_data=(X_test, y_test),
                    batch_size=32, callbacks=[early_stopping], verbose=1)

결과 변환

test_pred_prob = model.predict(test_scaled)
test_pred = (test_pred_prob >= 0.5).astype(int)

sub = pd.read_csv('sample_submission.csv')
sub['채무 불이행 확률'] = test_pred

sub.to_csv('submission.csv', index=False)

데이콘 결과 상위 25%로 평가지표 ROC-AUC 점수는 약 0.6 정도 나왔다. 사실 딥러닝을 오랜만에 설계하면서 감찾는게 목표였는데 이정도면 괜찮은 것 같다. feature engineering을 하면 더 점수가 높게 나왔을 거지만 시간이 부족해서 그렇게 까지는 하지 못했다.

사용자의 구매 패턴이나 평점을 가지고 다른 사람들의 구매 패턴, 평점을 통해서 추천을 하는 방법 추가적인 사용자의 개인정보나 아이템의 점보가 없이도 추천할 수 있는게 큰 장점 종류 - 최근접 이웃기반, 잠재 요인기반

이웃기반

이웃기반 협업 필터링은 메모리 기반 알고리즘으로 협업 필터링을 위해 개발되었다

알고리즘

1. User-based collaborative filtering 사용자의 구매 패턴(평점)과 유사한 사용자를 찾아서 추천 리스트 생성

-> 유사한 사람을 찾는

2. Item-based collaborative filtering 특정 사용자가 준 점수간의 유사한 상품을 찾아서 추천 리스트 생성

-> 유사한 상품을 찾는

장점 간단하고 직관적인 접근 방식 때문에 구현 및 디버그가 쉬움 특정 Item을 추천하는 이유를 정당화하기 쉽고 Item기반 방법의 해석 가능성이 두드러짐 추천 리스트에 새로운 item과 user가 추가되어도 상대적으로 안정적

단점 User 기반 방법의 시간, 속도, 메모리가 많이 필요 희소성 떄문에 제한된 범위가 있음

잠재요인 기반

Rating Matrix에서 빈 공산을 채우기위해 사용자와 상품을 잘 표현하는 차원을 찾는 방법(ex 행렬분해). 행렬 분해는 추천 시스템에서 사용되는 협업 필터링 알고리즘을 한 종류로 사용자-아이템 상호 작용 행렬을 두 개의 저차원 직사각형 행렬의 곱으로 분해하여 작동

SGD

고유값 분해와 같은 행렬을 대각화 하는 방법 Rating Matrix R과 User latent matrix U와 Item latent matrix V 내적의 차이를 최소화하는 U, V를 찾음

Gradient Descent를 통해 U, V를 업데이트

Gradient Descent를 통해 J를 U, V로 편미분한 값

기울기 폭주 방지를 위해 규제항 추가해야 한다

편미분한 값을 이용해 한 번의 에포크로 각 Latent Matrix의 원소를 업데이트

ALS(Alternating Least Squares)

SGD는 User Latent, Item Latent 두 개의 행렬을 최적화하는 방버 ALS는 두 행렬 중 하나를 고정시키고 다른 하나의 행렬을 순차적으로 반복하면서 최적화하는 방법 -> 기존의 최적화 문제가 convex형태로 바뀌기 때문에 수렴된 행렬을 찾을 수 있다

알고리즘

1. 초기 아이템, 사용자 행렬을 초기화
2. 아이템 행렬을 고정하고 사용자 행렬을 최적화
3. 사용자 행렬을 고정하고 아이템 행렬을 최적화
4. 2, 3 과정 반복

기본 문법

import plotly.graph_objects as go

# Figure 객체 생성
fig = go.Figure()

# Trace(데이터) 추가
fig.add_trace(go.Scatter(x=[1, 2, 3], y=[4, 1, 2], mode='lines+markers', name='Sample'))

# 레이아웃 설정
fig.update_layout(title='Sample Plot', xaxis_title='X Axis', yaxis_title='Y Axis')

fig.show()

주요 구성 요소

Trace(데이터 시각화 요소)

go.Scatter(): 선 그래프, 산점도 go.Bar(): 막대 그래프 go.Pie(): 파이 차트 go.Box(): 박스 플롯 go.Heatmap(): 히트맵

Figure(그래프 객체)

fig = go.Figure(): 빈 Figure 객체 생성 fig.add_trace(go.Scatter(...)): 데이터 추가

Layout(레이아웃 설정)

fig.update_layout(title='그래프 제목', xaxis_title='x축 제목', yaxis_title='y축 제목') fig.update_xaxes(title_text='x축 제목') fig.update_yaxes(title_text='y축 제목')

프로젝트 시각화 코드

카테고리별 국가별 주문 건수

각 카테고리와 국가에 대해 그래프 추가

fig = go.Figure()

categories = size_df['Category'].unique()
countries = size_df['Country'].unique()

for category in categories:
    for country in countries:
        category_data = size_df[(size_df['Category'] == category) & (size_df['Country'] == country)]
        fig.add_trace(go.Scatter(
            x=category_data['year'],
            y=category_data['주문건수'],
            mode='lines+markers',
            name=f"{country} - {category}",
            visible=(category == categories[0])  
        ))

fig.add_trace(go.Scatter(...)) -> 각 국가 및 카테고리에 대한 라인 그래프 -> name=f'{country} - {category}로 각 그래프의 이름을 설정하여 그래프 레전드에 표시 -> visible=(category == categories[0])로 첫 번째 카테고리의 그래프만 처음에 보이게 설정

드롭다운 버튼 생성: 각 카테고리마다 버튼을 생성해 선택하면 해당 카테고리만 볼 수 있도록 설정

dropdown_buttons = [
    {"label": category, "method": "update", "args": [{"visible": [category == cat for cat in categories for _ in countries]}, 
                                                    {"title": f"{category} 카테고리별 국가별 주문건수"}]}
    for category in categories
]

label: 드롭다운에 표시될 텍스트 method: 'update': 버튼 클릭 시 그래프를 업데이트 하도록 설정 args - visible: 각 카테고리의 국가별 주문 건수 그래프 중 해당 카테고리에 해당하는 것만 보이게 설정 args - title: 드롭다운 메뉴에서 카테고리를 선택할 때마다 그래프의 제목을 변경

레이아웃 및 드롭다운 메뉴 설정

fig.update_layout(
    updatemenus=[{
        "buttons": dropdown_buttons,
        "direction": "down",
        "showactive": True,
        "x": 0.1,
        "xanchor": "left",
        "y": 1.15,
        "yanchor": "top",
    }],
    title="카테고리별 국가별 주문 건수",
    xaxis_title="Year",
    yaxis_title="주문건수"
)

fig.show()

updatemenus: 드롭다운 메뉴를 레이아웃에 추가         - buttons: 앞서 만든 드롭다운 버튼을 설정         - direction: 'down': 드롭다운 버튼이 아래로 펼쳐지도록 설정         - showactive: True: 현재 선택된 버튼이 활성화되어 표시         - x, xanchor, y, yanchor: 드롭다운 버튼의 위치를 정한다(여기서는 그래프                                                    위쪽에 배치하도록 설정)

중앙값 주문 건수 비교

첫 번째 트레이스: 판매 금액 중앙값

fig.add_trace(go.Scatter(
    x=ch_furniture["year"], 
    y=ch_furniture["sales median"], 
    text=ch_furniture['sales median'],
    textposition='top center',
    mode="lines+markers+text",  
    name="판매 금액 중앙값",
    line=dict(color="blue", width=2)
))

text=: 각 데이터 포인트 위에 판매 금액 중앙값을 표시 mode='lines+marker+text': 데이터 포인트를 선과 마커로 표시하며 텍스트도 표시 line=dict(color='blue', width=2): 선의 색상을 파란색으로, 두께는 2로 설정

두 번째 트레이스: 주문 건수

fig.add_trace(go.Scatter(
    x=ch_furniture["year"], 
    y=ch_furniture["amount"], 
    mode="lines+markers+text",  
    text=ch_furniture['amount'],
    textposition='bottom center',
    name="주문건수",
    line=dict(color="red", width=2, dash="dash"),
    yaxis="y2"
))

yaxis='y2': 이 트레이스는 두 번째 y축(y2)에 배치되어 판매 금액의 중앙값과 주문 건수를 각각 다른 y축에 표시하도록 설정

레이아웃 설정

fig.update_layout(
    title="중국 가구 카테고리 연도별 판매 금액 중앙값, 주문건수",
    xaxis_title="Year",
    yaxis=dict(title="판매 금액 중앙값"),
    yaxis2=dict(title="주문건수", overlaying="y", side="right"),
    xaxis=dict(tickmode="linear", dtick=1),  
    legend=dict(x=0.9, y=1.2)
)
fig.show()

yaxis2=dict(title='주문 건수'...): 두 번째 y축을 추가하여         - overlaying='y': 첫 번째 y축과 겹쳐서 표시되도록 설정         - side='right': 두 번째 y축을 오른쪽에 배치 xaxis=dict(tickmode='linear', dtick=1): x축의 눈금은 선형으로 설정, 각 눈금 간 간격을 1년으로 설정

고객 세그먼트

구매 고객을 VIP, 일반 고객 두 그룹으로 나누어 리텐션 분석을 진행했다.

고객 세그먼트 코드

WITH Avg_price AS (
    SELECT AVG(total_purchase) AS avg_price
    FROM (
        SELECT user_id, SUM(price_usd) AS total_purchase
        FROM orders
        GROUP BY user_id
    ) AS user_purchase
),
VIP AS (
    SELECT o.user_id, SUM(o.price_usd) AS total_purchase, a.avg_price
    FROM orders o
    CROSS JOIN Avg_price a
    GROUP BY o.user_id, a.avg_price
    HAVING SUM(o.price_usd) >= 1.5 * a.avg_price
),

리텐션 분석

고객의 주문건을 기준으로 리텐션을 계산 첫 주문달을 기준으로 첫 달에 구매한 고객 수 집계 첫 주문 달에도 구매하고 두 번째 달에도 구매한 고객 수 집계 계속 이렇게 진행하면서 마지막 구매 달까지 리텐션을 계산한다

세그먼트별 첫 주문일을 확인하는 코드

first_order AS (
    SELECT DISTINCT user_id,
            CASE WHEN user_id IN (SELECT user_id
                                FROM vip) THEN 'VIP'
            ELSE 'Regular' END AS 'User_Segment', min(created_at) AS first_ord
    FROM orders
    GROUP BY 1
)

첫 주문 이후 n개월 주문 여부를 확인하는 코드

order_month AS (SELECT DISTINCT fo.user_id, User_segment,
        CASE WHEN created_at = date_format( date_format( first_ord, '%Y-%m-01'), '%Y-%m-01') THEN 0
        WHEN created_at > date_format( date_format( first_ord, '%Y-%m-01'), '%Y-%m-01') AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 1 month) THEN 1
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 1 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 2 month) THEN 2
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 2 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 3 month) THEN 3
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 3 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 4 month) THEN 4
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 4 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 5 month) THEN 5
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 5 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 6 month) THEN 6
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 6 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 7 month) THEN 7
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 7 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 8 month) THEN 8
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 8 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 9 month) THEN 9
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 9 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 10 month) THEN 10
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 10 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 11 month) THEN 11
        WHEN created_at > date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 11 month) AND created_at <= date_add(date_format( first_ord, '%Y-%m-01'), INTERVAL 12 month) THEN 12
        END AS month_num

FROM first_order fo JOIN orders o ON fo.user_id = o.user_id
ORDER BY month_num desc
)

연속으로 주문한 월의 수를 계산하는 코드

seq_table AS (
    SELECT user_id, User_segment, month_num
            FROM order_month
)

조회하는 코드

SELECT User_segment,
        CASE WHEN month_num = 0 THEN 'm-0'
        WHEN month_num = 1  THEN 'm-1'
        WHEN month_num = 2  THEN 'm-2'
        WHEN month_num = 3  THEN 'm-3'
        WHEN month_num = 4  THEN 'm-4'
        WHEN month_num = 5  THEN 'm-5'
        WHEN month_num = 6  THEN 'm-6'
        WHEN month_num = 7  THEN 'm-7'
        WHEN month_num = 8  THEN 'm-8'
        WHEN month_num = 9  THEN 'm-9'
        WHEN month_num = 10 THEN 'm-10'
        WHEN month_num = 11 THEN 'm-11'
        WHEN month_num = 12 THEN 'm-12'
        ELSE 'unknown'
        END AS month_range,
        count(user_id) user_cnt
FROM seq_table
GROUP BY 1,2
ORDER BY 1,2;

결론:

첫 구매 이후 지속적인 유지율이 낮다 일반 고객 대비 VIP 고객읠 평균 구매 빈도가 높지만, 시간이 지나며 유지율이 감소한다.

주제: 신규 고객 활성화 기준 설정 분석 방법: 코호트 분석을 통해 신규 고객이 활성화 될 수 있는 주문수 기준 설정 기간: 23년 7월 첫 주문 고객의 첫 주문일로부터 1달간 누적 주문수 별 리텐션 확인

SQL 코드

WITH
fst AS (
    SELECT mem_no, first_ord_dt
    FROM first_ord_table_practice1 fotp
    WHERE 1=1
    AND first_ord_dt >= '2023-07-01'
    AND first_ord_dt <= '2023-07-31'
),
ord as(
    SELECT DISTINCT omp.mem_no, 
            first_ord_dt,
            ord_dt,
            sum(CASE WHEN first_ord_dt < ord_dt AND ord_dt <= date_add(first_ord_dt, INTERVAL 7 day) THEN 1
                ELSE 0 END) over(PARTITION BY omp.mem_no) as is_w1_ord,
            dense_rank() over(PARTITION BY omp.mem_no ORDER BY ord_dt) ord_seq
    FROM fst
    JOIN order_master_practive1 omp ON fst.mem_no = omp.mem_no
    WHERE 1=1
    AND ord_dt >= '2023-07-01'
    AND ord_dt <= '2023-08-31'
    ORDER BY 1, 2
)
SELECT ord_seq,
        CASE WHEN is_w1_ord > 0 THEN 1 ELSE 0 END is_w1_ord,
        count(DISTINCT mem_no) mem_cnt
FROM ord
GROUP BY 1, 2
ORDER BY 2;

dense_rank를 이용해서 회원별로 누적 주문수를 구한 다음 count 했다 - 이건 1개 또 배웠다

파이썬 코드

# 첫 주문 이후 1주일 이내 주문 여부에 따라 그룹 나누기
true = df[df.is_w1_ord == 1].sort_values('mem_cnt', ascending=False)
false = df[df.is_w1_ord == 0].sort_values('mem_cnt', ascending=False)

# 리텐션 구하기
true['retention'] = true.mem_cnt/max(true.mem_cnt)
false['retention'] = false.mem_cnt/max(false.mem_cnt)

# 시각화를 위해 데이터 합치기
new_df = pd.concat([true, false])

# 시각화
fig = px.line(data_frame=new_df, x='ord_seq', y='retention', color='is_w1_ord')
fig.update_traces(selector=dict(name='1'), name='첫 구매 이후 1주이내 재구매 고객')
fig.update_traces(selector=dict(name='0'), name='첫 구매 이후 1주이내 미구매 고객')
fig.show()

결론

1주 이내 신규 고객을 재구매 고객으로 만들어야 한다 첫 주문일 이후 고객이 활성화될 가능성을 높이려면 한 달 이내 5번 이상 주문해야 한다 - 기준

고객 생애 가치로 유저가 서비스를 사용하는 기간동안 창출하는 매출 EX) 신규고객 획득비용(CAC) 기준 설정 효율적인 마케팅 채널을 파악해 예산 분배

LTV = ARPU * 리텐션 ARPU = 유저당 주문금액(매출/유저수) 그룹을 코호트로 쪼개서 LTV 비교 분석

실습 코드

WITH 
ord as(
    SELECT a.mem_no,
            b.age_range,
            b.first_ord_dt,
            a.ord_dt,
            a.order_amount
    FROM order_master_ltv a
    LEFT JOIN first_ord_table_ltv b ON a.mem_no = b.mem_no
)
,cohort as(
    SELECT age_range,
            CASE WHEN first_ord_dt = ord_dt THEN 'M-0'
                WHEN first_ord_dt < ord_dt AND date(ord_dt) <= date_add(first_ord_dt, INTERVAL 1 month) THEN 'M-1'
                WHEN date(ord_dt) > date_add(first_ord_dt, INTERVAL 1 month) AND date(ord_dt) <= date_add(first_ord_dt, INTERVAL 2 month) THEN 'M-2'
                WHEN date(ord_dt) > date_add(first_ord_dt, INTERVAL 2 month) AND date(ord_dt) <= date_add(first_ord_dt, INTERVAL 3 month) THEN 'M-3'
                WHEN date(ord_dt) > date_add(first_ord_dt, INTERVAL 3 month) AND date(ord_dt) <= date_add(first_ord_dt, INTERVAL 4 month) THEN 'M-4'
                WHEN date(ord_dt) > date_add(first_ord_dt, INTERVAL 4 month) AND date(ord_dt) <= date_add(first_ord_dt, INTERVAL 5 month) THEN 'M-5'
                ELSE 'over-5m' END month_nm,
            count(DISTINCT mem_no) sample_cnt,
            round(avg(order_amount)) ARPU
    FROM ord
    GROUP BY 1, 2
    ORDER BY 1, 2
)
SELECT age_range,
        month_nm,
        sample_cnt,
        ARPU,
        sample_cnt * 1.00 / max(sample_cnt) over(PARTITION BY age_range) retention
FROM cohort
ORDER BY 1, 2

결론

30대가 첫 주문 이후 5개월까지 가장 높은 LTV를 나타냄

로그데이터 분석

로그데이터: 고객이 서비스에 유입되어 남기는 행동 데이터 유입, 페이지 이동, 노출, 클릭 등 데이터가 이벤트 단위로 적재

분석 주제: 어떤 배너를 통해 유입된 고객의 주문 전환율이 더 높을까

실습 코드

WITH 
log AS
    (SELECT DISTINCT mem_no,
            session_id,
            log_dt,
            cast(log_stamp AS datetime) log_stamp,
            min(referrer) OVER(PARTITION BY mem_no ORDER BY log_stamp) bnr_type
    FROM log_table
),
ord AS
    (SELECT DISTINCT log.mem_no,
            log_dt,
            log_stamp,
            bnr_type,
            cast(ord_stamp AS datetime) ord_stamp,
            count(DISTINCT ord_no) ord_cnt
    FROM log 
    LEFT JOIN order_master_log oml 
    ON log.mem_no = oml.mem_no 
    AND log_dt = date(ord_stamp)
    AND log_stamp < CAST(ord_stamp AS datetime)
--     AND log.session_id = oml.session_id 
    GROUP BY 1, 2, 3, 4, 5
),
ord2 AS 
    (SELECT DISTINCT mem_no,
            bnr_type,
            CASE WHEN ord_cnt>0 THEN 1 ELSE 0 END is_order
    FROM ord
)

SELECT bnr_type, sum(is_order)
FROM ord2
GROUP BY 1
ORDER BY 1;

결론

배너 1에 비해 배너 2로 유입되어 주문한 사람이 4배 차이로 차이가 있었지만 작은 데이터 이기 때문에 의미는 거의 없을 것 같다.

코호트

특정 기간 동안 공통된 특성이나 경험을 갖는 사용자 집단

코호트 분석

시간을 두고 비슷한 그룹을 비교하는 방법

ex) 최근 유입 고객의 가입전환율이 낮아짐 -> 광고채널별 유입고객 코호트 분석

AARRR

그로스 해킹

사업의 핵심지표를 찾고, 성장시키는 방법을 찾는 활동

AARRR(해적지표)

사용자 행동방식 5단계 지표 사용자 유치(Acquisition), 사용자 활성화(Activation), 사용자 유지(Retention), 추천(Referral), 매출(Revenue)

고객 관리에서 Retention은 아주 중요

리텐션

리텐션

'고객 유지율'로 서비스의 성공을 예측할 수 있는 가장 기본적인 핵심 지표

측정 방법 특정 기간 내에 이벤트를 발생시킨 유저의 비율을 계산 기간 내 1번 이상의 이벤트가 관측되면 한 번으로 카운트 Retention = 측정 Week 기간 내 서비스 이용 고객수/Week1서비스 이용 고객수

실습

첫 구매 특가 상품을 구매한 고객이 더 잘 될 것인가?

가설: 첫 구매 특가 상품 구매 고객은 리텐션이 더 높을 것 독립변수: 첫 구매 특가 상품 구매 여부(1: 구매/0: 미구매) 종속변수: 고객 유지율(리텐션) 측정인원: 첫 구매 특가 상품 구매자 1,000명/미구매자 1,000명 기간: 1월 한 달간 첫구매 고객(1월 week1 주문고객 기준으로 week4까지 리텐션 비교)

sql 코드

T1: 고객 별 첫 주문 이후 몇 주차에 주문을 했는지 T2: 고객 별 추가 주문이 몇 번째인지(seq) 번호 부여 최종적으로, 각 고객의 첫 주문 이후 n주차에 추가 주문했는지 집계

# 첫 주문 테이블
select *
from first_ord_table;

# 오더마스터 테이블
select *
from order_master_cohort omc ;

# 테이블 조인
select *
from first_ord_table fot
left join order_master_cohort omc on fot.mem_no = omc.mem_no; 

# 분석에 필요한 데이터 집계(첫 주문 후 n주차별 주문 여부 분석)
with 
T1 as (
    select distinct fot.mem_no,
            is_promotion,
            case when ord_dt = first_ord_dt then 0
                when ord_dt > first_ord_dt and date(ord_dt) <= date_add(date(first_ord_dt), interval 7 day) then 1
                when ord_dt > date_add(date(first_ord_dt), interval 7 day) and date(ord_dt) <= date_add(date(first_ord_dt), interval 14 day) then 2
                when ord_dt > date_add(date(first_ord_dt), interval 14 day) and date(ord_dt) <= date_add(date(first_ord_dt), interval 21 day) then 3    
                when ord_dt > date_add(date(first_ord_dt), interval 21 day) and date(ord_dt) <= date_add(date(first_ord_dt), interval 28 day) then 4
                else null end as week_number
    from first_ord_table fot 
    left join order_master_cohort omc on fot.mem_no = omc.mem_no 
)
# 각 고객별 첫 주문 이후 추가 주문 순서 부여
, T2 as (    
    select is_promotion, mem_no, week_number,
            row_number() over(partition by mem_no order by week_number) seq
    from T1
    where week_number is not null)

    select is_promotion,  -- 특가 상품 구매자/미구매자 코호트 
            case when week_number = 0 then '1.w-0'
                 when week_number = 1 and seq = 2 then '2.w-1'
                 when week_number = 2 and seq = 3 then '3.w-2'
                 when week_number = 3 and seq = 4 then '4.w-3'
                 when week_number = 4 and seq = 5 then '5.w-4' end as week_range,
            count(mem_no) as mem_cnt
    from T2
    group by 1,2
    order by 1,2;

파이썬 시각화

import plotly.express as px
import pandas as pd
import numpy as np
from matplotlib import rc
import matplotlib.pyplot as plt
plt.rc('font', family='NanumGothic')

cohort = pd.DataFrame({'is_promotion': ['0', '0', '0', '0', '0', '1', '1', '1', '1','1'],
                       'week_range': ['w-0', 'w-1', 'w-2', 'w-3', 'w-4', 'w-0', 'w-1', 'w-2', 'w-3', 'w-4'],
                       'mem_cnt': [1000, 239, 104, 59, 45, 1000, 440, 266, 198, 155]})

cohort['retention'] = cohort.mem_cnt/1000

fig = px.line(data_frame=cohort, x='week_range', y='retention', color='is_promotion',
              title='코호트 분석')
fig.update_traces(selector=dict(name='0'), name='특가 상품 구매자')
fig.update_traces(selector=dict(name='1'), name='특가 상품 미구매자')
fig.show()

프로모션여부	W-0	W-1	W-2	W-3	W-4
1	1,000	44%	27%	20%	16%
0	1,000	24%	10%	6%	5%

일반적인 코호트 분석 결과의 그래프는 점점 떨어지는 그래프 표로 표현할 때는 프로모션을 시작한 주에는 인원수를 작성하고 주차 별로 남은 인원의 비율 작성 특가 상품 구매 코호트가 1주가 지난 시점부터 높은 리텐션이 보인다 첫 구매 특가 상품 프로모션을 유지하는 방향으로 의사결정

]]> https://velog.io/@taeyoon__/%EC%9D%B4%EC%A4%91%EC%B0%A8%EB%B6%84%EB%B2%95 https://velog.io/@taeyoon__/%EC%9D%B4%EC%A4%91%EC%B0%A8%EB%B6%84%EB%B2%95 Sun, 09 Feb 2025 15:25:51 GMT

A/B Test

A/B Test

A와 B를 대조하여 가설을 검정하는 실험방법 즉, 결과와 상관성이 높다고 생각되는 변수를 테스트하여 검정하는 방법

ex) 배너 위치를 변경하면 CTR(클릭전환율)이 증가할 것이다

이중차분법(Difference-In-Differences)

- 독립변수와 종속변수 간 인과 효과를 측정하기 위한 인과추론법 - 실험군(Treatment): 실험자가 종속변수와 상관성이 높아 보이는 독립변수에 변화를 주는 그룹 - 대조군(Control): 실험군과 대조하기 위해 처치를 하지 않는 그룹 - 대조군과 실험군 두 그룹의 처치 시점 전후 지표 비교

> ||처치 전|처치 후| |---|---|---| |실험군|a|A| |대조군|b|B| > >
이중차분: (A-a)-(B-b)

실습

가설: 정액이 기재되어 있는 할인쿠폰의 주문전환율이 더 높을 것이다. 종속변수: 주문전환율(1: 실험기간 중 주문이 1번이라도 있는 경우/ 0: 실험기간 중 주문이 없는 경우) 독립변수: 쿠폰유형(5천원 할인쿠폰 / 5% 할인쿠폰) 대조그룹: 쿠폰 미지급 100명 실험그룹: 5천원 할인쿠폰 100명 / 5% 할인쿠폰 100명 관찰기간: 6/12 쿠폰발급(처치 이전: 6/56/11, 처치 이후: 6/126/18)

mysql에서 컬럼명이 예약어와 겹칠 경우 ex) group 백틱(``)을 감싸주면 인식 가능

쿠폰 데이터와 오더 데이터를 조인하여 집단별 처치 전후의 차이를 알아봤다 몇 번을 주문했냐가 문제가 아니라 주문을 했는지 안했는지 확인하기 위해 고유 배달 번호가 아닌 고유 멤버 번호를 distinct하여 주문했으면 1, 안했으면 0으로 집계

# 이중차분법을 위한 그룹별 주문 수 집계
with 
T1 as(
    select ctt.mem_no
            , `group`
            , ord_no,
            case when ord_dt between '2023-06-05' and '2023-06-11' then '처치 전'
                when ord_dt between '2023-06-12' and '2023-06-18' then '처치 후' end as period
    from coupon_target_table ctt left join order_master_did omd 
    on ctt.mem_no = omd.mem_no
)

    select `group`
            , period
            , count(distinct mem_no) as ord_cnt
    from T1
    where period is not null
    group by 1, 2;

각 샘플마다 100명이여서 그냥 퍼센트 남긴 채로 계산

그룹/CVR	처치 전	처치 후	처치 후-처치 전	이중차분
Control	62%	56%	-6%	-
Test1_정율	36%	40%	4%	4%-(-6%)=10%
Test1_정액	61%	62%	1%	1%-(-6%)=7%

결론

정율쿠폰: 10% 정액쿠폰: 7% 3% 차이 밖에 나지 않기 때문에 유의미한 결과는 아니다

]]> https://velog.io/@taeyoon__/%EB%B6%80%EB%8F%99%EC%82%B0-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EB%B6%84%EC%84%9D https://velog.io/@taeyoon__/%EB%B6%80%EB%8F%99%EC%82%B0-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EB%B6%84%EC%84%9D Mon, 03 Feb 2025 15:12:03 GMT

크롤링

네이버 페이 부동산을 크롤링하여 100페이지가 넘지 않으면 에러가 날 수 있기 때문에 try except 사용했다

article_list = [] 
for i in tqdm(range(1, 101)):
    try:
        url = f'https://m.land.naver.com/cluster/ajax/articleList?itemId=&mapKey=&lgeo=&showR0=&rletTpCd=OPST%3AVL%3AOR&tradTpCd=B2&z=12&lat=37.481021&lon=126.951601&btm=37.3398975&lft=126.6762562&top=37.6218785&rgt=127.2269458&totCnt=8360&cortarNo=1162000000&sort=rank&page={i}'

        user_agent = generate_user_agent()
        headers = {'User-Agent':user_agent}

        res = requests.get(url, headers=headers)
        time.sleep(1) # 부하 방지를 위해 1초의 대기 시간 가진다


        article_json = res.json()
        article_body = article_json['body']
        article_list.append(article_body)
    except:
        break

article_list1 = [j for i in article_list for j in i]
data = pd.DataFrame(article_list1)

필요한 컬럼만 사용하고 컬럼명 지정 후 엑셀 파일로 저장

data = data[['atclNo', 'rletTpNm', 'flrInfo', 'rentPrc', 'hanPrc', 'spc1', 'spc2', 'direction', 'atclCfmYmd', 'repImgUrl', 'lat', 'lng', 'atclFetrDesc', 'tagList']]
data.columns = ['물건번호', '구분', '층수(물건층/전체층)', '월세', '보증금', '계약면적(m2)', '전용면적(m2)', '방향', '확인일자', '이미지', '위도', '경도', '설명', '태그']
data
data.to_excel('data.xlsx')

전처리

중복된 인덱스 컬럼 삭제

data.drop('Unnamed: 0', axis=1, inplace=True)

월세가 0원인 경우 삭제

data = data.query('월세 > 0')

보증금 숫자로 변환

data = data.query('~보증금.str.contains("억")')
data.보증금 = data.보증금.str.replace(',', '').astype(int)

새로운 컬럼 생성

물건층, 전체층을 분리한 후 비선호층에 대한 유무 확인하는 컬럼 생성

# 물건층, 전체층 분리
data[['물건층', '전체층']] = data['층수(물건층/전체층)'].str.split('/', expand=True)

# 비선호층을 구분하는 함수 
from re import T
def floor_info(target, total):
  try:
    if target in ['B1', 'B2']:
      return 'y'
    elif int(target) == 1 or int(target)/int(total) == 1:
      return 'y'
    else:
      return 'n'

  except ValueError:
    return 'n'

# 비선호층여부 컬럼 생성
data['비선호층여부'] = data.apply(lambda x: floor_info(x['물건층'], x['전체층']), axis=1)

데이터 필터링

내가 원하는 조건

1. 보증금 3,000만원 이하
2. 지하, 반지하, 꼭대기층 x
3. 북향 x

data_filtered = data.query('300<= 보증금 <= 3000 and 비선호층여부 == "n" and 전체층 !="1" and ~방향.str.contains("북")')

태그 분리

정규표현식을 이용해 태그 컬럼을 4개의 컬럼으로 분리

data_filtered[['tag1', 'tag2', 'tag3', 'tag4']] = data_filtered['태그'].str.replace(r"\'|\[|\]", "", regex=True).str.split(', ', expand=True)

연식 컬럼 추가

# 연식 정보가 있는 데이터만 필터링
data_filtered = data_filtered.query('tag1.str.contains("년")') 
data_filtered['연식'] = [int(i[0]) for i in data_filtered['tag1'].str.split('년')]

필요한 컬럼만

data_filtered = data_filtered[['물건번호','월세','보증금','전용면적(m2)','방향','위도','경도','물건층','전체층','연식']]
data_filtered.head()

역까지의 거리 추가

coordinate = pd.read_csv('서울시 역사마스터 정보.csv', encoding='cp949')
coordinate = coordinate.query('호선 == "2호선"')
station_list = ['신대방', '신림', '봉천', '서울대입구(관악구청)', '낙성대', '사당']
coordinate.query('역사명 in @station_list')

역까지의 거리를 구하는 함수(haversine을 이용해 거리를 구했다)

def distance(station_name, lat, long):
    station_lat = coordinate.query(f'역사명 == "{station_name}"')['위도'].values[0]
    station_long = coordinate.query(f'역사명 == "{station_name}"')['경도'].values[0]

    distance = haversine((station_lat, station_long), (lat, long), unit='m')

    return distance

각 지하철 역별로 자취방과의 직선거리를 구해 지하철역 이름의 컬럼에 저장

 for s in station_list:
  data_filtered[s] = data_filtered.apply(lambda x: distance(s, x['위도'], x['경도']), axis=1)

모든 지하철역에 대한 거리를 구하는 것은 비효율적이다 그래서 역까지 거리가 가장 가까운 거리만 데이터에 추가

 data_filtered['역까지최소거리'] = data_filtered.apply(lambda x:min([x['신대방'], x['신림'], x['봉천'], x['서울대입구(관악구청)'], x['낙성대'], x['사당']]), axis=1)
data_filtered.head()

역까지 최소거리를 구했으니 지하철역 컬럼은 삭제해도 된다

data_filtered.drop(station_list, axis=1, inplace=True)

EDA

각 항목의 박스플롯 확인

for x in ['월세', '보증금', '전용면적(m2)', '연식', '역까지최소거리']:
  fig = px.box(data_frame = data_filtered, x=x, width=700, height=400)
  fig.show()

원하는 조건

1. 월세는 저렴할수록 good
2. 전용면적이 클수록 good
3. 연식이 오래되지 않으면
4. 지하철 역에 가까울 수록
   pandas의 qcut을 이용해 등급을 매긴다

data_filtered['월세_등급'] = pd.qcut(data_filtered['월세'], 5, labels=[1, 2, 3, 4, 5])
data_filtered['전용면적_등급'] = pd.qcut(data_filtered['전용면적(m2)'], 5, labels=[1, 2, 3, 4, 5])
data_filtered['연식_등급'] = pd.qcut(data_filtered['연식'].rank(method='first'), 5, labels=[1, 2, 3, 4, 5]) # rank(method='first') 한 이유는 중복이 많기 때문에 임의로 정해라라고 설정한 것
data_filtered['역까지최소거리_등급'] = pd.qcut(data_filtered['역까지최소거리'], 5, labels=[1, 2, 3, 4, 5])

원하는 조건을 입력해 데이터 필터링

data_filtered_choice = data_filtered.query('월세_등급 < 3 and 전용면적_등급 < 3 and 연식_등급 <= 3 and 역까지최소거리_등급 <= 3')

최종 시각화

folium을 이용해 지도에 시각화 마커를 클릭하면 링크를 확인할 수 있다

f = folium.Figure(width=700, height=500)
m = folium.Map(location=[37.486313, 126.935378], zoom_start=14).add_to(f)

for idx in data_filtered_choice.index:
    lat = data_filtered_choice.loc[idx, '위도']
    long = data_filtered_choice.loc[idx, '경도']
    num = data_filtered_choice.loc[idx, '물건번호']

    folium.Marker([lat, long]
                  , popup=f"<a href=https://m.land.naver.com/article/info/{num}>링크</a>"
                  ).add_to(m)
m

]]> https://velog.io/@taeyoon__/%EC%A7%80%EB%A6%AC-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%8B%9C%EA%B0%81%ED%99%94 https://velog.io/@taeyoon__/%EC%A7%80%EB%A6%AC-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%8B%9C%EA%B0%81%ED%99%94 Wed, 22 Jan 2025 09:20:32 GMT 교통 데이터를 활용해 folium으로 데이터 시각화 수행

데이터 구조

2018년 이후 데이터, 2호선, 승차 인원에 관해 분석을 진행하기 위해 전처리 필요

전처리

연도, 월 컬럼 추가

data['연도'] = pd.to_datetime(data['사용월'], format='%Y%m').dt.year
data['월'] = pd.to_datetime(data['사용월'], format='%Y%m').dt.month

2018년 이후, 2호선만 추출

data = data[(data.연도 >= 2018) & (data.호선명 == '2호선')]
data = data.query('호선명 == "2호선" and 연도 >= 2018')

둘 다 같은 의미의 코드 지만 query를 이용해 이렇게 전처리 할 수도 있다

지하철역 이름 전처리

['강남', '강변(동서울터미널)', '건대입구', '교대(법원.검찰청)', '구로디지털단지', '구의(광진구청)', '낙성대', '낙성대(강감찬)', '당산', '대림(구로구청)', '도림천', '동대문역사문화공원', '동대문역사문화공원(DDP)', '뚝섬', '문래', '방배', '봉천', '사당', '삼성(무역센터)', '상왕십리', '서울대입구(관악구청)', '서초', '선릉', '성수', '시청', '신답', '신당', '신대방', '신도림', '신림', '신설동', '신정네거리', '신촌', '아현', '양천구청', '역삼', '영등포구청', '왕십리(성동구청)', '용답', '용두(동대문구청)', '을지로3가', '을지로4가', '을지로입구', '이대', '잠실(송파구청)', '잠실나루', '잠실새내', '종합운동장', '충정로(경기대입구)', '한양대', '합정', '홍대입구']

지하철역 이름이 바뀐 경우가 있기 때문에 "()" 부분을 제거 해야한다

# 지하철역 컬럼을 "("를 기준을 split하여 리스트에 넣고 그 중 첫번째 값을 꺼낸다 -> 그러면 "(" 앞에 있는 것들만 추출된다 
data['지하철역'] = [i[0] for i in data['지하철역'].str.split('(')]

승차 인원 추출

사실 여기서 나는 개인적으로 isin으로 승차가 들어간 컬럼만 가져오는게 더 효율적이지 않을까 생각했는데 그렇게 되면 내가 원하는 컬럼 순서나 나중에 승차 컬럼만 필요할때 사용함에 있어서 불편함이 있기 때문에 이렇게 리스트 컴프리헨션을 사용하는게 더 적합하다.

on_col = [i for i in data.columns if '승차' in i]
data = data[['사용월','연도','월','지하철역']+on_col]

합계

axis=1을 이용해 지하철역별 해당월의 승차 인원의 합을 구한다

data['합계'] = data[on_col].sum(axis=1)

EDA

지하철역별 월평균 승차 인원

data_mean = data.groupby('지하철역')[['합계']].mean().reset_index().rename({'합계':'월평균'}, axis=1).sort_values('월평균', ascending=False)

fig = px.bar(data_frame = data_mean, x='지하철역', y='월평균', title='지하철역별 월평균 승차인원')

연도/월별 승차 인원 추세 파악

연도

year_sum = data.query('연도 <= 2022').groupby(['연도'])[['합계']].sum().reset_index()
year_sum['연도'] = year_sum['연도'].astype(str)

fig = px.line(data_frame=year_sum, x='연도', y='합계')
fig.show()

월

month_sum = data.query('연도 <= 2022').groupby(['월'])[['합계']].sum().reset_index()
month_sum['월'] = month_sum['월'].astype(str)

fig = px.line(data_frame=month_sum, x='월', y='합계')
fig.show()

코로나가 시작된 2020년, 2021년에 인원이 많이 줄고(재택근무 영향) 2022년 부터 회복

시간대별 가장 승차인원이 많은 역

top10 = data_mean.sort_values('월평균', ascending=False).head(10)['지하철역']
top10

승하차 인원이 가장 많은 역: 강남, 잠실, 홍대입구 ...

월평균 인원수가 많은 순서로 10개만 필터링해 시간당 월평균 인원수 구하기

top10 = data_mean.sort_values('월평균', ascending=False).head(10)['지하철역']
top10_mean_hour = data.query('지하철역 in @top10').groupby('지하철역')[on_col].mean()
top10_mean_hour.columns = [i[:3] for i in top10_mean_hour.columns]

히트맵 시각화

top10_mean_hour.style.background_gradient(cmap='pink_r', axis=None).format('{:.0f}')

시간대별 인원 클러스터링

hour_mean = data.groupby('지하철역')[on_col].mean()
hour_mean.columns = [i[:3] for i in hour_mean.columns]
hour_mean_pct = hour_mean.div(hour_mean.sum(axis=1), axis=0)

KMeans 알고리즘을 이용해 군집화

from sklearn.cluster import KMeans
from yellowbrick.cluster import KElbowVisualizer

model = KMeans()
visualizer = KElbowVisualizer(model, k=(1,10))
visualizer.fit(hour_mean_pct)

주요 출근 시간대인 06시/18시를 확인

군집별 해당하는 역명 확인

for i in range(k):
    print(f'cluster {i}')
    print(list(hour_mean_pct.query(f'cluster == "{i}"').index))

cluster 0
['강남', '교대', '뚝섬', '삼성', '서초', '선릉', '성수', '시청', '역삼', '을지로3가', '을지로4가', '을지로입구', '한양대']
cluster 1
['강변', '구의', '낙성대', '대림', '봉천', '상왕십리', '서울대입구', '신답', '신대방', '신림', '신정네거리', '아현', '양천구청', '용답', '용두', '잠실나루', '잠실새내']
cluster 2
['건대입구', '구로디지털단지', '당산', '도림천', '동대문역사문화공원', '문래', '방배', '사당', '신당', '신도림', '신설동', '신촌', '영등포구청', '왕십리', '이대', '잠실', '종합운동장', '충정로', '합정', '홍대입구']    

시각화

위도 경도가 있는 데이터

coordinate = pd.read_csv('서울시 역사마스터 정보.csv', encoding='cp949')
coordinate.head()

앞에서 진행한 전처리 방식과 동일하게 진행 다른점은 "역사명" 컬럼명을 "지하철역"으로 컬렴명 변경

coordinate = coordinate.query('호선 == "2호선"')
coordinate['역사명'] = [i[0] for i in coordinate['역사명'].str.split('(')]
coordinate.rename({'역사명':'지하철역'}, axis=1, inplace=True)
coordinate

앞에서 구한 시간별 평균 데이터에서 '지하철역', '08시', '18시' 컬럼만 가져와서 위도/경도 데이터를 합친다

hour_mean_merge = hour_mean.reset_index()[['지하철역','08시','18시']]
coordinate_merge = coordinate[['지하철역','위도','경도']]
hour_mean_coor = pd.merge(hour_mean_merge, coordinate_merge, on='지하철역')

KMeans를 활용해 군집화하여 cluster이라는 컬럼으로 추가한다

hour_mean_coor['cluster'] = model.fit_predict(hour_mean_pct).astype(str)
hour_mean_coor.head()

folium

승차 유형별로 지도에 시각화

m = folium.Map(location=center, zoom_start=12)

for idx in hour_mean_coor.index:
    lat = hour_mean_coor.loc[idx, '위도']
    long = hour_mean_coor.loc[idx, '경도']
    title = hour_mean_coor.loc[idx, '지하철역']

    if hour_mean_coor.loc[idx, 'cluster'] == "0":
        color = '#000000'
    elif hour_mean_coor.loc[idx, 'cluster'] == "1":
        color = '#3A01DF'
    else:
        color = '#DF0101'

    folium.CircleMarker([lat, long]
                        , radius=18
                        , color = color
                        , fill = color
                        , tooltip = title).add_to(m)
m

0번 cluster: 주거 지역이 많이 분포 1번 cluster: 주거/상업 시설/회사가 비슷하게 분포 2번 cluster: 회사가 많이 분포

]]> https://velog.io/@taeyoon__/%EC%98%81%ED%99%94-%ED%9D%A5%ED%96%89-%EC%9A%94%EC%9D%B8-%EB%B6%84%EC%84%9D https://velog.io/@taeyoon__/%EC%98%81%ED%99%94-%ED%9D%A5%ED%96%89-%EC%9A%94%EC%9D%B8-%EB%B6%84%EC%84%9D Sat, 18 Jan 2025 04:27:59 GMT

데이터 탐색

movies 데이터

• budget: 영화 예산 (단위: 달러)
• genres: 모든 장르
• homepage: 공식 홈페이지
• id: 각 영화당 unique id
• original_language: 원 언어
• original_title: 원 제목
• overview: 간략한 설명
• popularity: TMDB에서 제공하는 인기도
• production_companies: 모든 제작사
• production_countries: 모든 제각국가
• release_date: 개봉일
• revenue: 흥행 수익 (단위: 달러)
• runtime: 상영 시간
• spoken_language: 사용된 모든 언어
• status: 개봉 여부
• title: 영문 제목
• vote_avearage: TMDB에서 받은 평점 평균
• vote_count: TMDB에서 받은 투표수

credits 데이터

• movie_id: 각 영화당 unique id
• title: 영문 제목
• cast: 모든 출연진
• crew: 모든 제작진

데이터 전처리

필요 없는 컬럼 제외

movies_df = movies[['id','budget','genres','title','release_date','revenue','vote_average','vote_count']]
credits_df = credits[['movie_id','crew','cast

movies, credits 데이터 결합

data = pd.merge(movies_df, credits_df, left_on = 'id', right_on = 'movie_id').drop('movie_id', axis=1)

새로운 컬럼 만들기

roi 컬럼

data['roi'] = data['revenue'] / data['budget']
data.head()

감독 컬럼

crew 컬럼은 문자열 타입의 딕셔너리로 구성되있다

data['crew'][0]

'[{"credit_id": "52fe48009251416c750aca23", "department": "Editing", "gender": 0, "id": 1721, "job": "Editor", "name": "Stephen E. Rivkin"}, {"credit_id": "539c47ecc3a36810e3001f87", "department": "Art", "gender": 2, "id": 496, "job": "Production Design", "name": "Rick Carter"}, {"credit_id": "54491c89c3a3680fb4001cf7", "department": "Sound", "gender": 0, "id": 900, "job": "Sound Designer", "name": "Christopher Boyes"}

ast 라이브러리를 이용해 문자열 -> 리스트로 변경

import ast

print(ast.literal_eval(data['crew'][0])) 
data['crew'] = data['crew'].apply(ast.literal_eval) # 리스트 형태로 바꾼다

감독의 이름을 리턴하는 함수

def get_director(x):
    for i in x:
        if i['job'] == 'Director':
            return i['name']

apply 메서드를 이용해 감독의 이름을 리턴해 'director' 컬럼에 저장

data['director'] = data['crew'].apply(get_director)

배우 컬럼

배우 컬럼도 cast 컬럼을 ast 라이브러리를 이용해 문자열을 리스트로 저장

data['cast_name'] = data['cast'].apply(lambda x: [i['name'] for i in ast.literal_eval(x)])
# 문자열 -> 리스트 -> 'name' key 만 가져와서 리스트로 저장
data.head()

장르 컬럼

장르도 앞에서 했던 것 처럼 새로운 'main_genre' 컬럼 생성

데이터 타입 변경

data['release_date'] = pd.to_datetime(data['release_date'], format='%Y-%m-%d')
data['id'] = data['id'].astype(str)

# 연도, 월 컬럼 만들기
data['year'] = data['release_date'].dt.year
data['month'] = data['release_date'].dt.month

결측치 제거

data.dropna(inplace=True)

EDA

연도별 흥행 수익

revenue_by_year = data.groupby('year')[['revenue']].sum().reset_index() # plotly의 x로 year가 들어가기 위해 reset_index 사용

fig = px.line(data_frame=revenue_by_year, x="year", y="revenue")
fig.show()

2000년대 이후로 흥행 수익이 급격히 높아짐

가장 흥행한 영화 10개

top = data.groupby('title')['revenue'].sum().reset_index().sort_values('revenue', ascending=False).head(10)
fig = px.bar(data_frame=top, x='title', y='revenue', title=f"흥행 수익 TOP 10 영화")
fig.show()

예산, 투표수 상위 10개 영화

title_dic = {'budget':'예산', 'vote_count':'투표수'}
for y in ['budget','vote_count']:
    top = data.groupby('title')[[y]].sum().reset_index().sort_values(y, ascending=False).head(10)
    fig = px.bar(data_frame=top, x='title', y=y, title=f"{title_dic[y]} TOP 10 영화")
    fig.show()

가장 흥행에 성공한 감독, 배우

top_director = data.groupby(['director'])['revenue'].sum().reset_index().sort_values('revenue', ascending=False).head(10)
fig = px.bar(data_frame=top_director, x='director', y='revenue', title=f"흥행 수익 TOP 10 감독")
fig.show()

흥행 수익이 높은 배우들의 목록을 확인하기 위해 explode 메서드를 활용해 확인

revenue_cast = data[['revenue', 'cast_name']].explode('cast_name') # explode: 리스트 형태의 값을 여러행으로 전개

top_cast = revenue_cast.groupby('cast_name')[['revenue']].sum().reset_index().sort_values('revenue', ascending=False).head(10)
fig = px.bar(data_frame=top_cast, x='cast_name', y='revenue', title=f"흥행 수익 TOP 10 배우")
fig.show()

장르별 흥행 수익의 분포

fig = px.box(data_frame = data, y = 'main_genre', x = 'revenue', hover_name = 'title')
fig.show()

액션과 드라마 장르에 수익이 매우 높은 영화들이 많이 있지만, 중앙값을 비교했을 때, 다른 장르에 비해 높지 않다

genre_avg_revenue = data.groupby('main_genre')[['revenue']].mean().reset_index()
fig = px.bar(data_frame = genre_avg_revenue, x = 'main_genre', y = 'revenue', title = '장르별 흥행 수익 평균')
fig.show()

장르별 영화 수익의 평균은 애니메이션>어드벤쳐>가족>SF>판타지>액션 순서

genre_sum_revenue = data.groupby('main_genre')[['revenue']].sum().reset_index()
fig = px.bar(data_frame = genre_sum_revenue, x = 'main_genre', y = 'revenue', title = '장르별 흥행 수익 합계')
fig.show()

흥행 수익 합계는 액션>어드벤쳐>드라마>코미디>애니메이션 순서

연도별 장르별 수익

revenue_by_year_genre = data.query('year >= 1990').groupby(['year','main_genre'])[['revenue']].sum().reset_index()

fig = px.bar(data_frame=revenue_by_year_genre, x="year", y="revenue", color='main_genre', color_discrete_sequence=px.colors.qualitative.Light24_r)
fig.show()

revenue_by_year_genre_pct = pd.pivot_table(data=data.query('year >= 1990'), index='year', columns='main_genre', values='revenue', aggfunc=sum, fill_value=0, margins=True)
revenue_by_year_genre_pct = 100 * revenue_by_year_genre_pct.div(revenue_by_year_genre_pct.iloc[:,-1], axis=0).drop('All').drop('All', axis=1)
revenue_by_year_genre_pct = pd.melt(revenue_by_year_genre_pct.reset_index(), id_vars='year', value_name='pct')

fig = px.bar(data_frame=revenue_by_year_genre_pct, x="year", y="pct", color='main_genre', color_discrete_sequence=px.colors.qualitative.Light24_r)
fig.show()

2010년도부터 액션 영화의 흥행 수익 비중이 높아지기 시작 1990년 후반 ~ 2000년대 초반에는 드라마 장르의 흥행 수익이 높았다

revenue_by_month_genre = data.query('year >= 1990').groupby(['month','main_genre'])[['revenue']].sum().reset_index()

fig = px.bar(data_frame=revenue_by_month_genre, x="month", y="revenue", color='main_genre', color_discrete_sequence=px.colors.qualitative.Light24_r)
fig.show()

액션, 어드벤처 장르는 비교적 봄, 여름에 개봉 수익이 높았다 드라마 장르는 비교적 가을, 겨울에 개봉 수익이 높았다. 코미디 장르는 비교적 겨울에 개봉 수익이 높았다.

수익, 예산, 투표수, 평점의 상관관계

fig = px.imshow(data[['budget','revenue','vote_average','vote_count']].corr(), text_auto='.2f', color_continuous_scale='Purp')
fig.show()

for x in ['budget', 'vote_count', 'vote_average']:
    fig = px.scatter(data_frame = data, x = x, y = 'revenue', hover_name = 'title', size = 'revenue', color = 'revenue'
    , color_continuous_scale = px.colors.sequential.Sunsetdark, width = 700, height = 600, trendline = 'ols')
    fig.show()

• 흥행 수익 상위 100개의 영화들에 대해서만 상관관계 확인

for x in ['budget', 'vote_count', 'vote_average']:
    fig = px.scatter(data_frame = top100, x = x, y = 'revenue', hover_name = 'title', size = 'revenue', color = 'revenue'
    , color_continuous_scale = px.colors.sequential.Emrld, width = 700, height = 600, trendline = 'ols', trendline_color_override='green')
    fig.show()

예산과 투표수는 흥행 수익과 높은 양의 상관관계를 보이나, 평점 평균은 비교적 낮은 양의 상관관계를 볼 수 있다 흥행에 성공한 상위 100개로만 확인 했을때는, 그 상관관계가 더 낮아진다

ROI가 높으면서 흥행에 성공한 영화의 특징

top300 = data.sort_values('revenue', ascending=False).head(300)

fig = px.box(data_frame = top300, y = 'main_genre', x = 'roi', hover_name = 'title')
fig.show()

액션의 경우 예산이 큰 영화가 많아 ROI가 높은 편은 아니고, 드라마/코미디/로맨스 영화가 ROI가 큰 영화들이 많다

]]> https://velog.io/@taeyoon__/folium-%EC%A0%95%EB%A6%AC https://velog.io/@taeyoon__/folium-%EC%A0%95%EB%A6%AC Fri, 17 Jan 2025 05:41:46 GMT 기본 문법

f = folium.Figure(width=가로길이, height=세로길이)
m = folium.Map(location=[위도, 경도], zoom_start=줌할정도).add_to(f)
m.save('test.html') # 지도 저장

f = folium.Figure(width=700, height=500) # 지도의 크기
m = folium.Map(location=[37.510781008592716, 127.09607026177875], zoom_start=16).add_to(f)

마커 추가하기

# 장소 표시 마커
folium.Marker([위도, 경도], tooltip=마우스 오버시 나타남, popup=클릭시 나타남, icon=folium.Icon(color=색, icon=모양)).add_to(지도)

# 원 형태 마커
folium.CircleMarker([위도, 경도], radius=범위, color=색).add_to(지도)

folium.Marker([37.510781008592716, 127.09607026177875]
               , tooltip='롯데월드'
              , icon = folium.Icon(color='red', icon='star')
              , popup = '<iframe src="https://upload.wikimedia.org/wikipedia/commons/thumb/c/c2/Lotte_World_Theme_Park.jpg/440px-Lotte_World_Theme_Park.jpg"></iframe>').add_to(m)

folium.CircleMarker([37.510781008592716, 127.09607026177875]
              , color = 'red'
              , radius = 50).add_to(m)              

folium.Choropleth(geo_data=geo_json, fill_color='gray').add_to(m) # 각 구별 경계데이터를 구분

f = folium.Figure(width=700, height=500)
m = folium.Map(location=[37.566535, 126.9779692], zoom_start=11).add_to(f)
folium.Choropleth(geo_data=geo_json,
                  data=twosome_count,
                  columns=['시군구명', 'count'],
                  key_on='properties.name',
                  fill_color='BuPu',
                  fill_opacity=0.7,
                  line_opacity=0.7,
                  legend_name='서울시 구별 투썸플레이스 매장수').add_to(m)

]]> https://velog.io/@taeyoon__/plotly-folium-%EC%A0%95%EB%A6%AC https://velog.io/@taeyoon__/plotly-folium-%EC%A0%95%EB%A6%AC Wed, 15 Jan 2025 04:22:23 GMT 기본 문법

fig = px.그래프종류(data_frame=데이터, x=X축 컬럼, y=Y축 컬럼, color=범례 컬럼, title=제목,
                 labels=dict(X축 컬럼=X축 라벨, Y축 컬럼=Y축 라벨),
                 width=그래프 가로길이, height=그래프 세로길이, text_auto=True/False)
fig.show()

산점도

px.scatter(data_frame=데이터, x= , y= , color=색, trendline='ols') 
# trendline은 추세선 추가

facet_col: column 지정해서 분할

fig = px.scatter(data_frame=penguins, x='bill_length_mm', y='bill_depth_mm', color='sex', trendline='ols', facet_col='island',
                 color_discrete_sequence=px.colors.qualitative.Set2, template='plotly_white')
fig.show()

히스토그램

px.histogram(data_frame=데이터, x= , y= , color=색)

fig = px.histogram(data_frame=penguins, x='flipper_length_mm', color_discrete_sequence=px.colors.qualitative.Set2, template='plotly_white')
fig.show()

상자 그림

px.box(data_frame=데이터, x= , y= , color=색)

fig = px.box(data_frame=penguins, x='body_mass_g', y='species', color='sex',
             color_discrete_sequence=px.colors.qualitative.Set2, template='plotly_white')
fig.show()

막대 그래프

px.bar(data_frame=데이터, x= , y= , color=색, barmode='group')
# 쌓아서 올리지 않으면 barmode='group'을 추가

barmode 없는 경우

fig = px.bar(data_frame=titanic_groupby, x='class', y='survived', color='sex',
             color_discrete_sequence=px.colors.qualitative.Set2, template='plotly_white')
fig.show()

barmode='group' 지정한 경우

fig = px.bar(data_frame=titanic_groupby, x='class', y='survived', color='sex', barmode='group', text_auto='.2f',
             color_discrete_sequence=px.colors.qualitative.Set2, template='plotly_white')
fig.show()

선 그래프

px.line(data_frame=데이터, x= , y= , color=색)

fig = px.line(data_frame=flights, x="year", y="passengers", color='month'
, color_discrete_sequence=px.colors.qualitative.Set2, template='plotly_white')
fig.show()

히트맵

px.imshow(데이터, text_auto=텍스트포맷, color_continuous_scale=컬러맵)

fig = px.imshow(titanic_pivot, text_auto='.2f', color_continuous_scale='Purples')
fig.show()

파이차트

px.pie(data_frame=데이터, values=값, name=라벨)

fig = px.pie(df, values='tip', names='day', color_discrete_sequence=px.colors.qualitative.Pastel)
fig.show()

]]>