How to study for us

AARRR 프레임워크, 성장의 흐름을 읽는 다섯 글자

Shine_sunho — Tue, 23 Sep 2025 16:22:33 +0900

AARRR 프레임워크, 성장의 흐름을 읽는 다섯 글자

AARRR의 다섯 단계(획득·활성화·유지·추천·수익화)를 정리하고, 실무에서 어떻게 바라보고 적용할지에 대한 관점을 공유합니다.

스타트업이나 서비스 기획, 데이터 분석을 공부하다 보면 자주 접하게 되는 개념이 바로 AARRR입니다. 단순히 다섯 글자를 외우는 데서 끝나지 않고, 실제 서비스에 어떻게 적용할 수 있을지를 고민하는 것이 중요합니다. 이번 글에서는 AARRR 프레임워크의 개념을 정리하고, 제가 생각하는 활용 포인트를 함께 나누고자 합니다.

AARRR, 다섯 단계의 고객 여정

AARRR은 고객이 서비스를 접하고, 경험하고, 다시 찾아오고, 추천하고, 결국 매출로 이어지는 흐름을 다섯 단계로 나눈 프레임워크입니다.

1) Acquisition (획득)

고객이 어디서, 어떤 경로로 들어오는지 파악
광고·검색·바이럴·앱스토어 등 유입 채널과 CAC 점검

2) Activation (활성화)

첫 경험이 얼마나 긍정적인지 평가
온보딩과 UX, 퍼널 분석으로 “아, 이 서비스 좋다” 순간 설계

3) Retention (유지)

고객이 꾸준히 돌아오는지 확인
코호트 분석과 리텐션 차트로 재방문·반복 사용 지표 점검

4) Referral (추천)

고객이 다른 사람을 데려오는지 측정
추천 프로그램과 바이럴 계수(Viral Coefficient)로 자발적 확산 확인

5) Revenue (수익화)

고객이 실제로 지갑을 여는지(결제·구독·광고 수익 등)
ARPU, LTV, 결제 전환율 등으로 수익 구조의 건강성 점검

중요한 건 순서가 아니다

흔히 AARRR을 Acquisition부터 Revenue까지 ‘순서대로’ 최적화하면 된다고 생각하기 쉽습니다. 하지만 실제로는 Activation과 Retention이 먼저 안정적으로 확보되어야 합니다. 제품 자체가 고객을 붙잡을 힘이 없다면, 아무리 많은 유입을 만들어도 결국 이탈로 이어지기 때문입니다.

핵심: “얼마나 많이 데려오느냐”보다 “얼마나 오래 남게 하느냐”가 우선입니다.

제가 보는 AARRR의 의미

AARRR은 단순히 지표를 관리하는 틀이 아니라, 서비스가 지속 가능한 성장을 만들어내는 과정이라고 생각합니다.

퍼널 분석으로 고객 이탈의 순간을 발견
코호트 분석으로 시간에 따른 행동 변화를 추적

Machine Learning 개념정리 1탄 (평가지표, 정규화)

Shine_sunho — Wed, 16 Apr 2025 15:48:43 +0900

평가 지표

기존 ML모델의 성능을 평가하기 위한 지표로 사용되며 회귀모델, 분류 모델에 따른 각 측정방식의 사용법이 달라진다.
- 분류 작업
  - 오차 행렬(혼돈 행렬) : 주로 이진 분류에서 많이 사용됨
    - 1) True Positive(TP) : 예측값을 Positive로 예측했는데 실제 값 역시 Positive인 경우
      - 2) True Negative(TN) : 예측값을 Negative로 예측했는데 실제 값 역시 Negative인 경우
      - 3) False Negative(FN) : 예측값을 Negative로 예측했는데 실제 값은 Positive인 경우
      - 4) False Positive(FP) : 예측값을 Positive로 예측했는데 실제 값은 Negative인 경우
  - 정확도 : 모델의 예측이 얼마나 정확한지 의미 : TN + TP / (TP + TN + FN + FP)
  - 정밀도 : 예측을 긍정으로 한 데이터 중 실제로 긍정인 비율 : TP / (FP + TP)
  - 재현율 : 실제로 긍정인 데이터 중 긍정으로 예측한 비율 : TP / (FN + TP)
    - 기본적으로, 정밀도와 재현율은 Trade-off 관계를 가짐. 정밀도는 FP를, 재현율을 FN을 낮춤으로써 긍정 예측의 성능을 높임
  - F1-Score : 정밀도와 재현율 한쪽에 치우치지 않고 둘다 균형을 이루는 것, 조화평균으로 계산함 : (2(정밀도재현율)) / (정밀도 + 재현율)
  - ROC-AUC : FPR(False-Postiive Rate,FP/(FP+TN))가 변할 떄 TPR(True Positive Rate,재현율)이 어떻게 변하는지 나타내는 곡선, AUC는 ROC의 곡선의 넒이를 의미함, AUC가 높을수록, 즉 왼쪽 위로 휘어질수록 성능이 높다고 판단 가능. 즉, TPR이 높고 FPR이 낮을수록 예측 오류는 낮아짐
- 회귀 작업
  - MAE : 예측값과 정답값 사이 차이의 절대값의 평균
  - MAPE : MAE를 퍼센트로 변환한 것, 스케일에 관계없이 절대적인 치이 비교를 가능하게 함, 0인 경우 0으로 나눌 수 없어서 0이 많은 데이터에는 적절하지 않음
  - WAPE : 관측값으로부터 예측값의 전체적 편차를 측정함. 관측값의 합과 예측값의 합을 구하고 두 값 사이의 오차를 계산함
  - MSE : 예측값과 정답값 사이 차이의 제곱의 평균, 제곱을 했기 때문에 이상치에 민감함
  - RMSE : MSE에 루트를 씌운 값
  - RMSEL : 예측값과 정답값에 로글르 씌워 계산
  - R Squared : 분산을 기반으로 예측 성능을 측정, 정답값의 분산 대비, 예측값의 분산 비율을 지표로 함, 1에 가까울수록 정확도가 높음
  - wQL : 해당 분위수에 대한 예측 오차를 측정
    - P10 실제보다 예측이 작아야 유리한 손실 구조 (보수적)
      - P50 중앙값 기반 예측 (일반적 정확도 기준)
    - P90 실제보다 예측이 커야 유리한 손실 구조 (공격적)

정규화

정규화를 하는 이유 : 정규화는 개별 피처의 크기를 모두 똑같은 단위로 변경하는 것, 피처의 스케일이 심하게 차이가 나는 경우, 큰 피처가 더 중요하게 여겨질 수 있기 때문.
정규화 방법론
- 최소-최대 정규화 : 각 피처의 최소값을 0, 최대값을 1로 두고 변환 -> (x- min) / (max- min)
  - 이상치(outlier)의 영향이 큼 → 이상치가 있으면 전체 스케일이 왜곡됨
  - 데이터가 정해진 범위 안에 있을 때 (ex. 이미지 픽셀, 온도, 비율 등)
- Z-정규화 : 각 피처의 표준편차와 평균으로 값을 정규화함 -> (X-mean)/std
  - 평균과 분산을 기준으로 정규화 → 데이터의 분포를 보존
  - 스케일이 고정되지 않아 음수 값도 포함됨
  - 변수 간 단위가 다른 경우 (예: 키 vs 몸무게 vs 수입)

정규화 기법	중심값	분포 보존	이상치 대응	음수 가능	주요 활용
Min-Max	min / max	❌	❌	❌	이미지, 신경망
Z-정규화	평균 / 표준편차	⭕	△	⭕	회귀, SVM, PCA
MaxAbs	0 / 최대 절대값	❌	△	⭕	희소 데이터
Robust	중앙값 / IQR	⭕	⭕	⭕	이상치 많은 금융, 센서
Log 변환	log(X + c)	⭕	⭕	❌	매출, 방문자수
L2 정규화	유클리드 길이	❌	❌	⭕	텍스트 벡터 유사도
L1 정규화	L1 거리 (절댓값 합)	❌	❌	⭕	희소 벡터, 텍스트 분석

Baekjoon [9205] 맥주 마시면서 걸어가기 - python

Shine_sunho — Thu, 13 Mar 2025 16:07:30 +0900

문제

https://www.acmicpc.net/problem/9205

풀이코드

# 맥주 한 박스에는 맥주가 20개 들어있다. 목이 마르면 안되기 때문에 50미터에 한 병씩 마시려고 한다. 즉, 50미터를 가려면 그 직전에 맥주 한 병을 마셔야 한다.
# 편의점에 들렸을 때, 빈 병은 버리고 새 맥주 병을 살 수 있다. 하지만, 박스에 들어있는 맥주는 20병을 넘을 수 없다. 편의점을 나선 직후에도 50미터를 가기 전에 맥주 한 병을 마셔야 한다.
from collections import deque

def bfs():
    que = deque()
    que.append((home_idx_x,home_idx_y))

    while que:
        x,y = que.popleft()
        if abs(x-festival_idx_x) + abs(y-festival_idx_y) <= 1000:
            print("happy")
            return
        else:
            for i in range(store_cnt):
                if visited[i] == False:
                    xx = store_idx_list[i][0]
                    yy = store_idx_list[i][1]
                    if abs(xx-x) + abs(yy-y) <= 1000:
                        visited[i] = True
                        que.append((xx,yy))
    print('sad')
    return

testcase = int(input())

for _ in range(testcase):
    store_cnt = int(input())
    home_idx_x, home_idx_y = map(int,input().split())
    store_idx_list = []
    for i in range(store_cnt):
        store_idx_x, store_idx_y = map(int,input().split())
        store_idx_list.append((store_idx_x, store_idx_y)) # x,y
    festival_idx_x, festival_idx_y = map(int,input().split())
    visited = [False for _ in range(store_cnt+1)]
    bfs()

문제접근

처음엔 이중리스트로 좌표를 다 저장한후, 접근을 해야 할까 생각했지만, 메모리측면과 시간복잡도로 인해 해당 방법은 패스했다.

이에 따라, 처음 집 위치에서 저장한 편의점 좌표중 갈 수 있는 좌표(거리 1000이하) 일 경우, 해당 좌표로 탐색을 진행한다.

그 다음, 해당 좌표에서 또 다른 편의점으로 도착할 수 있을지 탐색을 진행한다.

이를 반복한 다음, 최종적으로 페스티벌에 도착할 수 있는지 판별한다.

약간 Queen문제랑 비슷한거 같다.

Baekjoon [5567] 결혼식 - python

Shine_sunho — Mon, 10 Mar 2025 20:09:37 +0900

문제

https://www.acmicpc.net/problem/5567

풀이코드

from collections import deque

def bfs(start_num,depth):
    global answer
    que = deque()
    que.append((start_num,depth))
    while que:
        start_num,depth = que.popleft()
        visited_list[start_num] = True
        for i in linked_list[start_num]:
            if visited_list[i] != True and depth < 2:
                visited_list[i] = True
                que.append((i,depth+1))
                answer +=1


number = int(input())
linked_list = [[] for _ in range(number+1)]
visited_list = [False for _ in range(number+1)]
testcase = int(input())

answer = 0
for i in range(testcase):
    n,m = map(int,input().split())
    linked_list[n].append(m)
    linked_list[m].append(n)

bfs(1,0)
print(answer)

문제접근

친구관계를 저장하기 위해 linked_list 를 사용하여 친구관계를 저장한다. 이때 adjacency matrix를 사용해도 가능하다.

친구관계를 저장 한 후, BFS로 탐색을 시작한다. 이때 친구의 친구까지만 초대를 하기 위해 depth를 이용하여 탐색범위를 설정한다.

Baekjoon [17070] 파이프 옮기기 1 - python

Shine_sunho — Thu, 6 Mar 2025 16:59:59 +0900

문제

https://www.acmicpc.net/problem/17070

풀이 코드1(실패) (BFS탐색)

from collections import deque

n = int(input())
mapp = [list(map(int, input().split())) for _ in range(n)]

dx = [1, 1, 0]  # 가로, 대각선, 세로 이동
dy = [0, 1, 1]
now = [0, 1, 2]  # 0: 가로, 1: 대각선, 2: 세로

dp = [[[0] * 3 for _ in range(n)] for _ in range(n)]  # dp[y][x][방향] = 경로 개수 저장
dp[0][1][0] = 1  # 처음 파이프 위치: (0,1)에서 가로로 시작

que = deque([[0, 1, 0]])  # (y, x, 방향) 형태로 초기값 설정

def bfs():
    while que:
        y, x, pipe_now = que.popleft()

        if y == n - 1 and x == n - 1:  # 도착 지점 도달
            continue

        for i in range(3):  # 3가지 방향 이동
            if abs(i - pipe_now) > 1:
                continue  # 가로 , 세로 직접 변경 불가능

            yy, xx = y + dy[i], x + dx[i]

            if 0 <= yy < n and 0 <= xx < n and mapp[yy][xx] == 0:  # 벽이 아닐 때
                if i == 1:  # 대각선 이동 시 추가 검사
                    if y + 1 >= n or x + 1 >= n:  # 인덱스 초과 방지
                        continue
                    if mapp[y+1][x] == 1 or mapp[y][x+1] == 1:  # 대각선 이동 시 추가 벽 확인
                        continue

                dp[yy][xx][i] += dp[y][x][pipe_now]  # 현재 위치에서 이동 가능한 방향의 경우의 수 추가
                if [yy, xx, i] not in que:  # **중복 방지를 위해 큐에 존재하는지 확인**
                    que.append([yy, xx, i])

bfs()
print(sum(dp[n-1][n-1]))  # 3가지 방향으로 도착하는 경우의 수 합산 출력

풀이 코드2(성공) (DP)

n = int(input())
mapp = [list(map(int, input().split())) for i in range(n)]

# 3차원 DP 테이블 선언 (가로, 대각선, 세로)
dp = [[[0] * 3 for _ in range(n)] for _ in range(n)]

# 초기값 설정 (0,1)에서 가로 방향 시작
dp[0][1][0] = 1

# DP 실행
for y in range(n):
    for x in range(2, n):  # (0,1)부터 시작하므로 x는 2부터
        if mapp[y][x] == 1:  # 벽이면 이동 불가
            continue

        # 가로 방향 이동 가능
        dp[y][x][0] = dp[y][x-1][0] + dp[y][x-1][1]

        # 세로 방향 이동 가능
        if y > 0:
            dp[y][x][2] = dp[y-1][x][1] + dp[y-1][x][2]

        # 대각선 이동 가능 (벽 체크 필요)
        if y > 0 and mapp[y-1][x] == 0 and mapp[y][x-1] == 0:
            dp[y][x][1] = dp[y-1][x-1][0] + dp[y-1][x-1][1] + dp[y-1][x-1][2]

# 최종 출력: 목적지 (n-1, n-1)에 도착하는 모든 경우의 수 합산
print(sum(dp[n-1][n-1]))

문제 접근

처음엔 문제를 접근 했을 때, BFS로 탐색을 한 후, 가로,대각선,세로를 탐색하는 것을 목표로 잡았다.

해당 코드는 테스트케이스를 다 통과하여, 성공을 할 줄 알았으나 시간초과가 발생했다.

GPT의 힘을 빌려, 왜 시간초과가 나는지 생각을 해본 결과, N의 개수가 많아지면서 que에 탐색하는 좌표값이 많아지면 중복탐색으로 인해, 시간초과가 발생하지 않았나 싶다.

이를 바탕으로, 이중포문과 dp의 3차원 배열을 이용하여 경우의수를 저장하는 방식을 사용했다.

국민은행 2025년 동계 체험형 인턴 회고

Shine_sunho — Wed, 5 Mar 2025 16:09:25 +0900

꽤나 시간이 지난 후, 국민은행 동계인턴 회고를 작성하려합니다.

인턴십 내용은 다음과 같았습니다. AI,Data 부문 00자리수 채용이 진행됐었고, 이에 따라 서류평가와 AI역량검사 + AI면접을 기반으로 합격을 진행했습니다.

사실 학부 졸업생이라 AI,Data 부문에 과연 경쟁력이 있을지 의문이 들었지만, 자기소개서를 어찌저찌 작성하며 서류를 제출했습니다.

몇일 후, AI역량검사를 진행했는데, 기본적인 게임과 인성검사 그리고 5개이상의 면접 질문을 받았습니다.

당시, 면접 질문의 난이도가 꽤나 높았던걸로 기억하는데, 알고보니 AI 면접의 결과가 서류 평가후, 면접 평가에 사용된다는 사실을 보고 난후, 알았습니다.

운이 좋게 AI,Data부문 인턴에 합격하여 2달간 국민은행 인턴십을 진행했습니다.

AI,Data혁신부안에는 총 5개의 부서가 나눠졌는데, HR 담당자와 각 부서의 팀장님??들 분이 합격자의 서류를 바탕으로 각 부서로 배정됐습니다.

이에 따라, 저는 데이터 분석을 진행하는 부서에 근무하며, 인턴십을 수행했습니다.

인턴십 과정은 개인 프로젝트, 팀 프로젝트, 보고서, 출결 등 다양한 항목을 바탕으로 평가가 진행됐습니다. 각 부서별로, 담당 멘토분들이 계셨으며, 각 부서의 업무에 맞는 개인 프로젝트가 배정되어 진행을 했습니다.

입행 첫 주에는, 국민은행 신관 건물에서 OJT교육이 진행됐습니다. 당시 구내식당이 꽤나 높은 곳에 위치하고 있어, 점심을 먹을 때 여의도 전경이 한눈에 보이는 점이 상당히 맘에 들었던거 같습니다 ㅎㅎ

이후, 부서 멘토분들이 오셔서 여의도에 나눠져있는 각기 다른 국민은행 건물로 인솔을 진행해주셨습니다.

AI데아터 부서는 여의도공원 바로 앞에 있는 FKI타워에서 위치하고 있어 해당 장소에서 출퇴근을 했으며, 건물 높이가 높아 근무 중, 종종 경치를 구경하는 맛에 회사를 다녔던거 같습니다.

2달간 업무를 진행하고, 평가에 따라 각 부서에 속해있는 인턴 들 중, 상위 10%와 상위 20%는 최우수 수료와 우수 수료 선정을 진행했습니다.

이 과정에서, 운이 좋게 우수 수료생에 선정되어 채용시 가점을 받을 수 있었습니다.

아마, 25년 상반기 또는 하반기에 국민은행 채용이 열린다면, 꽤나 인상깊고 뜻깊었던 국민은행을 위해 다시 한번 노력을 불태우지 않을까 싶습니다.

이만 두서없이 내용 정리가 안된 회고를 마치도록 하겠습니다 ㅎㅎ

Baekjoon [4179] 불! - python

Shine_sunho — Wed, 5 Mar 2025 15:53:42 +0900

문제

https://www.acmicpc.net/problem/4179

풀이 코드

from collections import deque
import sys

# J와 F동시에 BFS시작
# 탐색한 좌표를 담을 수 있는 변수 x 필요
    # 해당 변수에 J와 F를 구분할 수 있는 변수 필요
# 좌표를 담은 변수x를 pop하며 탐색 진행
# 탐색을 한 후, 다시 x에 저장, 이때 카운티 1증가
# J가 F랑 곂치면 임파서블 출력
# J가 벽 외각에 도달하면 cnt 출력

r,c = map(int,input().split())

dx = [-1,1,0,0]
dy = [0,0,-1,1]
answer = "IMPOSSIBLE"
def bfs():
    global answer
    while que:
        # print(mapp)
        y,x,time = que.popleft()
        if time >= 1 and mapp[y][x]!= "F" and (y==0 or x == 0 or y == r-1 or x ==c-1):
            answer = time
            return
            # break
        for i in range(4):
            yy = y + dy[i]
            xx = x + dx[i]
            if 0<= yy < r and 0<= xx < c:
                if mapp[yy][xx] != "#": #벽이 아닐 때
                    if time >= 1 and mapp[yy][xx] == ".": # pop한게 지훈이 일때
                        mapp[yy][xx] = "@" # 방문 체크
                        que.append((yy,xx,time+1))
                    elif time == 0 and mapp[yy][xx] != "F": # pop한게 불일 때
                        mapp[yy][xx] = "F" # 불 번짐
                        que.append((yy,xx,0))
mapp = [list(input()) for _ in range(r)]
que = deque()
for i in range(r):
    for j in range(c):
        if mapp[i][j] == "J":
            que.append((i,j,1)) # y,x,time
for i in range(r):
    for j in range(c):
        if mapp[i][j] == "F":
            que.append((i,j,0)) # y,x,time
bfs()
print(answer)

문제 접근

문제를 봤을 때, 불과 지훈이 있으면 각 좌표에 따라 BFS를 진행해야합니다.

이 과정에서, 불이 지훈보다 1초 늦게 전이가 되는 것을 확인했습니다.

que에 좌표를 넣을 때, 지훈을 불보다 먼저 넣어 4방탐색을 먼저 시작합니다.

이후 문제 접근은 주석과 같습니다.

# J와 F동시에 BFS시작
# 탐색한 좌표를 담을 수 있는 변수 x 필요
    # 해당 변수에 J와 F를 구분할 수 있는 변수 필요
# 좌표를 담은 변수x를 pop하며 탐색 진행
# 탐색을 한 후, 다시 x에 저장, 이때 카운티 1증가
# J가 F랑 곂치면 임파서블 출력
# J가 벽 외각에 도달하면 cnt 출력

[운영체제] 메모리 관리와 가상 메모리

Shine_sunho — Mon, 3 Jun 2024 17:00:11 +0900

메모리 관리

컴퓨터 내의 한정 된 메모리를 극한으로 활용해야 하며 가상메모리, 메모리 할당 기법 등이 발달함.

가상 메모리

가상 메모리는 메모리 관리 기법의 하나로 컴퓨터가 실제로 이용가능한 메모리 자원을 추상화하여 이를 사용하는 사용자들에게 매이 큰 메모리로 보이게 만드는 것.

이때 가상적으로 주어진 주소를 가상 주소라고 하며, 실제 메모리상에 있는 주소를 실제 주소(physical address)라고 함. 가상 주소는 메모리관리 장치(MMU)에 의해 실제 주소로 변환되며, 이덕 분에 사용자는 실제 주소를 의식할 필요 없이 프로그램 구축이 가능해짐.

MMU

프로세스는 독립적인 메모리 공간을 가져야 되고, 자신의 공간만 접근해야함
따라서 한 프로세스에게 합법적인 주소 영역을 설정하고, 잘못된 접근이 오면 trap을 발생시켜 보호함
이때 base와 limit 레지스터를 활용하여 메모리를 보호함
- base 레지스터 : 메모리 상의 프로세스 시작주소를 물리 주소로 저장
- limit 레지스터 : 프로세스의 사이즈를 저장함
- 따라서 프로세스의 접근 가능한 메모리 영역은 base <=x < base +limit이 됨.

가상 메모리는 가상 주소와 실제 주소가 매핑되어 있고 프로세스의 주소 정보가 들어 있는 '페이지 테이블'로 관리됨. 이때 속도 향상을 위해 TLB를 사용함

TLB

메모리와 CPU 사이에 있는 주소 변환을 위한 캐시, 페이지 테이블에 있는 리스트를 보관하며 CPU가 페이지 테이블까지 가지 않도록 하여 속도를 향상 시킬 수 있는 캐시 계층임

스와핑과 페이지 폴트

스와핑

가상 메모리에는 존재하지만 실제 메모리인 RAM에는 현재 없는 데이터나 코드에 접근할 경우 페이지 폴트가 발생함.
이때 메모리에서 당장 사용하지 않는 영역을 하드디스크로 옮기고 하드디스크의 일부분을 마치 메모리처럼 불러와 쓰는 기법을 스와핑이라 함

페이지 폴트

프로세스의 주소 공간에는 존재하지만, 지금 이 컴퓨터의 RAM에는 없는 데이터에 접근할 경우 발생

페이지 폴트가 일어나 스와핑이 일어나는 과정

어떤 명령어가 유효한 가상 주소에 접근했으나 해당 페이지가 만약 없다면 트랩이 발생되어 운영체제에 알리게 됨
운영체제는 실제 디스크로부터 사용하지 않은 프레임을 찾음
해당 프레임을 실제 메모리에 가져와서 페이지 교체 알고리즘을 기반으로 특정 페이지와 교체함(이때 스와핑 발생)
페이지 테이블을 갱신시킨 후 해당 명령어를 다시 시작

페이지 : 가상 메모리를 사용하는 최소 크기 단위

프레임 : 실제 메모리를 사용하는 최소 크기 단위

스레싱

메모리의 페이지 폴트율이 높은 것을 의미하며, 이는 컴퓨터의 성능 저하를 초래함

발생하는 원리

스레싱은 메모리에 너무 많은 프로세스가 동시에 올라가면 스와핑이 많이 일어나서 발생하는 것
페이지 폴트가 일어나면 CPU이용률이 낮아짐
CPU이용률이 낮아지게 되어 운영체제는 가용성을 높이기 위해, 더 많은 프로세스를 메모리에 올림
이때 악순환이 반복되며 스레싱이 일어남

해결 방법

메모리를 증가시킴
HDD를 SDD로 바꿈
운영체제 측면에서 해결하는 방법
- 작업세트
  - 프로세스의 과거 사용 이력인 지역성을 통해 결정된 페이지 집합을 만들어서 미리 메모리에 로드함
- PFF(Page Fault Frequency)
  - 페이지 폴트 빈도를 조절하여 상한선과 하한선을 만듬

[운영체제] 메모리와 캐시

Shine_sunho — Mon, 3 Jun 2024 15:58:42 +0900

메모리

메모리는 전자회로에서 데이터나 상태, 명령어 등을 기록하는 장치를 말하며, 보통 RAM을 일컫어 메모리라고도 함. CPU는 계산을 담당하고, 메모리는 기억을 담당함

메모리 계층

메모리 계층은 레지스터, 캐시, 메모리, 저장장치로 구성되어 있음

레지스터 : CPU안에 있는 작은 메모리, 휘발성, 속도 가장 빠름, 용략 제일 적음
캐시 : L1,2 캐시를 지칭함. 휘발성, 속도빠름, 기억 용략 적음
주기억장치 : RAM을 지칭함, 휘발성, 속도 보통, 기억 용량 보통
보조기억장치 : HDD, SDD를 일컫으며 비휘발성, 속도 낮음, 기억 용량이 많음

캐시

데이터를 미리 복샣 놓는 임시 저장소이자 빠른 장치와 느린 장치에서 속도 차이에 따른 병목 현상(Bottle neck)을 줄이기 위한 메모리임.

이를 통해 데이터를 접근하는 시간이 오래 걸리는 경우를 해결하고 무언가를 다시 계산하는 시간을 절약 할 수 있음. 이때 적중율(Hit Rate)를 극대화 시키기 위해서 데이터 지역성의 원리를 이용함.

지역성 : 모든 코드나 데이터를 균등하게 Access 하지 않는다는 특성을 기본으로 한다. 즉, Locality란 기억 장치 내의 정보를 균일하게 Access 하는 것이 아닌 어느 한 순간에 특정 부분을 집중적으로 참조하는 특성인 것이다.

이 데이터 지역성은 대표적으로 시간 지역성(Temporal Locality)과 공간 지역성(Spatial Locality)으로 나뉜다.

시간 지역성 : 최근에 참조된 주소의 내용은 곧 다음에 다시 참조되는 특성.
- ex) for문에서 i연산을 통해 반복해서 셈을 구하는 과정
공간 지역성 : 대부분의 실제 프로그램이 참조된 주소와 인접한 주소의 내용이 다시 참조되는 특성
- ex) 배열 arr의 각 요소들에 연속적으로 접근할 때

캐시히트와 캐시미스

캐시에서 원하는 데이터를 찾았다면, 캐시히트라고 하며, 해당 데이터가 캐시에 없다면 주메모리로가서 데이터를 찾아오는 것을 캐시미스라고 함.

캐시 매핑

캐시가 히트되기 위해 매핑하는 방법을 말하며 CPU의 레지스터와 주 메모리간에 데이터를 주고받을 때를 기반으로 설명함. 레지스터는 주 메모리에 비하면 굉장히 작고 주 메모리는 굉장히 크기때문에 작은 레지스터가 캐시 계층으로써 역할을 잘하려면 매핑 방식이 중요함. 캐시에 데이터를 저장할 때 특정 자료구조를 사용하여 묶음으로 저장하게 되는데 이를 캐싱 라인 이라고 함.

직접 매핑(directed mapping)
- 메모리가 1~100, 캐시가 1~10이면 1: 1~10, 2: 1~20 이런 식으로 매핑함, 처리가 빠르지만 충돌 발생이 잦음
연관 매핑(associative mapping)
- 순서를 일치시키지 않고 관련있는 캐시와 메모리를 매핑함. 충돌이 적지만 모든 블록을 탐색해야 해서 속도가 느림
집합 연관 매핑(set associative mapping)
- 직접 매핑과 연과 매핑을 합쳐놓음

[운영체제] CPU 스케줄링과 알고리즘

Shine_sunho — Mon, 3 Jun 2024 15:37:13 +0900

CPU 스케줄링

CPU 스케줄러는 CPU 스케줄링에 따라 프로세스에서 해야 하는 일을 스레드 단위로 CPU에 할당함. 프로그램이 실행될 때는 CPU 스케줄링 알고리즘이 어떤 프로그램에 CPU를 줄 것인지 결정함. 이때 비선점형 알고리즘과 선점형 알고리즘으로 나뉘며 CPU를 할당함.

비선점형 방식

비선점형 방식은 프로세스가 스스로 CPU 소유권을 포기하는 방식이며, 강제로 프로세스를 중지하지 않음. 따라서 context switching으로 인한 부하가 적음

FCFS(First Come First Served)
- 큐에 도착한 순서대로 CPU를 할당함
- 실행 시간이 짧은게 뒤로 가면 평균 대기 시간이 길어짐
SJF(Shorest Job First)
- 수행시간이 제일 짧다고 판단되는 작업을 먼저 수행함
- FCFS보다 평균 대기 시간 감소, 짧은 작업에 유리
- 이때 긴 시간을 가진 프로세스가 실행되지 않는 starvation(기아현상) 이 일어날 수 있음
우선순위(HRN)
- SJF스케줄링의 경우, 긴 시간을 가진 프로세스가 실행되지 않는 현상을 보완하여 우선순위를 계산함
- 우선순위 = (대기시간 + 실행시간) / 실행시간

선점형 방식

현대 운영체제가 사용하는 방식으로 지금 사용하고 있는 프로세스를 알고리즘에 의해 중단시켜 버리고 강제로 다른 프로세스에 CPU소유권을 할당하는 방식임

라운드 로빈(Round Robin)
- FCFS에 의해 프로세스들이 보내지면 각 프로세스는 동일한 Time Quantum(실행 최소 단위 시간)만큼 CPU를 할당받음
- 할당 받는 시간이 크면 FCFS와 같아지며, 작으면 문맥 교환이 잦아져서 오버헤드가 증가함
다단계 큐(Multilevel-Queue)
- 우선순위에 따른 준비 큐를 여러개 사용하며, 큐마다 라운드 로빈이나 FCFS 등 다른 스케줄링 알고리즘을 적용함.
- 큐 간의 프로세스 이동이 안되므로 스케줄링 부담이 적지만, 유연성이 떨어짐
SRTF(Shortest Remaning Time First)
- SJF는 중간에 실행 시간이 더 짧은 작업이 들어와도 기존 작업을 모두 수행하고 그 다음 짧은 작업을 이어나감.
- SRTF는 중간에 더 짧은 작업이 들어오면 수행하던 프로세스를 중지하고 해당 프로세스를 수행하는 알고리즘
우선순위(Priority Scheduling)
- 정적/동적으로 우선순위를 부여하며 우선순위가 높은 순서대로 처리
- 우선순위가 낮은 프로세스는 무한정 기다리는 Starvation 현상이 생길 수 있음

CPU 스케줄링 척도

Reponse Time(반응 시간)
- 스케줄링에 프로세스가 준비큐에 들어와 작업이 처음 실행되기까지 걸린 시간
Turnaround Time
- 실행 시간과 대기 시간을 모두 합한 시간으로 작업이 완료될 때까지 걸린 시간

[운영체제] Mutex(뮤텍스), Semaphore(세마포어), Deadlock(데드락)

Shine_sunho — Sun, 2 Jun 2024 22:06:05 +0900

프로세스 동기화

임계 영역(Critical Section)에 진입하는 프로세스를 관리하기 위해 Mutex, Semaphore방법을 사용하여 접근을 제어한다. 이때 lock을 사용하며 획득과 방출을 이용해 다중 프로세스 접근을 제어함.

Semaphore(세마포어)

소프트웨어상에서 Critical Section 문제를 해결하기 위한 동기화 도구
간단한 정수 값과 두 가지 함수 wait(P함수) signal(V함수)로 공유 자원에 대한 접근을 처리함
wait()는 자신의 차례가 올 때 까지 기다리는 함수이며, siganl()은 다음 프로세스로 순서를 넘겨주는 함수이다.

OS 는 Counting/Binary 세마포를 구분한다

카운팅 세마포
가용한 개수를 가진 자원 에 대한 접근 제어용으로 사용되며, 세마포는 그 가용한 자원의 개수 로 초기화 된다. 자원을 사용하면 세마포가 감소, 방출하면 세마포가 증가 한다.
이진 세마포
MUTEX 라고도 부르며, 상호배제의 (Mutual Exclusion)의 머릿글자를 따서 만들어졌다. 이름 그대로 0 과 1 사이의 값만 가능하며, 다중 프로세스들 사이의 Critical Section 문제를 해결하기 위해 사용한다.

단점

Busy Waiting(바쁜 대기)
Spin lock이라고 불리는 Semaphore 초기 버전에서 Critical Section 에 진입해야하는 프로세스는 진입 코드를 계속 반복 실행해야 하며, CPU 시간을 낭비했었다. 이를 Busy Waiting이라고 부르며 특수한 상황이 아니면 비효율적이다. 일반적으로는 Semaphore에서 Critical Section에 진입을 시도했지만 실패한 프로세스에 대해 Block시킨 뒤, Critical Section에 자리가 날 때 다시 깨우는 방식을 사용한다. 이 경우 Busy waiting으로 인한 시간낭비 문제가 해결된다.

Mutex(뮤텍스)

프로세스나 스레드가 공유 자원을 lock()을 통해 잠금 설정하고 사용한 후에는 unlock()을 통해 잠금 해제하는 객체임. 잠금이 설정되면 다른 프로세스나 스레드는 잠긴 코드 영역에 접근할 수 없고 해제는 그와 반대로 진행됨.
상호배제라고도 하며 Critical Section을 가진 스레드의 Running time이 서로 겹치지 않도록 각각 단독으로 실행하게 하는 기술이다.

차이점

가장 큰 차이점은 관리하는 동기화 대상의 개수
- Mutex는 동기화 대상이 오직 하나뿐일 때, Semaphore는 동기화 대상이 하나 이상일 때 사용한다.
Semaphore는 Mutex가 될 수 있지만 Mutex는 Semaphore가 될 수 없다.
- Mutex는 상태가 0, 1 두 개 뿐인 binary Semaphore
Semaphore는 소유할 수 없는 반면, Mutex는 소유가 가능하며 소유주가 이에 대한 책임을 가진다.
- Mutex 의 경우 상태가 두개 뿐인 lock 이므로 lock 을 가질 수 있다.
Mutex의 경우 Mutex를 소유하고 있는 스레드가 이 Mutex를 해제할 수 있다. 하지만 Semaphore의 경우 이러한 Semaphore를 소유하지 않는 스레드가 Semaphore를 해제할 수 있다.
Semaphore는 시스템 범위에 걸쳐있고 파일시스템상의 파일 형태로 존재하는 반면 Mutex는 프로세스 범위를 가지며 프로세스가 종료될 때 자동으로 Clean up 된다.

교착상태(Deadlock)

>> 2개 이상의 프로세스들이 서로가 가진 자원을 기다리며 중단된 상태를 말함.

ex) 프로세스 A가 프로세스 B의 어떤 자원을 요청할 때 프로세스 B도 프로세스 A가 점유하고 있는 자원을 요청하는 것

Deadlock의 발생조건 4가지

상호 배제 : 자원은 한번에 한 프로세스만 사용할 수 있음
점유 대기 : 특정 프로세스가 점유한 자원을 다른 프로세스가 요청하는 상태
비선점 : 다른 프로세스의 자원을 강제적으로 가져올 수 없음
순환 대기: 두 개 이상의 프로세스가 자원 접근을 기다리는데, 그 관계에 사이클이 존재한다.

위 4가지 모두 성립해야 데드락이 발생함(한개라도 성립하지 않으면 데드락 문제를 해결할 수 있음)

Deadlock

예방(Preventation)
1. 교착 상태 발생 조건 중 하나를 제거하면서 해결함(자원 낭비가 심함)
회피
1. 교착 상태 발생시 피해나가는 알고리즘
2. 대표적 알고리즘 예시) 은행원 알고리즘(Banker's Algorithm)
  1. 총 자원의 양과 현재 할당한 자원의 양을 기준으로 안정 또는 불안정 상태로 나누고 안정 상태로 가도록 자원을 할당하는 알고리즘

[운영체제] 멀티 스레드와 임계영역(Critical Section)

Shine_sunho — Sun, 2 Jun 2024 21:11:57 +0900

멀티 스레드

>> 하나의 응용 프로그램에서 여러 스레드를 구성해 각 스레드가 하나의 작업을 처리하는 것

스레드들이 공유 메모리를 통해 다수의 작업을 동시에 처리하도록 진행함. 스레드는 프로세스와 달리 코드,데이터,힙은 스레드끼리 서로 공유하며, 그 외의 영역은 각각 생성됨(ex. 스택)

멀티스레딩은 프로세스 내 작업을 여러개의 스레드, 멀티스레드로 처리하는 기법이며 스레드끼리 서로 자원을 공유하기 때문에 효율성이 높음. 한 스레드가 중단(blocked) 된 상태여도 다른 스레드는 실행(running) 상태 일 수 있기 때문에 중단되지 않은 빠른 처리가 가능하며, 동시성에도 큰 장점이 있습니다.

동시성 : 서로 독립적인 작업들을 작은 단위로 나누고 동시에 실행되는 것처럼 보여주는 것

Thread-safe

Thread-safe란?
- 직역하면 스레드 안전.
- 멀티스레드 환경에서 여러 스레드가 동시에 하나의 객체 및 변수(공유 자원)에 접근할 때, 의도한 대로 동작하는 것을 말함.
- 이러한 상황을 "Thead-safe하다" 라고 표현함.
Thread-safe하게 구현하기
- Thread-safe하기 위해서는 공유 자원에 접근하는 임계영역(critical section)을 동기화 기법으로 제어해줘야 함.
  - 이를 '상호배제'라고 함.
- 동기화 기법으로는 Mutex나 Semaphore 등이 있다.
Reentrant
- Reentrant는 재진입성이라는 의미로, 어떤 함수가 Reentrant하다는 것은 여러 스레드가 동시에 접근해도 언제나 같은 실행 결과를 보장한다는 의미
- 이를 만족하기 위해서 해당 서브루틴에서는 공유자원을 사용하지 않으면 됨
  - 예를들어 정적(전역) 변수를 사용하거나 반환하면 안 되고 호출 시 제공된 매개변수만으로 동작해야함
- 따라서, Reentrant하다면 Thread-safe하지만 그 역은 성립하지 않음

공유 자원

공유 자원은 시스템 안에서 각 프로세스, 스레드가 함께 접근할 수 있는 모니터, 프린터, 메모리, 파일, 데이터 등의 자원이나 변수 등을 의미합니다. 이 공유 자원을 2개 이상의 프로세스가 동시에 읽거나 쓰는 상황을 경쟁 상태(Race Condition)이라고 함. 이처럼 동시에 접근을 시도할 때 접근의 타이밍이나 순서 등이 결괏값에 영향을 줄 수 있는 상태를 의미함.

Race Condition이 발생하는 경우

1. 커널 작업을 수행하는 중에 인터럽트 발생

커널 모드에서 작업을 수행하는 동안, 인터럽트를 disable 시켜 CPU 제어권을 가져가지 못하도록 함.

2. 프로세스가 'System Call'을 하여 커널 모드로 진입하여 작업을 수행하는 도중 문맥 교환이 발생할 때

프로세스가 커널모드에서 작업하는 경우 시간이 초과되더라도 CPU 제어권이 다른 프로세스에게 넘어가지 않도록 함.

3. 멀티 프로세서 환경에서 공유 메모리 내의 커널 데이터에 접근할 때

커널 내부에 있는 각 공유 데이터 접근할 때마다, 그 데이터에 대한 lock/ unlock을 하는 방법

임계 영역

임게 영역은 둘 이상의 프로세스, 스레드가 공유 자원에 접근 할 때 순서 등의 이유로 결과가 달라지는 코드 영역을 말함. 임계 영역을 해결하기 위한 방법은 크게 뮤텍스, 세마포어, 모니터 3가지 방법이 있으며, 이 방법 모두 상호 배제, 한정 대기, 융통성이라는 조건을 만족함.

이때 방법의 토대가 되는 메커니즘은 잠금(lock)방법을 사용함.

상호 배제 : 한 프로세스가 임계 영역에 들어갔을 때 다른 프로세스는 들어갈 수 없다.

한정 대기 : 특정 프로세스가 영원히 임계 영역에 들어가지 못하면 안된다.

융통성 : 만약 어떠한 프로세스도 임계 영역을 사용하지 않는다면 임계 영역 외부의 어떠한 프로세스도 들어갈 수 있으며 이때 프로세스끼리 서로 방해하지 않는다.

[운영체제] 멀티 프로세스와 PCB

Shine_sunho — Sun, 2 Jun 2024 19:05:37 +0900

멀티 프로세스란

>> 하나의 프로그램을 여러개의 프로세스로 구성하여 각 프로세스가 병렬적으로 작업을 수행하는 것

장점 : 안정성 (메모리 침범 문제를 OS차원에서 해결할 수 있음)

단점 : 각각 독립된 메모리 영역을 갖고 있어, 작업량이 많을 수록 Context Switching으로 인한 성능 저하가 발생함, 캐쉬 메모리를 초기화 하는 부분에서 오버헤드가 발생할 수 있음.

IPC(Inter Process Communication)

IPC는 프로세스끼리 데이터를 주고받고 공유 데이터를 관리하는 메커니즘을 뜻함.

IPC의 종류로는 공유 메모리, 파일, 소켓, 익명 파이프, 명명 파이프. 메세지 큐가 있음. 이들은 모두 메모리가 완전히 공유되는 스레드보다 속도가 떨어짐(스레드는 스택을 제외한 나머지 영역을 전부 공유하기 때문에 오버헤드에 대한 우려가 적음)

1. 익명 PIPE

한쪽 방향으로만 통신이 가능한 단방향 통신, FIFO방식으로 읽히며 양쪽으로 모두 송/수신을 하고 싶으면 2개의 파이프를 만들어야함.
매우 간단하게 사용할 수 있는 장점이 있고 전이중 통신을 하기 위해선 2개를 만들어야함
부모, 자식 프로세스 간에만 사용할 수 있으며 다른 네트워크 상에서는 사용이 불가능함

2. Name PIPE(FIFO)

부모-자식 간 통신처럼 명확히 알 경우 뿐 아니라, 전혀 모르는 상태의 프로세스들 사이에 통신에 사용됨
부모 프로세스와 무관한 다른 프로세스와도 통신이 가능함 (통신을 위해 이름 있는 파일을 사용)
익명 파이프와 같이 읽기/쓰기 동시에 불가능함

3. 메세지 큐

파이프처럼 데이터의 흐름이 존재하는 것이 아닌, 메모리 공간으로 사용됨
메세지를 큐 데이터 구조 형태로 관리하며 커널의 전역 변수 형태 등 커널에서 전역적으로 관리되며 사용방법이 매우 직관적이고 간단함.

4. 공유 메모리

데이터 자체를 공유하도록 지원하는 설비.
여러 프로세스에 동일한 메모리 블록에 대한 접근 권한이 부여되어 프로세스가 서로 통신할 수 있도록 공유 메모리를 생성해서 통신하는것을 말함
기본적으로 각 프로세스의 메모리를 다른 프로세스가 접근 할 수 없지만, 공유 메모리를 통해 여러 프로세스가 하나의 메모리를 공유 할 수 있음
불필요한 오버헤드가 발생하지 않아 가장 빠르며 같은 메모리 영역을 여러 프로세스가 공유하기 때문에 동기화가 필요함

5. 파일

파일을 메모리에 맵핑시켜 공유하는 방식

6. 소켓

네트워크 소켓 통신을 통해 데이터를 공유함 TCP와 UDP가 있음

이러한 IPC 통신에서 프로세스간 데이터를 동기화하고 보호하기 위해 세마포어와 뮤텍스를 사용함 (공유된 자원에 한번에 하나의 프로세스만 접근을 시킬 때)

Context Switching이란?

프로세스의 상태 정보를 저장하고 복원하는 일련의 과정임

즉, 동작 중인 프로세스의 상태를 저장하고 로드시키는 과정을 말함. 한 프로세스가 할당 된 시간이 끝나거나 인터럽트에 의해 발생함.

이때 PCB를 기반으로 프로세스의 상태를 가져오며 이전에 보관했던 프로세스 상태를 복구하는 과정도 포함됨

이때 프로세스가 가지고 있는 메모리 주소가 그대로 있으면 잘못된 주소 변환이 생기므로 캐스 클리어 과정을 겪게 되고, 이 때문에 캐시미스가 발생할 수 있음

캐시미스는 컨텍스트 스위칭에 드는 비용임.

PCB(Process Control Block)

PCB는 운영체제에서 프로세스의 메타데이터를 저장한 '데이터'를 말함. 프로세스 제어 블록이라고도 불림. 프로세스가 생성되면 운영체제는 해당 PCB를 생성함.

프로그램이 실행되면 프로세스가 생성되고 프로세스 주소 값들에 앞서 설명한 스택, 힙 등의 구조를 기반으로 메모리가 할당됨. 이 프로세스의 메타데이터들이 PCB에 저장되어 관리 됨. 이 때문에 일반 사용자가 접근하지 못하도록 커널 스택의 가장 앞부분에서 관리됨. 이때 PCB는 Linked List 방식으로 관리됨.

PCB의 구조

PCB는 프로세스 스케줄링 상태, 프로세스 ID 등의 다음과 같은 정보로 이뤄져 있음

프로세스 스케줄링 상태
프로세스 ID
프로세스 권한
프로그램 카운터
CPU 레지스터
CPU 스케줄링 정보
계정 정보
I/O 상태 정보

[운영체제] 프로세스 & 스레드

Shine_sunho — Sun, 2 Jun 2024 18:36:46 +0900

운영 체제의 역할

운영 체제의 역할은 크게 4가지가 있음

1. CPU 스케줄링과 프로세스 관리

2. 메모리 관리

3. 디스크 파일 관리

4. I/O 디바이스 관리

프로세스

프로그램을 메모리 상에서 실행 중인 작업, CPU의 스케줄링의 대상이 되는 작업을 의미함
프로그램이 메모리에 올라가면 프로세스가 되는 인스턴스화가 일어나며, 운영체제의 CPU스케줄러에 따라 CPU가 프로세스를 실행함

스레드

프로세스 안에서 실행되는 여러 흐름 단위

기본적으로 프로세스마다 최소 1개의 쓰레드를 보유하고 있음(메인 스레드 포함)

프로세스는 독립적으로 작동하며 각각 별도의 주소공간을 할당함

하나의 프로세스가 생성될 때, 기본적으로 하나의 스레드 같이 생성 진행

프로세스는 자신만의 고유 공간과 자원을 할당받아 사용하는 반면, 스레드는 다른 스레드와 공간, 자원을 공유하면서 사용하는 차이가 존재

프로세스 메모리 구조

이때 프로세스는 총 4개의 영역이 존재함

Code : 코드 자체를 구성하는 메모리 영역(프로그램 영역), Code segment라고 불림

Data : 전역변수, 정적변수,배열(Bss segment, Data Segment로 나뉨)

초기화 된 데이터는 data영역에 저장, static, cosnt로 선언 되어 있고, 0이 아닌 값으로 초기화 된 변수가 해당 메모리 영역에 할당 됨
초기화 되지 않는 데이터는 bss영역에 저장, 전역 변수 또는 static, const로 선언되어 있고 0으로 초기화 또는 초기화가 어떠한 값으로도 되어 있지 않은 변수들이 이 메모리 영역에 할당.

Heap : 동적 할당 시 사용( new(), malloc() 등)

Stack : 지역변수, 매개변수, 리턴 값(임시 메모리 영역), 함수가 호출 될 때마다 호출될 때의 환경 등 특정 정보가 스택에 계속해서 저장됨, 또한 재귀 함수가 호출된다고 했을 때, 새로운 스택 프레임이 매번 사용되기 때문에 함수 내의 변수 집합이 해당 함수의 다른 인스턴스 변수를 방해하지 않음.

프로세스 내에 있는 스레드는 stack만 따로 할당 받고 나머지 영역은 서로 공유한 상태임

프로그래머스 level3 경주로 건설 - python

Shine_sunho — Thu, 2 May 2024 14:59:45 +0900

경주로 건설

문제 설명

건설회사의 설계사인 죠르디는 고객사로부터 자동차 경주로 건설에 필요한 견적을 의뢰받았습니다.
제공된 경주로 설계 도면에 따르면 경주로 부지는 N x N 크기의 정사각형 격자 형태이며 각 격자는 1 x 1 크기입니다.
설계 도면에는 각 격자의 칸은 0 또는 1 로 채워져 있으며, 0은 칸이 비어 있음을 1은 해당 칸이 벽으로 채워져 있음을 나타냅니다.
경주로의 출발점은 (0, 0) 칸(좌측 상단)이며, 도착점은 (N-1, N-1) 칸(우측 하단)입니다. 죠르디는 출발점인 (0, 0) 칸에서 출발한 자동차가 도착점인 (N-1, N-1) 칸까지 무사히 도달할 수 있게 중간에 끊기지 않도록 경주로를 건설해야 합니다.
경주로는 상, 하, 좌, 우로 인접한 두 빈 칸을 연결하여 건설할 수 있으며, 벽이 있는 칸에는 경주로를 건설할 수 없습니다.
이때, 인접한 두 빈 칸을 상하 또는 좌우로 연결한 경주로를 직선 도로 라고 합니다.
또한 두 직선 도로가 서로 직각으로 만나는 지점을 코너 라고 부릅니다.
건설 비용을 계산해 보니 직선 도로 하나를 만들 때는 100원이 소요되며, 코너를 하나 만들 때는 500원이 추가로 듭니다.
죠르디는 견적서 작성을 위해 경주로를 건설하는 데 필요한 최소 비용을 계산해야 합니다.

예를 들어, 아래 그림은 직선 도로 6개와 코너 4개로 구성된 임의의 경주로 예시이며, 건설 비용은 6 x 100 + 4 x 500 = 2600원 입니다.

또 다른 예로, 아래 그림은 직선 도로 4개와 코너 1개로 구성된 경주로이며, 건설 비용은 4 x 100 + 1 x 500 = 900원 입니다.

도면의 상태(0은 비어 있음, 1은 벽)을 나타내는 2차원 배열 board가 매개변수로 주어질 때, 경주로를 건설하는데 필요한 최소 비용을 return 하도록 solution 함수를 완성해주세요.

[제한사항]

board는 2차원 정사각 배열로 배열의 크기는 3 이상 25 이하입니다.
board 배열의 각 원소의 값은 0 또는 1 입니다.
도면의 가장 왼쪽 상단 좌표는 (0, 0)이며, 가장 우측 하단 좌표는 (N-1, N-1) 입니다.
원소의 값 0은 칸이 비어 있어 도로 연결이 가능함을 1은 칸이 벽으로 채워져 있어 도로 연결이 불가능함을 나타냅니다.
board는 항상 출발점에서 도착점까지 경주로를 건설할 수 있는 형태로 주어집니다.
출발점과 도착점 칸의 원소의 값은 항상 0으로 주어집니다.

입출력 예

board	result
[[0,0,0],[0,0,0],[0,0,0]]	900
[[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,1,0,0,0],[0,0,0,1,0,0,0,1],[0,0,1,0,0,0,1,0],[0,1,0,0,0,1,0,0],[1,0,0,0,0,0,0,0]]	3800
[[0,0,1,0],[0,0,0,0],[0,1,0,1],[1,0,0,0]]	2100
[[0,0,0,0,0,0],[0,1,1,1,1,0],[0,0,1,0,0,0],[1,0,0,1,0,1],[0,1,0,0,0,1],[0,0,0,0,0,0]]	3200

입출력 예에 대한 설명

입출력 예 #1

본문의 예시와 같습니다.

입출력 예 #2

위와 같이 경주로를 건설하면 직선 도로 18개, 코너 4개로 총 3800원이 듭니다.

입출력 예 #3

위와 같이 경주로를 건설하면 직선 도로 6개, 코너 3개로 총 2100원이 듭니다.

입출력 예 #4

붉은색 경로와 같이 경주로를 건설하면 직선 도로 12개, 코너 4개로 총 3200원이 듭니다.
만약, 파란색 경로와 같이 경주로를 건설한다면 직선 도로 10개, 코너 5개로 총 3500원이 들며, 더 많은 비용이 듭니다.

문제 풀이

from collections import deque

# [[0,0,1,0],
#  [0,0,0,0],
#  [0,1,0,1],
#  [1,0,0,0]]
max_num = 1000000000


def solution(board):
    answer = []
    matrix = [[max_num for _ in range(len(board))] for _ in range(len(board))]
    dx = [1, -1, 0, 0]
    dy = [0, 0, 1, -1]
    direct = [0, 2, 1, 3]

    # 0 오른쪽
    # 1 아랫쪽
    # 2 왼쪽
    # 3 위쪽
    def bfs(x, y, cost, dirr):

        if dirr == 0:  # 오른쪽 출발
            que = deque()
            que.append((x, y, cost, dirr))
            while que:
                x, y, cost, dirr = que.popleft()
                for i in range(4):
                    xx = x + dx[i]
                    yy = y + dy[i]
                    now_dir = direct[i]
                    if 0 <= xx < len(board) and 0 <= yy < len(board):
                        if dirr == now_dir:  # 같은 방향일 때
                            # print(y,x,dirr,now_dir)
                            new_cost = cost + 100
                        else:
                            new_cost = cost + 600
                        if board[yy][xx] == 0:  # 보드가 벽이 아닐때
                            if matrix[yy][xx] > new_cost:
                                matrix[yy][xx] = min(matrix[yy][xx], new_cost)
                                que.append((xx, yy, new_cost, now_dir))

        elif dirr == 1:  # 아랫쪽 출발
            que = deque()
            que.append((x, y, cost, dirr))
            while que:
                x, y, cost, dirr = que.popleft()
                for i in range(4):
                    xx = x + dx[i]
                    yy = y + dy[i]
                    now_dir = direct[i]
                    if 0 <= xx < len(board) and 0 <= yy < len(board):
                        if dirr == now_dir:  # 같은 방향일 때
                            new_cost = cost + 100
                        else:
                            new_cost = cost + 600
                        if board[yy][xx] == 0:  # 보드가 벽이 아닐때
                            if matrix[yy][xx] > new_cost:
                                matrix[yy][xx] = min(matrix[yy][xx], new_cost)
                                que.append((xx, yy, new_cost, now_dir))
        # print(matrix)
        return

    answer = []
    # 오른쪽 방향
    for i in range(len(board)):
        for j in range(len(board)):
            if board[i][j] == 1:
                matrix[i][j] = 1
    matrix[0][0] = 0
    bfs(0, 0, 0, 0)
    answer.append(matrix[-1][-1])

    # 왼쪽 방향
    matrix = [[max_num for _ in range(len(board))] for _ in range(len(board))]
    for i in range(len(board)):
        for j in range(len(board)):
            if board[i][j] == 1:
                matrix[i][j] = 1
    bfs(0, 0, 0, 1)
    answer.append(matrix[-1][-1])

    print(answer)
    return min(answer)

문제 접근

경주로를 건설할때 고려해야하는 포인트는 2가지라 생각했습니다.

1. 경주로의 방향 설정

2. cost를 최소화하며 진행

다음 조건 2가지를 변수로 저장하며 BFS로 탐색을 진행하기로 하여, deque에 cost와 dirr 변수를 저장하여 탐색을 진행했습니다.

이때, 진행할 수 있는 방향이 0,0방향에서 오른쪽 방향과 아래쪽 방향으로 나뉠 수 있기 때문에, 2번의 BFS를 통해 최소값을 가져와 값을 도출했습니다.

알고리즘 진행 방식은 다음과 같습니다.

1. 초기 변수로 matrix를 초기화 합니다. 이때 최소값 cost를 구해야하므로 초기값은 무한대값으로 설정합니다.

2. 방향에 맞춰 탐색을 진행합니다. 이때 4방탐색 기준으로, 방향값을 설정하여 방향이 일치하면 cost 100, 방향이 다르다면 600을 더합니. 이때 기존 500이 아닌 600을 더하는 이유는, 꺾이는 방향에서 100 + 500이 동시에 계산되기 때문입니다.

3. matrix의 최소값을 비교하며 벽을 피해 탐색을 진행합니다.

4. 도착하면 matrix[-1][-1] 의 값을 가져옵니다.

프로그래머스 PCCP 기출문제 1번 - 붕대감기 [python]

Shine_sunho — Tue, 30 Apr 2024 17:14:51 +0900

구현

PCCP로 코딩테스트 역량을 보는 필기 시험이 있어서, PCCP를 준비하며 문제를 풀어봤습니다.

https://programmers.co.kr/app/with_setting/tests/131575/challenges/algorithms/20179?language=python3

문제 풀이

def solution(bandage, health, attacks):
    now_health = health # 최대 체력
    attack_time = [i[0] for i in attacks]
    dealing = [i[1] for i in attacks]
    max_time = max([i[0] for i in attacks]) # 최대시간
    bandage_time = bandage[0] # 시전 시간
    second_healing = bandage[1] # 초당 회복량
    more_healing = bandage[2] # 추가회복량
    cnt = 0 # 붕대 시간
    for time in range(1,max_time+1):
        if time in attack_time: # 시간이 경과했을 때 공격 상태일 때
            cnt = 0 #연속 성공 초기화
            now_health -= dealing[attack_time.index(time)] #몬스터 공격
            if now_health <= 0: # 몬스터 공격했을때 피가 0이하면 종료
                answer = -1
                return answer
                # break
        else:
            cnt +=1
            if cnt == bandage_time: # 시전 시간이 됐을 때
                cnt = 0
                now_health += more_healing
                if now_health >= health :
                    now_health = health
            if now_health == health: # 체력이 최대 체력일 때
                pass
            else: # 체력이 최대 체력이 아닐 때
                now_health += second_healing
                if now_health >= health:
                    now_health = health
    print(now_health)

    if now_health <= 0:
        answer = -1
    else:
        answer = now_health
    return answer

문제 해석

조건에 맞춰 코드를 작성했습니다.

1. 시간이 흐른다.

1 - 1) 몬스터한테 공격을 받았을 경우 피가 감소함

1 - 2) 몬스터 한테 공격 받고 피가 0 이하면 종료

2. 시간이 흐를 때 초당 체력힐링으로 피가 증가함.

2 - 1) 피는 최대 체력을 넘을 수 없음

2 - 2) 붕대 요구 시간이 다차면 추가 힐링을 시작함.

프로그래머스 level2 전력망을 둘로 나누기 - python

Shine_sunho — Thu, 21 Mar 2024 15:32:56 +0900

전력망을 둘로 나누기

문제 설명

n개의 송전탑이 전선을 통해 하나의 트리 형태로 연결되어 있습니다. 당신은 이 전선들 중 하나를 끊어서 현재의 전력망 네트워크를 2개로 분할하려고 합니다. 이때, 두 전력망이 갖게 되는 송전탑의 개수를 최대한 비슷하게 맞추고자 합니다.

송전탑의 개수 n, 그리고 전선 정보 wires가 매개변수로 주어집니다. 전선들 중 하나를 끊어서 송전탑 개수가 가능한 비슷하도록 두 전력망으로 나누었을 때, 두 전력망이 가지고 있는 송전탑 개수의 차이(절대값)를 return 하도록 solution 함수를 완성해주세요.

제한사항

n은 2 이상 100 이하인 자연수입니다.
wires는 길이가 n-1인 정수형 2차원 배열입니다.
- wires의 각 원소는 [v1, v2] 2개의 자연수로 이루어져 있으며, 이는 전력망의 v1번 송전탑과 v2번 송전탑이 전선으로 연결되어 있다는 것을 의미합니다.
- 1 ≤ v1 < v2 ≤ n 입니다.
- 전력망 네트워크가 하나의 트리 형태가 아닌 경우는 입력으로 주어지지 않습니다.

입출력 예

n	wires	result
9	[[1,3],[2,3],[3,4],[4,5],[4,6],[4,7],[7,8],[7,9]]	3
4	[[1,2],[2,3],[3,4]]	0
7	[[1,2],[2,7],[3,7],[3,4],[4,5],[6,7]]	1

입출력 예 설명

입출력 예 #1

다음 그림은 주어진 입력을 해결하는 방법 중 하나를 나타낸 것입니다.

4번과 7번을 연결하는 전선을 끊으면 두 전력망은 각 6개와 3개의 송전탑을 가지며, 이보다 더 비슷한 개수로 전력망을 나눌 수 없습니다.
또 다른 방법으로는 3번과 4번을 연결하는 전선을 끊어도 최선의 정답을 도출할 수 있습니다.

입출력 예 #2

다음 그림은 주어진 입력을 해결하는 방법을 나타낸 것입니다.

2번과 3번을 연결하는 전선을 끊으면 두 전력망이 모두 2개의 송전탑을 가지게 되며, 이 방법이 최선입니다.

입출력 예 #3

다음 그림은 주어진 입력을 해결하는 방법을 나타낸 것입니다.
3번과 7번을 연결하는 전선을 끊으면 두 전력망이 각각 4개와 3개의 송전탑을 가지게 되며, 이 방법이 최선입니다.

문제 풀이

from collections import deque


def solution(n, wires):
    res = 0
    graph = [[] for _ in range(n + 1)]
    for a, b in wires:
        graph[a].append(b)
        graph[b].append(a)

    def bfs(start):
        visited = [0] * (n + 1)
        q = deque([start])
        visited[start] = 1
        cnt = 1
        while q:
            s = q.popleft()
            for i in graph[s]:
                if not visited[i]:
                    q.append(i)
                    visited[i] = 1
                    cnt += 1
        return cnt

    res = n
    for a, b in wires:
        # graph에서 remove
        graph[a].remove(b)
        graph[b].remove(a)

        res = min(abs(bfs(a) - bfs(b)), res)

        # 다시 append
        graph[a].append(b)
        graph[b].append(a)

    return res

문제 접근

1. 주어진 전력망을 링크드리스트를 사용하여 다 연결한다.

2. 주어진 연결망을 탐색하며 임의로 하나를 자른다.

3. 이후 2개로 나뉘어진 전력망을 BFS를 통해 탐색을 진행한다.

4. 2개의 전력망의 차이를 계산하며 res값을 지속해서 변경한다.

5. 탐색이 다 끝나며 res값을 갱신했을 때 최소값을 return한다.

Baekjoon [20920] 영단어 암기는 괴로워 - python

Shine_sunho — Fri, 15 Mar 2024 15:33:51 +0900

문제

https://www.acmicpc.net/problem/20920

20920번: 영단어 암기는 괴로워

첫째 줄에는 영어 지문에 나오는 단어의 개수 $N$과 외울 단어의 길이 기준이 되는 $M$이 공백으로 구분되어 주어진다. ($1 \leq N \leq 100\,000$, $1 \leq M \leq 10$) 둘째 줄부터 $N+1$번째 줄까지 외울 단

www.acmicpc.net

풀이 코드

# 다음과 같은 우선순위를 차례로 적용하여 만들어진다.
#
# 자주 나오는 단어일수록 앞에 배치한다.
# 해당 단어의 길이가 길수록 앞에 배치한다.
# 알파벳 사전 순으로 앞에 있는 단어일수록 앞에 배치한다
#
# M보다 짧은 길이의 단어의 경우 읽는 것만으로도 외울 수 있기 때문에 길이가 M이상인 단어들만 외운다고 한다.

import sys
from collections import defaultdict
input = sys.stdin.readline

n,m = map(int,input().split())
word_list = defaultdict(int)
for i in range(n):
    word = input().strip()
    if len(word) >= m:
        word_list[word] +=1
sort_dict = sorted(word_list.items() ,key =lambda x : (-x[1],-len(x[0]),x[0]))


for i in sort_dict:
    print(i[0])

문제 접근

1. 자주 나오는 단어일수록 앞에 배치한다.

2. 해당 단어의 길이가 길수록 앞에 배치한다.

3. 알파벳 사전 순으로 앞에 있는 단어일수록 앞에 배치한다.

위 3개의 조건에 맞춰 단어를 정렬하면 된다. M글자수보다 작은 길이의 글자들은 defaultdict에 추가하지않는다.

defaultdict을 통해 빠르게 중복된 글자의 개수를 구해준다. 이후, sorted 함수와 lambda함수를 통해 정렬을 진행한다.

해당 문제를 풀면서 key값으로 정렬을 진행할때, 튜플 형식으로 정렬 조건을 나열하면 순차적으로 정렬을 진행하는것을 배웠다.

-x[1]을 통해 단어의 개수를 기반으로 정렬하고, -len(x[0])을 통해 단어의 길이를 기반으로 정렬, x[0]을 통해 알파벳 사전순으로 정렬을 진행했다.

Baekjoon [5972] 택배배송 - python

Shine_sunho — Thu, 7 Mar 2024 16:48:42 +0900

문제

5972번: 택배 배송

농부 현서는 농부 찬홍이에게 택배를 배달해줘야 합니다. 그리고 지금, 갈 준비를 하고 있습니다. 평화롭게 가려면 가는 길에 만나는 모든 소들에게 맛있는 여물을 줘야 합니다. 물론 현서는

www.acmicpc.net

코드 풀이

import heapq

n,m = map(int,input().split())
INF = int(1e9)
linked_list = [[] for _ in range(n+1)]

for i in range(m):
    node1,node2,cost = map(int,input().split())
    linked_list[node1].append((node2,cost))
    linked_list[node2].append((node1,cost))

distance = [INF] * (n+1)
# print(distance)
def dijkstra(start):
    q = []
    heapq.heappush(q, (0, start))
    distance[start] = 0
    while q:
        dist, now = heapq.heappop(q)
        if distance[now] < dist:
            continue
        for i in linked_list[now]:
            cost = dist + i[1]
            if cost < distance[i[0]]:
                distance[i[0]] = cost
                heapq.heappush(q, (cost, i[0]))

dijkstra(1)
# print(distance)
if distance[n] == INF:
    print(-1)
else:
    print(distance[n])

문제 접근

기본적인 다익스트라 알고리즘이다.

1. 먼저 링크드리스트 또는 인접행렬을 통해 노드간 간선 비용을 저장한다.

2. 간선 비용을 최소화 할 수 있게 distance 변수로 모든 간선 비용을 최대값으로 설정한다.

3. 시작지점으로부터 다익스트라 알고리즘을 시작한다.

3-1. 최소힙을 유지하는 python의 heapq모듈을 사용하여 노드간 정보를 담아온다.

3-2. heapq에서 정보값을 하나씩 추출하면서 추출한 노드의 인접 노드간의 간선 정보를 계산한다.

3-3. 노드 간선 정보값 비교를 통해 값이 작다면 distance 변수값을 바꿔준다.

4. 3-1,3-2,3-3 을 지속적으로 반복한다.

Baekjoon [14889] 스타트와 링크 - python

Shine_sunho — Wed, 6 Mar 2024 19:28:06 +0900

문제

14889번: 스타트와 링크

예제 2의 경우에 (1, 3, 6), (2, 4, 5)로 팀을 나누면 되고, 예제 3의 경우에는 (1, 2, 4, 5), (3, 6, 7, 8)로 팀을 나누면 된다.

www.acmicpc.net

코드 풀이

import sys
from itertools import combinations
from collections import deque
input = sys.stdin.readline

# def bfs(list1):
    # start_node = list1[0]
    # que = deque()
    # que.append(start_node)
    # visited = []
    # visited.append(start_node)
    # sum1 = 0
    # while que:
    #     node = que.popleft()

n = int(input().strip())
matirx = []
for i in range(n):
    matirx.append(list(map(int,input().split())))
min_value = float('inf')
for combi in combinations(range(n),n//2):
    answer1= 0
    answer2 = 0
    combi = (list(combi)) # 조합 된 노드 탐색 시작
    another_combi = [i for i in range(n) if i not in combi] # 그외 조합되지 않은 노트 탐색 시작
    for r in combinations(combi, 2):  # 5
        answer1 += matirx[r[0]][r[1]]
        answer1 += matirx[r[1]][r[0]]
    for r in combinations(another_combi, 2):  # 6
        answer2 += matirx[r[0]][r[1]]
        answer2 += matirx[r[1]][r[0]]
    min_value = min(min_value, abs(answer1 - answer2))  # 7
print(min_value)

문제 접근

1. 주어진 matrix 길이의 /2 만큼 조합을 만들어 낸다.

2. 이후 추출된 조합리스트에서 2개의 인덱스를 선정해서 값을 더한다.

3. 2개의 최소값을 비교하며 값을 도출한다.

Baekjoon [17471] 게리맨더링 - python

Shine_sunho — Tue, 5 Mar 2024 16:27:02 +0900

문제

https://www.acmicpc.net/problem/17471

17471번: 게리맨더링

선거구를 [1, 4], [2, 3, 5, 6]으로 나누면 각 선거구의 인구는 9, 8이 된다. 인구 차이는 1이고, 이 값보다 더 작은 값으로 선거구를 나눌 수는 없다.

www.acmicpc.net

문제 풀이

#  구역을 두 개의 선거구로 나눠야 하고, 각 구역은 두 선거구 중 하나에 포함되어야 한다.
#  선거구는 구역을 적어도 하나 포함해야 하고, 한 선거구에 포함되어 있는 구역은 모두 연결되어 있어야 한다.
#  구역 A에서 인접한 구역을 통해서 구역 B로 갈 수 있을 때, 두 구역은 연결되어 있다고 한다.
#  중간에 통하는 인접한 구역은 0개 이상이어야 하고, 모두 같은 선거구에 포함된 구역이어야 한다.
import itertools
import collections
import sys
input = sys.stdin.readline

def bfs(same):
    start = same[0] # 조합된 노드 중 첫번째 노드로 start지점 생성
    # print(start)
    q = collections.deque([start]) # deque로 탐색 노드 값 저장
    visited = set([start])
    # print(visited)
    _sum = 0
    while q:
        v = q.popleft() # 처음 노드 값 추출
        _sum += node_number[v] # 해당 노드의 인구수 값 저장
        # print(linked_list[v])
        for u in linked_list[v]: # 탐색할 노드의 인접 노드 탐색
            if u not in visited and u in same: # 인접 노드가 방문하지 않은 노드이며 조합된 노드들로 구성된 경우,
                q.append(u) # q에 추가
                visited.add(u) # 방문한 노드로 체크
    return _sum, len(visited) # 탐색 한 노드들의 인구수 합, 노드 길이 리턴


n = int(input())
node_number = list(map(int,input().split()))
# print(node_number)
result = float('inf')
linked_list = [[] for _ in range(n)]

for i in range(n):
    near_node = list(map(int,input().split()))
    for j in range(1, near_node[0] + 1):
        linked_list[i].append(near_node[j] - 1)

    # linked list형태로 인접 노드 저장
# print(linked_list)
for i in range(1, n//2 + 1):
    combis = list(itertools.combinations(range(n), i)) # 주어진 노드로 조합 생성
    for combi in combis: # 조합 탐색
        # print(combi)
        sum1, v1 = bfs(combi) # 조합 된 노드 탐색 시작
        sum2, v2 = bfs([i for i in range(n) if i not in combi]) # 그외 조합되지 않은 노트 탐색 시작
        if v1 + v2 == n:  # 2번의 bfs를 통해 모든 노드가 방문되었는지 확인한다.
            result = min(result, abs(sum1 - sum2))

if result != float('inf'):
    print(result)
else:
    print(-1)

문제 접근

#  구역을 두 개의 선거구로 나눠야 하고, 각 구역은 두 선거구 중 하나에 포함되어야 한다.
#  선거구는 구역을 적어도 하나 포함해야 하고, 한 선거구에 포함되어 있는 구역은 모두 연결되어 있어야 한다.
#  구역 A에서 인접한 구역을 통해서 구역 B로 갈 수 있을 때, 두 구역은 연결되어 있다고 한다.
#  중간에 통하는 인접한 구역은 0개 이상이어야 하고, 모두 같은 선거구에 포함된 구역이어야 한다.

문제는 다음과 같다.

1. 구역을 2개로 나눈다.

2. 구역은 모두 연결되어야 한다.

3. 인접한 구역을 탐색하여 연결된 노드들을 탐색한다.

4. 연결된 노드들의 인구 정보를 계산한다.

5. 노드를 전부 탐색하여 2개의 구역으로 나눠졌을 때 합한 인구정보의 차가 최소가 되게 만든다.

해당 방식에 대한 어려움이 생겨 타인의 코드를 참고했다.

[참고 코드]

[백준] 17471 - 게리맨더링 [Python(파이썬)]

문제 www.acmicpc.net/problem/17471 17471번: 게리맨더링 선거구를 [1, 4], [2, 3, 5, 6]으로 나누면 각 선거구의 인구는 9, 8이 된다. 인구 차이는 1이고, 이 값보다 더 작은 값으로 선거구를 나눌 수는 없다. www.

cotak.tistory.com

코드의 진행 방식은 다음과 같다.

1. 인풋값들을 링크드 리스트를 통해 노드에 인접한 노드 번호를 저장한다.

2. 구역을 2개로 나누기 위해 조합을 사용한다. 이때 조합을 사용할 때 n//2를 하는 이유는 다음과 같다. 전체 n에서 특정 조합을 만들고 특정 조합을 제외한 차집합을 구할 때 나오는 경우의 수는 반대 조건일 때 해당 되기 때문에, 최대 n/2의 수로 조합을 만드는 것이다.

ex) 6개의 덩어리에서 2,4로 나누는 것과 4,2 로 나누는 것은 동일하다는 의미.

즉 최대 3,3까지 나오는 경우의수가 제일 많은 경우의 수!!

3. 조합을 나눴으면 조합의 시작 노드를 바탕으로 BFS탐색을 진행한다. 이때 사용되는 변수들은 인구정보를 담고 있는 리스트 변수와 링크드 리스트로 구현되어있는 리스트를 사용한다.

4. 조합으로 만들어진 경우의 수에 있는 노드들이 탐색하지 않는 노드이면서 시작노드와 인접한 노드일 경우 인구정보를 계산하며 탐색을 시작.

5. 계산이 될수록 result변수를 통해 최소값 비교를 통해 값을 추출한다.

6. 값 도출

위 방식으로 알고리즘이 작동을 하였다. 처음에 조합 방식 자체를 생각하지 못해 구역을 나누는데 있어 어려움을 겪었다. 보다 나은 알고리즘 풀이를 위해 다양한 방식으로 접근해보는 사고력을 기르자!!

Baekjoon [2116] 주사위 쌓기 - python

Shine_sunho — Tue, 5 Mar 2024 14:35:20 +0900

문제

https://www.acmicpc.net/problem/2116

2116번: 주사위 쌓기

첫줄에는 주사위의 개수가 입력된다. 그 다음 줄부터는 한 줄에 하나씩 주사위의 종류가 1번 주사위부터 주사위 번호 순서대로 입력된다. 주사위의 종류는 각 면에 적혀진 숫자가 그림1에 있는

www.acmicpc.net

코드 풀이

import copy
import sys
sys.setrecursionlimit(10**6)


n = int(input())
n_dice = []
total_dice = []
depth =0
summ_dice = 0
for i in range(n):
    n_dice.append(list(map(int,input().split())))

def sum_dice(idx,depth):
    global summ_dice
    # print(idx,depth)
    # print(summ_dice)
    # print(test_dice)
    if depth  >= n:
        print("yes")
        return summ_dice
    if idx == 0:
        new_idx = 5
        start_idx = test_dice[depth][idx]
        end_idx = test_dice[depth][new_idx]
        if depth +1 >= n:
            # print(depth)
            test_dice[depth].remove(start_idx)
            test_dice[depth].remove(end_idx)
            max_num = max(test_dice[depth])
            summ_dice += max_num
            return summ_dice
        target_idx = test_dice[depth+1].index(end_idx)
        # print(target_idx)
        test_dice[depth].remove(start_idx)
        test_dice[depth].remove(end_idx)
        max_num = max(test_dice[depth])
        summ_dice += max_num
        depth +=1
        # print(n_dice)
        # print(test_dice[depth].index(new_idx))
        return sum_dice(target_idx,depth)
    elif idx == 1:
        new_idx = 3
        start_idx = test_dice[depth][idx]
        end_idx = test_dice[depth][new_idx]
        if depth + 1 >= n:
            # print(depth)
            test_dice[depth].remove(start_idx)
            test_dice[depth].remove(end_idx)
            max_num = max(test_dice[depth])
            summ_dice += max_num
            return summ_dice
        target_idx = test_dice[depth+1].index(end_idx)
        test_dice[depth].remove(start_idx)
        test_dice[depth].remove(end_idx)
        max_num = max(test_dice[depth])
        summ_dice += max_num
        depth +=1

        return sum_dice(target_idx,depth)
    elif idx == 2:
        new_idx = 4
        start_idx = test_dice[depth][idx]
        end_idx = test_dice[depth][new_idx]
        if depth + 1 >= n:
            # print(depth)
            test_dice[depth].remove(start_idx)
            test_dice[depth].remove(end_idx)
            max_num = max(test_dice[depth])
            summ_dice += max_num
            return summ_dice
        target_idx = test_dice[depth+1].index(end_idx)
        test_dice[depth].remove(start_idx)
        test_dice[depth].remove(end_idx)
        max_num = max(test_dice[depth])
        summ_dice += max_num
        depth +=1

        return sum_dice(target_idx,depth)
    elif idx == 3:
        new_idx = 1
        start_idx = test_dice[depth][idx]
        end_idx = test_dice[depth][new_idx]
        if depth + 1 >= n:
            # print(depth)
            test_dice[depth].remove(start_idx)
            test_dice[depth].remove(end_idx)
            max_num = max(test_dice[depth])
            summ_dice += max_num
            return summ_dice
        target_idx = test_dice[depth+1].index(end_idx)
        test_dice[depth].remove(start_idx)
        test_dice[depth].remove(end_idx)
        max_num = max(test_dice[depth])
        summ_dice += max_num
        depth +=1

        return sum_dice(target_idx,depth)
    elif idx == 4:
        new_idx = 2
        start_idx = test_dice[depth][idx]
        end_idx = test_dice[depth][new_idx]
        if depth + 1 >= n:
            # print(depth)
            test_dice[depth].remove(start_idx)
            test_dice[depth].remove(end_idx)
            max_num = max(test_dice[depth])
            summ_dice += max_num
            return summ_dice
        target_idx = test_dice[depth+1].index(end_idx)
        test_dice[depth].remove(start_idx)
        test_dice[depth].remove(end_idx)
        max_num = max(test_dice[depth])
        summ_dice += max_num
        depth +=1

        return sum_dice(target_idx,depth)
    elif idx == 5:
        new_idx = 0
        start_idx = test_dice[depth][idx]
        end_idx = test_dice[depth][new_idx]
        if depth + 1 >= n:
            # print(depth)
            test_dice[depth].remove(start_idx)
            test_dice[depth].remove(end_idx)
            max_num = max(test_dice[depth])
            summ_dice += max_num
            return summ_dice
        target_idx = test_dice[depth+1].index(end_idx)
        test_dice[depth].remove(start_idx)
        test_dice[depth].remove(end_idx)
        max_num = max(test_dice[depth])
        summ_dice += max_num
        depth +=1

        return sum_dice(target_idx,depth)
for i in range(6):
    test_dice = copy.deepcopy(n_dice)
    depth = 0
    summ_dice = 0
    b = sum_dice(i,depth)
    total_dice.append(b)
# print(total_dice)
print(max(total_dice))

문제 접근

주사위 면이 주어지고, 쌓인 주사위에서 그리디 알고리즘을 통해 옆면의 최대 합을 구하는 문제입니다. 문제 접근을 다음과 같이 진행했습니다.

1. 주사위를 각각 쌓는다.

2. 0번째 idx는 5번째 idx와 마주보고, 1번째 idx는 3번째 idx와 마주보고, 2번째 idx는 4번째 idx와 마주본다.

3. 주사위 탐색을 진행한다. 이때 주사위 층은 depth변수를 통해 접근하며 마지막 depth만 예외처리를 따로 진행한다.

4. 주사위를 탐색하며 최대값을 계산한다. 이때 위에 면과 아래면을 계산하기 위해 start_idx, end_idx로 값을 계산하며 idx를 계산한다.

5. 구한 idx를 한 depth에 있는 주사위 값에서 빼며 위,아래 곂친 면을 제외하고 4개의 옆면에서 최대값을 구한다.

6. 4번과 5번을 지속적으로 반복하며 최대값을 합한 후, 최종 리스트에 추가한다.

7. 최종 리스트에서 최대 값을 도출한다.

위 방식으로 진행하며 문제를 접근했습니다. 이해가 안되시면 댓글 남겨주시면 감사하겠습니다.

Baekjoon [2212] 센서 - python

Shine_sunho — Mon, 4 Mar 2024 16:38:24 +0900

문제

2212번: 센서

첫째 줄에 센서의 개수 N(1 ≤ N ≤ 10,000), 둘째 줄에 집중국의 개수 K(1 ≤ K ≤ 1000)가 주어진다. 셋째 줄에는 N개의 센서의 좌표가 한 개의 정수로 N개 주어진다. 각 좌표 사이에는 빈 칸이 하나 있

www.acmicpc.net

접근 방식

각 점들끼리의 거리를 구한다음, 이를 정렬하여 최장 길이를 제거한다. 이때 제거하는 개수는 집중국의 개수-1 로 제거하면 총 집중국의 개수 만큼 길이가 생성된다.

문제 풀이

# 고속도로 위에 최대 K개의 집중국을 세울 수 있음.
# N개의 센서가 적어도 하나의 집중국과는 통신이 가능해야 하며, 집중국의 유지비 문제로 인해 각 집중국의 수신 가능 영역의 길이의 합을 최소화해야 함.
# 각 집중국의 수신 가능영역의 거리의 합의 최솟값을 구하는 프로그램을 작성하시오. 단, 집중국의 수신 가능영역의 길이는 0 이상이며 모든 센서의 좌표가 다를 필요는 없다.

n = int(input()) # 센서의 개수
k = int(input()) # 집중국의 개수
sensor_n = list(map(int,input().split())) # N개의 센서의 좌표
sensor_n.sort()

number_list = []
for i in range(len(sensor_n)-1):
    number_list.append(sensor_n[i+1] - sensor_n[i])

number_list.sort()
if k == 1:
    print(sum(number_list))
else:
    print(sum(number_list[:-(k-1)]))

Baekjoon [12904] A와 B - python

Shine_sunho — Mon, 4 Mar 2024 15:06:38 +0900

문제

https://www.acmicpc.net/problem/12904

12904번: A와 B

수빈이는 A와 B로만 이루어진 영어 단어가 존재한다는 사실에 놀랐다. 대표적인 예로 AB (Abdominal의 약자), BAA (양의 울음 소리), AA (용암의 종류), ABBA (스웨덴 팝 그룹)이 있다. 이런 사실에 놀란 수

www.acmicpc.net

시간 초과난 코드

# 규칙
# 1.문자열의 뒤에 A를 추가한다.
# 2.문자열을 뒤집고 뒤에 B를 추가한다.
import sys

sys.setrecursionlimit(10 ** 6)
s = input()
target = input()
cnt = len(target) - len(s)

def make_word(word):
    # print(word)
    if len(word) <= len(target):
        if word == target:
            return 1
        else:
            word_a = word + "A"
            result_a = make_word(word_a)
            reverse_word = word[::-1]
            reverse_word = reverse_word + "B"
            result_b = make_word(reverse_word)
            return result_a or result_b
    else:
        return 0
s = make_word(s)
print(s)

정답 코드

# 규칙
# 1.문자열의 뒤에 A를 추가한다.
# 2.문자열을 뒤집고 뒤에 B를 추가한다.
import sys

sys.setrecursionlimit(10 ** 6)
s = input()
target = input()
cnt = len(target) - len(s)


while(len(target)!= len(s)):
    if target[-1] == "A":
        target = target[:-1]
    elif target[-1] == "B":
        target = target[:-1]
        target = target[::-1]
if target == s:
    print(1)
else:
    print(0)

문제 접근

처음엔 단순히 재귀를 통해서 접근하는 방식을 접근했다. 이때 문자열 길이에 따라 시간초과가 발생했다. 이를 해결하고자 target_string에서 처음 string이 될때까지 반대로 접근했다. 이를 통해 시간효율성을 높여 시간초과를 해결했다.

Support Vector Machine - bin - diabates dataset

Shine_sunho — Fri, 2 Feb 2024 15:37:44 +0900

서포트벡터머신 - 이진분류

피마인디언 당뇨병 데이터셋

In [3]:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

import warnings
warnings.filterwarnings('ignore')

1. 데이터 준비

In [4]:

from google.colab import drive
drive.mount('/content/drive')

Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).

In [5]:

df = pd.read_csv("/content/drive/MyDrive/SKT FLY AI/2주차/diabetes.csv")

In [6]:

df.head()

Out[6]:

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age	Outcome
0	6	148	72	35	0	33.6	0.627	50	1
1	1	85	66	29	0	26.6	0.351	31	0
2	8	183	64	0	0	23.3	0.672	32	1
3	1	89	66	23	94	28.1	0.167	21	0
4	0	137	40	35	168	43.1	2.288	33	1

In [7]:

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 768 entries, 0 to 767
Data columns (total 9 columns):
 #   Column                    Non-Null Count  Dtype  
---  ------                    --------------  -----  
 0   Pregnancies               768 non-null    int64  
 1   Glucose                   768 non-null    int64  
 2   BloodPressure             768 non-null    int64  
 3   SkinThickness             768 non-null    int64  
 4   Insulin                   768 non-null    int64  
 5   BMI                       768 non-null    float64
 6   DiabetesPedigreeFunction  768 non-null    float64
 7   Age                       768 non-null    int64  
 8   Outcome                   768 non-null    int64  
dtypes: float64(2), int64(7)
memory usage: 54.1 KB

In [8]:

df.describe().T

Out[8]:

	count	mean	std	min	25%	50%	75%	max
Pregnancies	768.0	3.845052	3.369578	0.000	1.00000	3.0000	6.00000	17.00
Glucose	768.0	120.894531	31.972618	0.000	99.00000	117.0000	140.25000	199.00
BloodPressure	768.0	69.105469	19.355807	0.000	62.00000	72.0000	80.00000	122.00
SkinThickness	768.0	20.536458	15.952218	0.000	0.00000	23.0000	32.00000	99.00
Insulin	768.0	79.799479	115.244002	0.000	0.00000	30.5000	127.25000	846.00
BMI	768.0	31.992578	7.884160	0.000	27.30000	32.0000	36.60000	67.10
DiabetesPedigreeFunction	768.0	0.471876	0.331329	0.078	0.24375	0.3725	0.62625	2.42
Age	768.0	33.240885	11.760232	21.000	24.00000	29.0000	41.00000	81.00
Outcome	768.0	0.348958	0.476951	0.000	0.00000	0.0000	1.00000	1.00

In [9]:

df.Outcome.value_counts()

Out[9]:

0    500
1    268
Name: Outcome, dtype: int64

2. 테스트데이터 분리¶

In [10]:

y = df.Outcome
y

Out[10]:

0      1
1      0
2      1
3      0
4      1
      ..
763    0
764    0
765    0
766    1
767    0
Name: Outcome, Length: 768, dtype: int64

In [11]:

X = df.drop('Outcome',axis=1)
X

Out[11]:

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age
0	6	148	72	35	0	33.6	0.627	50
1	1	85	66	29	0	26.6	0.351	31
2	8	183	64	0	0	23.3	0.672	32
3	1	89	66	23	94	28.1	0.167	21
4	0	137	40	35	168	43.1	2.288	33
...	...	...	...	...	...	...	...	...
763	10	101	76	48	180	32.9	0.171	63
764	2	122	70	27	0	36.8	0.340	27
765	5	121	72	23	112	26.2	0.245	30
766	1	126	60	0	0	30.1	0.349	47
767	1	93	70	31	0	30.4	0.315	23

768 rows × 8 columns

In [12]:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X,y,test_size = 0.2, random_state = 42,stratify=y)

In [13]:

print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

(614, 8) (154, 8) (614,) (154,)

In [14]:

y_train.value_counts()

Out[14]:

0    400
1    214
Name: Outcome, dtype: int64

In [15]:

y_test.value_counts()

Out[15]:

0    100
1     54
Name: Outcome, dtype: int64

3. 전처리

결측치 체크

In [16]:

X_train.isna().sum()

Out[16]:

Pregnancies                 0
Glucose                     0
BloodPressure               0
SkinThickness               0
Insulin                     0
BMI                         0
DiabetesPedigreeFunction    0
Age                         0
dtype: int64

이상치 체크

0인값을 가진 샘플을 지우기

In [17]:

df1 = X_train.copy()
df1.shape

Out[17]:

(614, 8)

In [18]:

df1.columns

Out[18]:

Index(['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',
       'BMI', 'DiabetesPedigreeFunction', 'Age'],
      dtype='object')

In [19]:

cols = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',
       'BMI']

In [20]:

df1 = df1[cols].replace(0,np.nan)   # 0을 결측치로 대체

df1.isna().sum()

Out[20]:

Glucose            4
BloodPressure     23
SkinThickness    175
Insulin          290
BMI                9
dtype: int64

In [21]:

df1 = df1.dropna()
df1.shape

# 결과값을 봤을 때 데이터의 유실이 너무 많음 -> 다른 방안으로 대체

Out[21]:

(322, 5)

0인 값을 적당한 값으로 채워넣는 방법 -> median 값으로 대체

In [22]:

df2 = X_train.copy()
df2.shape

Out[22]:

(614, 8)

In [23]:

df2[cols] = df2[cols].replace(0,np.nan)   # 0을 결측치로 대체

df2.isna().sum()

Out[23]:

Pregnancies                   0
Glucose                       4
BloodPressure                23
SkinThickness               175
Insulin                     290
BMI                           9
DiabetesPedigreeFunction      0
Age                           0
dtype: int64

In [24]:

df2['Glucose'] = df2['Glucose'].fillna(df2['Glucose'].median())
df2['BloodPressure'] = df2['BloodPressure'].fillna(df2['BloodPressure'].median())
df2['SkinThickness'] = df2['SkinThickness'].fillna(df2['SkinThickness'].median())
df2['Insulin'] = df2['Insulin'].fillna(df2['Insulin'].median())
df2['BMI'] = df2['BMI'].fillna(df2['BMI'].median())

In [25]:

G_m = df['Glucose'].median()
B_m = df['BloodPressure'].median()
S_m = df['SkinThickness'].median()
I_m = df['Insulin'].median()
Bm_m = df['BMI'].median()

In [26]:

df2.describe()

Out[26]:

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age
count	614.000000	614.000000	614.000000	614.000000	614.000000	614.000000	614.000000	614.000000
mean	3.819218	121.671010	72.140065	29.042345	137.705212	32.448208	0.477428	33.366450
std	3.314148	30.003794	12.275119	8.891855	78.764767	6.824122	0.330300	11.833438
min	0.000000	56.000000	24.000000	7.000000	15.000000	18.200000	0.084000	21.000000
25%	1.000000	99.000000	64.000000	25.000000	120.000000	27.625000	0.245000	24.000000
50%	3.000000	117.000000	72.000000	29.000000	125.000000	32.400000	0.382500	29.000000
75%	6.000000	140.000000	80.000000	32.000000	130.000000	36.500000	0.639250	41.000000
max	17.000000	199.000000	122.000000	99.000000	744.000000	67.100000	2.329000	81.000000

In [27]:

df2[cols] = df2[cols].fillna(df[cols])

In [28]:

df2.describe()

Out[28]:

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age
count	614.000000	614.000000	614.000000	614.000000	614.000000	614.000000	614.000000	614.000000
mean	3.819218	121.671010	72.140065	29.042345	137.705212	32.448208	0.477428	33.366450
std	3.314148	30.003794	12.275119	8.891855	78.764767	6.824122	0.330300	11.833438
min	0.000000	56.000000	24.000000	7.000000	15.000000	18.200000	0.084000	21.000000
25%	1.000000	99.000000	64.000000	25.000000	120.000000	27.625000	0.245000	24.000000
50%	3.000000	117.000000	72.000000	29.000000	125.000000	32.400000	0.382500	29.000000
75%	6.000000	140.000000	80.000000	32.000000	130.000000	36.500000	0.639250	41.000000
max	17.000000	199.000000	122.000000	99.000000	744.000000	67.100000	2.329000	81.000000

In [29]:

X_train = df2.copy()

스케일링

In [30]:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)

X_train_s

Out[30]:

array([[-0.85135507, -1.05642747, -0.82674004, ..., -0.76969431,
         0.31079384, -0.79216928],
       [ 0.35657564,  0.14439907,  0.47777235, ..., -0.41771394,
        -0.11643851,  0.56103382],
       [-0.5493724 , -0.55608308, -1.15286813, ...,  0.35957603,
        -0.76486207, -0.70759409],
       ...,
       [-0.85135507, -0.82293342, -0.17448384, ...,  0.82888319,
        -0.78607218, -0.28471812],
       [ 1.86648903, -0.35594533, -0.17448384, ..., -0.72569676,
        -1.01938346,  0.56103382],
       [ 0.05459296,  0.74481233, -1.15286813, ..., -0.43237979,
        -0.57700104,  0.30730824]])

In [31]:

scaler.mean_

Out[31]:

array([  3.81921824, 121.67100977,  72.14006515,  29.04234528,
       137.70521173,  32.44820847,   0.47742834,  33.36644951])

In [32]:

y_train = y_train.values
type(y_train)

Out[32]:

numpy.ndarray

4. 학습

SVC 베이스 모델

In [33]:

from sklearn.svm import SVC

clf = SVC(random_state = 42)
clf = clf.fit(X_train_s,y_train)

5. 예측

테스트 데이터 전처리 먼저

0인 값을 위에서 계산한 값으로 넣는 작업
스케일링

In [34]:

X_test.head(5)

Out[34]:

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age
44	7	159	64	0	0	27.4	0.294	40
672	10	68	106	23	49	35.5	0.285	47
700	2	122	76	27	200	35.9	0.483	26
630	7	114	64	0	0	27.4	0.732	34
81	2	74	0	0	0	0.0	0.102	22

In [35]:

X_test = X_test.replace(0,np.nan)
X_test

Out[35]:

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age
44	7.0	159.0	64.0	NaN	NaN	27.4	0.294	40
672	10.0	68.0	106.0	23.0	49.0	35.5	0.285	47
700	2.0	122.0	76.0	27.0	200.0	35.9	0.483	26
630	7.0	114.0	64.0	NaN	NaN	27.4	0.732	34
81	2.0	74.0	NaN	NaN	NaN	NaN	0.102	22
...	...	...	...	...	...	...	...	...
32	3.0	88.0	58.0	11.0	54.0	24.8	0.267	22
637	2.0	94.0	76.0	18.0	66.0	31.6	0.649	23
593	2.0	82.0	52.0	22.0	115.0	28.5	1.699	25
425	4.0	184.0	78.0	39.0	277.0	37.0	0.264	31
273	1.0	71.0	78.0	50.0	45.0	33.2	0.422	21

154 rows × 8 columns

In [36]:

X_test['Glucose'] = X_test['Glucose'].fillna(G_m)
X_test['BloodPressure'] = X_test['BloodPressure'].fillna(B_m)
X_test['SkinThickness'] = X_test['SkinThickness'].fillna(S_m)
X_test['Insulin'] = X_test['Insulin'].fillna(I_m)
X_test['BMI'] = X_test['BMI'].fillna(Bm_m )

In [37]:

X_test['Pregnancies'] = X_test['Pregnancies'].fillna(X_test['Pregnancies'].median())

In [38]:

X_test

Out[38]:

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age
44	7.0	159.0	64.0	23.0	30.5	27.4	0.294	40
672	10.0	68.0	106.0	23.0	49.0	35.5	0.285	47
700	2.0	122.0	76.0	27.0	200.0	35.9	0.483	26
630	7.0	114.0	64.0	23.0	30.5	27.4	0.732	34
81	2.0	74.0	72.0	23.0	30.5	32.0	0.102	22
...	...	...	...	...	...	...	...	...
32	3.0	88.0	58.0	11.0	54.0	24.8	0.267	22
637	2.0	94.0	76.0	18.0	66.0	31.6	0.649	23
593	2.0	82.0	52.0	22.0	115.0	28.5	1.699	25
425	4.0	184.0	78.0	39.0	277.0	37.0	0.264	31
273	1.0	71.0	78.0	50.0	45.0	33.2	0.422	21

154 rows × 8 columns

In [39]:

X_test.isna().sum()

Out[39]:

Pregnancies                 0
Glucose                     0
BloodPressure               0
SkinThickness               0
Insulin                     0
BMI                         0
DiabetesPedigreeFunction    0
Age                         0
dtype: int64

In [40]:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_test_s = scaler.fit_transform(X_test)
X_test_s

Out[40]:

array([[ 0.76197764,  1.16484536, -0.8288433 , ..., -0.71876183,
        -0.46562514,  0.63400979],
       [ 1.72381827, -1.66920722,  2.88630463, ...,  0.4261539 ,
        -0.49253293,  1.24533587],
       [-0.84109008,  0.01253827,  0.23262754, ...,  0.48269295,
         0.09943846, -0.58864236],
       ...,
       [-0.84109008, -1.23319913, -1.89031414, ..., -0.56327945,
         3.73497988, -0.67597466],
       [-0.19986299,  1.94343123,  0.40953934, ...,  0.63817533,
        -0.55531777, -0.15198088],
       [-1.16170362, -1.57577692,  0.40953934, ...,  0.10105437,
        -0.08293657, -1.02530385]])

In [41]:

y_pred = clf.predict(X_test_s)

In [42]:

from sklearn.metrics import accuracy_score, recall_score, precision_score,f1_score

acc = accuracy_score(y_test,y_pred) # 정답값, 예측

print(f'optimal_accuracy: {acc}')

optimal_accuracy: 0.7402597402597403

모델 튜닝

C, gamma,kernel,degrees 하이퍼 파라미터 튜닝

In [43]:

from sklearn.model_selection import GridSearchCV

params = {
    "C" : [0.1 ,1 ],
    'gamma' : [0.01,0.1],
    'degree' : [2,3],
    'kernel' : ['linear','poly']
}

grid_cv = GridSearchCV(SVC(),params,cv=5,refit= True, verbose=3)
grid_cv.fit(X_train_s,y_train)

Fitting 5 folds for each of 16 candidates, totalling 80 fits
[CV 1/5] END C=0.1, degree=2, gamma=0.01, kernel=linear;, score=0.764 total time=   0.0s
[CV 2/5] END C=0.1, degree=2, gamma=0.01, kernel=linear;, score=0.756 total time=   0.0s
[CV 3/5] END C=0.1, degree=2, gamma=0.01, kernel=linear;, score=0.756 total time=   0.0s
[CV 4/5] END C=0.1, degree=2, gamma=0.01, kernel=linear;, score=0.780 total time=   0.0s
[CV 5/5] END C=0.1, degree=2, gamma=0.01, kernel=linear;, score=0.811 total time=   0.0s
[CV 1/5] END C=0.1, degree=2, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 2/5] END C=0.1, degree=2, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 3/5] END C=0.1, degree=2, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 4/5] END C=0.1, degree=2, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 5/5] END C=0.1, degree=2, gamma=0.01, kernel=poly;, score=0.656 total time=   0.0s
[CV 1/5] END C=0.1, degree=2, gamma=0.1, kernel=linear;, score=0.764 total time=   0.0s
[CV 2/5] END C=0.1, degree=2, gamma=0.1, kernel=linear;, score=0.756 total time=   0.0s
[CV 3/5] END C=0.1, degree=2, gamma=0.1, kernel=linear;, score=0.756 total time=   0.0s
[CV 4/5] END C=0.1, degree=2, gamma=0.1, kernel=linear;, score=0.780 total time=   0.0s
[CV 5/5] END C=0.1, degree=2, gamma=0.1, kernel=linear;, score=0.811 total time=   0.0s
[CV 1/5] END C=0.1, degree=2, gamma=0.1, kernel=poly;, score=0.634 total time=   0.0s
[CV 2/5] END C=0.1, degree=2, gamma=0.1, kernel=poly;, score=0.659 total time=   0.0s
[CV 3/5] END C=0.1, degree=2, gamma=0.1, kernel=poly;, score=0.650 total time=   0.0s
[CV 4/5] END C=0.1, degree=2, gamma=0.1, kernel=poly;, score=0.650 total time=   0.0s
[CV 5/5] END C=0.1, degree=2, gamma=0.1, kernel=poly;, score=0.656 total time=   0.0s
[CV 1/5] END C=0.1, degree=3, gamma=0.01, kernel=linear;, score=0.764 total time=   0.0s
[CV 2/5] END C=0.1, degree=3, gamma=0.01, kernel=linear;, score=0.756 total time=   0.0s
[CV 3/5] END C=0.1, degree=3, gamma=0.01, kernel=linear;, score=0.756 total time=   0.0s
[CV 4/5] END C=0.1, degree=3, gamma=0.01, kernel=linear;, score=0.780 total time=   0.0s
[CV 5/5] END C=0.1, degree=3, gamma=0.01, kernel=linear;, score=0.811 total time=   0.0s
[CV 1/5] END C=0.1, degree=3, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 2/5] END C=0.1, degree=3, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 3/5] END C=0.1, degree=3, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 4/5] END C=0.1, degree=3, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 5/5] END C=0.1, degree=3, gamma=0.01, kernel=poly;, score=0.656 total time=   0.0s
[CV 1/5] END C=0.1, degree=3, gamma=0.1, kernel=linear;, score=0.764 total time=   0.0s
[CV 2/5] END C=0.1, degree=3, gamma=0.1, kernel=linear;, score=0.756 total time=   0.0s
[CV 3/5] END C=0.1, degree=3, gamma=0.1, kernel=linear;, score=0.756 total time=   0.0s
[CV 4/5] END C=0.1, degree=3, gamma=0.1, kernel=linear;, score=0.780 total time=   0.0s
[CV 5/5] END C=0.1, degree=3, gamma=0.1, kernel=linear;, score=0.811 total time=   0.0s
[CV 1/5] END C=0.1, degree=3, gamma=0.1, kernel=poly;, score=0.659 total time=   0.0s
[CV 2/5] END C=0.1, degree=3, gamma=0.1, kernel=poly;, score=0.659 total time=   0.0s
[CV 3/5] END C=0.1, degree=3, gamma=0.1, kernel=poly;, score=0.699 total time=   0.0s
[CV 4/5] END C=0.1, degree=3, gamma=0.1, kernel=poly;, score=0.691 total time=   0.0s
[CV 5/5] END C=0.1, degree=3, gamma=0.1, kernel=poly;, score=0.730 total time=   0.0s
[CV 1/5] END C=1, degree=2, gamma=0.01, kernel=linear;, score=0.772 total time=   0.0s
[CV 2/5] END C=1, degree=2, gamma=0.01, kernel=linear;, score=0.748 total time=   0.0s
[CV 3/5] END C=1, degree=2, gamma=0.01, kernel=linear;, score=0.756 total time=   0.0s
[CV 4/5] END C=1, degree=2, gamma=0.01, kernel=linear;, score=0.772 total time=   0.0s
[CV 5/5] END C=1, degree=2, gamma=0.01, kernel=linear;, score=0.803 total time=   0.0s
[CV 1/5] END C=1, degree=2, gamma=0.01, kernel=poly;, score=0.642 total time=   0.0s
[CV 2/5] END C=1, degree=2, gamma=0.01, kernel=poly;, score=0.650 total time=   0.1s
[CV 3/5] END C=1, degree=2, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 4/5] END C=1, degree=2, gamma=0.01, kernel=poly;, score=0.650 total time=   0.1s
[CV 5/5] END C=1, degree=2, gamma=0.01, kernel=poly;, score=0.656 total time=   0.0s
[CV 1/5] END C=1, degree=2, gamma=0.1, kernel=linear;, score=0.772 total time=   0.0s
[CV 2/5] END C=1, degree=2, gamma=0.1, kernel=linear;, score=0.748 total time=   0.0s
[CV 3/5] END C=1, degree=2, gamma=0.1, kernel=linear;, score=0.756 total time=   0.0s
[CV 4/5] END C=1, degree=2, gamma=0.1, kernel=linear;, score=0.772 total time=   0.0s
[CV 5/5] END C=1, degree=2, gamma=0.1, kernel=linear;, score=0.803 total time=   0.0s
[CV 1/5] END C=1, degree=2, gamma=0.1, kernel=poly;, score=0.659 total time=   0.0s
[CV 2/5] END C=1, degree=2, gamma=0.1, kernel=poly;, score=0.715 total time=   0.0s
[CV 3/5] END C=1, degree=2, gamma=0.1, kernel=poly;, score=0.683 total time=   0.0s
[CV 4/5] END C=1, degree=2, gamma=0.1, kernel=poly;, score=0.715 total time=   0.0s
[CV 5/5] END C=1, degree=2, gamma=0.1, kernel=poly;, score=0.656 total time=   0.0s
[CV 1/5] END C=1, degree=3, gamma=0.01, kernel=linear;, score=0.772 total time=   0.1s
[CV 2/5] END C=1, degree=3, gamma=0.01, kernel=linear;, score=0.748 total time=   0.0s
[CV 3/5] END C=1, degree=3, gamma=0.01, kernel=linear;, score=0.756 total time=   0.0s
[CV 4/5] END C=1, degree=3, gamma=0.01, kernel=linear;, score=0.772 total time=   0.0s
[CV 5/5] END C=1, degree=3, gamma=0.01, kernel=linear;, score=0.803 total time=   0.0s
[CV 1/5] END C=1, degree=3, gamma=0.01, kernel=poly;, score=0.642 total time=   0.0s
[CV 2/5] END C=1, degree=3, gamma=0.01, kernel=poly;, score=0.650 total time=   0.1s
[CV 3/5] END C=1, degree=3, gamma=0.01, kernel=poly;, score=0.650 total time=   0.0s
[CV 4/5] END C=1, degree=3, gamma=0.01, kernel=poly;, score=0.650 total time=   0.1s
[CV 5/5] END C=1, degree=3, gamma=0.01, kernel=poly;, score=0.656 total time=   0.1s
[CV 1/5] END C=1, degree=3, gamma=0.1, kernel=linear;, score=0.772 total time=   0.0s
[CV 2/5] END C=1, degree=3, gamma=0.1, kernel=linear;, score=0.748 total time=   0.0s
[CV 3/5] END C=1, degree=3, gamma=0.1, kernel=linear;, score=0.756 total time=   0.0s
[CV 4/5] END C=1, degree=3, gamma=0.1, kernel=linear;, score=0.772 total time=   0.0s
[CV 5/5] END C=1, degree=3, gamma=0.1, kernel=linear;, score=0.803 total time=   0.0s
[CV 1/5] END C=1, degree=3, gamma=0.1, kernel=poly;, score=0.707 total time=   0.0s
[CV 2/5] END C=1, degree=3, gamma=0.1, kernel=poly;, score=0.707 total time=   0.0s
[CV 3/5] END C=1, degree=3, gamma=0.1, kernel=poly;, score=0.691 total time=   0.0s
[CV 4/5] END C=1, degree=3, gamma=0.1, kernel=poly;, score=0.724 total time=   0.0s
[CV 5/5] END C=1, degree=3, gamma=0.1, kernel=poly;, score=0.779 total time=   0.0s

Out[43]:

GridSearchCV(cv=5, estimator=SVC(),
             param_grid={'C': [0.1, 1], 'degree': [2, 3], 'gamma': [0.01, 0.1],
                         'kernel': ['linear', 'poly']},
             verbose=3)

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

GridSearchCV

GridSearchCV(cv=5, estimator=SVC(),
             param_grid={'C': [0.1, 1], 'degree': [2, 3], 'gamma': [0.01, 0.1],
                         'kernel': ['linear', 'poly']},
             verbose=3)

estimator: SVC

SVC()

SVC

SVC()

In [45]:

grid_cv.best_estimator_

Out[45]:

SVC(C=0.1, degree=2, gamma=0.01, kernel='linear')

In [46]:

grid_cv.best_score_   # 최고의 모델 정확도

Out[46]:

0.7736771957883513

In [47]:

grid_cv.best_params_

Out[47]:

{'C': 0.1, 'degree': 2, 'gamma': 0.01, 'kernel': 'linear'}

베스트 모델 학습

In [50]:

clf = SVC(C= 0.1, degree=2, gamma = 0.01, kernel = 'linear')
clf = clf.fit(X_train_s,y_train)

모델 저장

In [52]:

import pickle


with open('svc_c_1_degree_2_gamma_001_rbf.pickle','wb') as f:
  pickle.dump(clf,f)

In [54]:

# 스케일러

with open('stanard_scaler.pickle','wb') as f:
  pickle.dump(scaler,f)

저장된 모델 사용하기

In [ ]:

with open('/content/svc_c_1_degree_2_gamma_001_rbf.pickle','rb') as f:
  c = pickle.read(f)

Baekjoon [14888] 연산자 끼워넣기 - python

Shine_sunho — Thu, 1 Feb 2024 11:17:16 +0900

14888번: 연산자 끼워넣기

첫째 줄에 수의 개수 N(2 ≤ N ≤ 11)가 주어진다. 둘째 줄에는 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 100) 셋째 줄에는 합이 N-1인 4개의 정수가 주어지는데, 차례대로 덧셈(+)의 개수, 뺄셈(-)의 개수, 곱

www.acmicpc.net

문제 풀이

n = int(input())
number_list = list(map(int,input().split()))
operator_list = list(map(int,input().split())) #덧셈(+)의 개수, 뺄셈(-)의 개수, 곱셈(×)의 개수, 나눗셈(÷)의 개수이다.
min_num = 1e9
max_num = -1e9
def operator(depth, total,plus,minus,multi,div):
    global min_num
    global max_num
    # print(depth, max_num,min_num)
    if depth == n: # 백트래킹 끝나는 조건
        max_num = max(total, max_num)
        min_num = min(total, min_num)
        return
    if plus:
        operator(depth + 1,total + number_list[depth],plus-1,minus,multi,div)  # plus연산 수를 하나 뺴며, depth를 기반으로 숫자 idx탐색
    if minus:
        operator(depth + 1, total - number_list[depth], plus, minus - 1, multi, div) # minus연산 수를 하나 뺴며, depth를 기반으로 숫자 idx탐색
    if multi:
        operator(depth + 1, total * number_list[depth], plus, minus, multi - 1, div) # multi연산 수를 하나 뺴며, depth를 기반으로 숫자 idx탐색
    if div:
        operator(depth + 1, int(total / number_list[depth]), plus, minus, multi, div - 1) # div 연산 수를 하나 뺴며, depth를 기반으로 숫자 idx탐색


operator(1,number_list[0],operator_list[0],operator_list[1],operator_list[2],operator_list[3])
print(int(max_num))
print(int(min_num))
# print((-3//5))

문제 접근

min, max 변수를 통해 최대, 최소 값을 전달하며 depth를 통해 깊이 탐색을 진행합니다. DFS와 달리 주어진 조건에 맞춰 탐색을 하는것이아니라 전체적으로 다 탐색을 하면서 depth값이 n값이 되면 return을 하는 식으로 진행했습니다.

이때 if 문에서 elif문을 쓰지 않은 이유는 연산의 순서에 따라 최대, 최소 값이 바뀔 수 있기 때문에

a @ b 연산에서 @에 넣을 수 있는 모든 연산자를 다 넣어보며 계산합니다.

KNN으로 citrus data set 분류하기

Shine_sunho — Tue, 30 Jan 2024 14:20:07 +0900

02-knn-bin-citrus.ipynb

0.22MB

KNN (이진분류)

citrus data set

In [1]:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

1. 데이터 준비¶

In [2]:

from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive

In [97]:

df = pd.read_csv("/content/drive/MyDrive/SKT FLY AI/2주차/citrus.csv")

In [77]:

df.head()

Out[77]:

	name	diameter	weight	red	green	blue
0	orange	2.96	86.76	172	85	2
1	orange	3.91	88.05	166	78	3
2	orange	4.42	95.17	156	81	2
3	orange	4.47	95.60	163	81	4
4	orange	4.48	95.76	161	72	9

In [68]:

# 데이터의 shape
df.shape

Out[68]:

(10000, 6)

In [69]:

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10000 entries, 0 to 9999
Data columns (total 6 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   name      10000 non-null  object 
 1   diameter  10000 non-null  float64
 2   weight    10000 non-null  float64
 3   red       10000 non-null  int64  
 4   green     10000 non-null  int64  
 5   blue      10000 non-null  int64  
dtypes: float64(2), int64(3), object(1)
memory usage: 468.9+ KB

In [70]:

df.name.unique()

Out[70]:

array(['orange', 'grapefruit'], dtype=object)

In [71]:

df.describe()

Out[71]:

	diameter	weight	red	green	blue
count	10000.000000	10000.000000	10000.000000	10000.000000	10000.000000
mean	9.975685	175.050792	153.847800	76.010600	11.363200
std	1.947844	29.212119	10.432954	11.708433	9.061275
min	2.960000	86.760000	115.000000	31.000000	2.000000
25%	8.460000	152.220000	147.000000	68.000000	2.000000
50%	9.980000	174.985000	154.000000	76.000000	10.000000
75%	11.480000	197.722500	161.000000	84.000000	17.000000
max	16.450000	261.510000	192.000000	116.000000	56.000000

In [72]:

# 결측치(Missing value)

df.isna().sum(axis=0)

Out[72]:

name        0
diameter    0
weight      0
red         0
green       0
blue        0
dtype: int64

In [73]:

df.name.value_counts()

Out[73]:

orange        5000
grapefruit    5000
Name: name, dtype: int64

In [98]:

df = df.sample(frac =1)
df.head(10)

Out[98]:

	name	diameter	weight	red	green	blue
6188	grapefruit	10.62	183.46	156	58	13
1608	orange	7.90	144.19	159	80	2
7879	grapefruit	11.69	201.17	147	57	19
6552	grapefruit	10.86	187.98	149	53	18
6556	grapefruit	10.87	188.01	139	50	4
6039	grapefruit	10.48	181.57	146	67	21
5445	grapefruit	9.82	171.60	153	69	2
568	orange	6.95	130.84	151	92	13
2100	orange	8.23	148.97	158	90	29
547	orange	6.93	130.45	170	76	9

In [99]:

df.reset_index(drop=True, inplace=True)
df

Out[99]:

	name	diameter	weight	red	green	blue
0	grapefruit	10.62	183.46	156	58	13
1	orange	7.90	144.19	159	80	2
2	grapefruit	11.69	201.17	147	57	19
3	grapefruit	10.86	187.98	149	53	18
4	grapefruit	10.87	188.01	139	50	4
...	...	...	...	...	...	...
9995	grapefruit	13.06	221.37	157	61	7
9996	grapefruit	11.22	193.83	159	73	25
9997	grapefruit	12.56	214.02	168	54	19
9998	orange	9.48	168.20	149	76	19
9999	orange	8.57	153.77	151	104	2

10000 rows × 6 columns

In [120]:

# 테스트 데이터 분리

X = df.loc[:7999]
y = df.loc[8000:]

In [117]:

Out[117]:

	name	diameter	weight	red	green	blue
0	grapefruit	10.62	183.46	156	58	13
1	orange	7.90	144.19	159	80	2
2	grapefruit	11.69	201.17	147	57	19
3	grapefruit	10.86	187.98	149	53	18
4	grapefruit	10.87	188.01	139	50	4
...	...	...	...	...	...	...
7995	grapefruit	10.50	181.80	143	89	13
7996	orange	7.79	142.14	176	74	6
7997	orange	8.20	148.54	173	82	2
7998	orange	8.19	148.41	162	80	2
7999	grapefruit	11.81	202.95	155	72	4

8000 rows × 6 columns

In [121]:

Out[121]:

	name	diameter	weight	red	green	blue
8000	orange	7.87	143.73	145	87	16
8001	orange	8.37	150.84	155	83	6
8002	grapefruit	10.92	188.98	171	69	30
8003	orange	7.49	137.99	168	69	2
8004	grapefruit	11.30	195.19	148	80	32
...	...	...	...	...	...	...
9995	grapefruit	13.06	221.37	157	61	7
9996	grapefruit	11.22	193.83	159	73	25
9997	grapefruit	12.56	214.02	168	54	19
9998	orange	9.48	168.20	149	76	19
9999	orange	8.57	153.77	151	104	2

2000 rows × 6 columns

전처리¶

스케일링

In [147]:

X.columns

Out[147]:

Index(['name', 'diameter', 'weight', 'red', 'green', 'blue'], dtype='object')

In [148]:

X_target = X.name
X_train = X[['diameter', 'weight', 'red', 'green', 'blue']]

In [149]:

X_target

Out[149]:

0       grapefruit
1           orange
2       grapefruit
3       grapefruit
4       grapefruit
           ...    
7995    grapefruit
7996        orange
7997        orange
7998        orange
7999    grapefruit
Name: name, Length: 8000, dtype: object

In [150]:

X_train

Out[150]:

	diameter	weight	red	green	blue
0	10.62	183.46	156	58	13
1	7.90	144.19	159	80	2
2	11.69	201.17	147	57	19
3	10.86	187.98	149	53	18
4	10.87	188.01	139	50	4
...	...	...	...	...	...
7995	10.50	181.80	143	89	13
7996	7.79	142.14	176	74	6
7997	8.20	148.54	173	82	2
7998	8.19	148.41	162	80	2
7999	11.81	202.95	155	72	4

8000 rows × 5 columns

평균 및 분산을 통해 Z정규화¶

In [151]:

u_dia = X_train.diameter.mean()
std_dia = X_train.diameter.std()
X_train.diameter = (X_train.diameter - u_dia )/std_dia

<ipython-input-151-20b9ae9e183a>:3: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  X_train.diameter = (X_train.diameter - u_dia )/std_dia

In [152]:

u_wei = X_train.weight.mean()
std_wei = X_train.weight.std()
X_train.weight = (X_train.weight - u_wei )/std_wei

<ipython-input-152-7de1ec988aee>:3: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  X_train.weight = (X_train.weight - u_wei )/std_wei

In [153]:

u_r = X_train.red.mean()
std_r = X_train.red.std()
X_train.red = (X_train.red - u_r )/std_r

<ipython-input-153-af9162887f7b>:3: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  X_train.red = (X_train.red - u_r )/std_r

In [154]:

u_g = X_train.green.mean()
std_g = X_train.green.std()
X_train.green = (X_train.green - u_g )/std_g

<ipython-input-154-ddc5e8fc4fb8>:3: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  X_train.green = (X_train.green - u_g )/std_g

In [155]:

u_b = X_train.blue.mean()
std_b = X_train.blue.std()
X_train.blue = (X_train.blue - u_b )/std_b

<ipython-input-155-db2495ad9551>:3: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  X_train.blue = (X_train.blue - u_b )/std_b

In [156]:

X_train

Out[156]:

	diameter	weight	red	green	blue
0	0.333416	0.290576	0.205745	-1.544606	0.177122
1	-1.064225	-1.054454	0.491651	0.338238	-1.034816
2	0.883224	0.897159	-0.651973	-1.630190	0.838179
3	0.456738	0.445390	-0.461369	-1.972525	0.728003
4	0.461876	0.446418	-1.414389	-2.229277	-0.814464
...	...	...	...	...	...
7995	0.271756	0.233720	-1.033181	1.108492	0.177122
7996	-1.120747	-1.124668	2.111786	-0.175265	-0.594112
7997	-0.910073	-0.905462	1.825879	0.509406	-1.034816
7998	-0.915211	-0.909915	0.777557	0.338238	-1.034816
7999	0.944884	0.958125	0.110443	-0.346433	-0.814464

8000 rows × 5 columns

In [159]:

X_target = X_target.map({'grapefruit': 0, 'orange':1})
X_target

Out[159]:

0       0
1       1
2       0
3       0
4       0
       ..
7995    0
7996    1
7997    1
7998    1
7999    0
Name: name, Length: 8000, dtype: int64

학습¶

K-nn 알고리즘

In [160]:

type(X_train),type(X_target)

Out[160]:

(pandas.core.frame.DataFrame, pandas.core.series.Series)

In [162]:

# Numpy array 형식으로 변환
X_train = X_train.values
X_target = X_target.values

In [164]:

# 베이스 모델 학습
from sklearn.neighbors import KNeighborsClassifier

clf = KNeighborsClassifier()
clf = clf.fit(X_train,X_target)

In [166]:

y_target = y.name
y_train = y[['diameter','weight','red','green','blue']]
y_train

Out[166]:

	diameter	weight	red	green	blue
8000	7.87	143.73	145	87	16
8001	8.37	150.84	155	83	6
8002	10.92	188.98	171	69	30
8003	7.49	137.99	168	69	2
8004	11.30	195.19	148	80	32
...	...	...	...	...	...
9995	13.06	221.37	157	61	7
9996	11.22	193.83	159	73	25
9997	12.56	214.02	168	54	19
9998	9.48	168.20	149	76	19
9999	8.57	153.77	151	104	2

2000 rows × 5 columns

In [167]:

y_target = y_target.map({'grapefruit': 0, 'orange':1})

In [168]:

y_train.diameter = (y_train.diameter - u_dia )/std_dia

In [169]:

y_train.weight = (y_train.weight - u_wei )/std_wei

In [170]:

y_train.red = (y_train.red - u_r )/std_r

In [171]:

y_train.green = (y_train.green - u_g )/std_g

In [172]:

y_train.blue = (y_train.blue - u_b )/std_b

In [175]:

y_train = y_train.values

In [176]:

y_target = y_target.values

In [177]:

# 예측 진행

y_pred = clf.predict(y_train)

In [180]:

y_pred[:20]

Out[180]:

array([1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0])

In [181]:

y_target[:20]

Out[181]:

array([1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0])

평가¶

In [182]:

# 정확도 평가

np.sum(y_pred == y_target) / len(y_pred)

Out[182]:

0.9205

In [185]:

from sklearn.metrics import confusion_matrix

cf = confusion_matrix(y_target, y_pred)
cf

Out[185]:

array([[929,  73],
       [ 86, 912]])

In [186]:

s = sns.heatmap(cf, annot = True,cmap='Blues')

In [192]:

from sklearn.metrics import accuracy_score, recall_score, precision_score,f1_score


acc = accuracy_score(y_target,y_pred) # 정답값, 예측값
recall = recall_score(y_target,y_pred) # 정답값, 예측값
precision = precision_score(y_target,y_pred) # 정답값, 예측값
f1 = f1_score(y_target,y_pred) # 정답값, 예측값

print(f'accuracy : {acc}')
print(f'recall : {round(recall,3)}')
print(f'precision : {round(precision,3)}')
print(f'f1 : {round(f1,3)}')

accuracy : 0.9205
recall : 0.914
precision : 0.926
f1 : 0.92

모델 튜닝¶

In [195]:

score = []

for k in range(3,100):
  clf = KNeighborsClassifier(n_neighbors = k)
  clf.fit(X_train,X_target)
  y_pred = clf.predict(y_train)
  acc = accuracy_score(y_target,y_pred) # 정답값, 예측값
  score.append(acc)
print(f'max_accuracy: {max(score)}')

max_accuracy: 0.9355

In [198]:

plt.plot(range(3,100),score)
plt.show()

In [199]:

# k가 특정 N(40)일 때가 베스트라 가정, 재학습을 진행

best_clf = KNeighborsClassifier(n_neighbors = 60)
best_clf.fit(X_train,X_target)
y_pred = best_clf.predict(y_train)
acc = accuracy_score(y_target,y_pred) # 정답값, 예측

print(f'optimal_accuracy: {acc}')

optimal_accuracy: 0.935

Baekjoon [5014] 스타트링크 - python

Shine_sunho — Thu, 25 Jan 2024 18:16:33 +0900

https://www.acmicpc.net/problem/5014

5014번: 스타트링크

첫째 줄에 F, S, G, U, D가 주어진다. (1 ≤ S, G ≤ F ≤ 1000000, 0 ≤ U, D ≤ 1000000) 건물은 1층부터 시작하고, 가장 높은 층은 F층이다.

www.acmicpc.net

문제 풀이

from collections import deque
# F, S, G, U, D가 주어진다.
F, S, G, U, D = map(int,input().split())
# F : 스타트링크 건물 층수
# S : 있는 위치
# G : 스타트링크 있는 위치
# U : 위로 갈수 있는 층
# D : 아래로 갈수 있는 층

dp = [99999999 for _ in range(F+1)]
visited = [0 for _ in range(F+1)]
def DFS(s):
    visited[s] = 1
    dp[s] = 1
    que = deque()
    que.append(s)
    while que:
        s = que.popleft()
        up_s = s + U
        down_s = s - D
        # print(up_s,down_s)
        if up_s <= F:
            if visited[up_s] == 0:
                dp[up_s] = min(dp[up_s],dp[s] +1)
                visited[up_s] = 1
                que.append(up_s)
        if down_s > 0:
            if visited[down_s] == 0:
                dp[down_s] = min(dp[down_s],dp[s] + 1)
                visited[down_s] = 1
                que.append(down_s)
    return
DFS(S)

if dp[G] == 99999999:
    print("use the stairs")
else:
    print(dp[G]-1)

문제 접근

1차원 배열로 자기 위치에서 U계단 만큼 상승, D계단 만큼 하강을 바탕으로 탐색을 진행했습니다. 시간초과가 걸리는 분들은 혹시 조건문안에 visited 방문을 체크하는지 확인해보는게 좋은 거 같습니다.

Baekjoon [12919] A와 B 2 - python

Shine_sunho — Mon, 22 Jan 2024 15:04:00 +0900

https://www.acmicpc.net/problem/12919

12919번: A와 B 2

수빈이는 A와 B로만 이루어진 영어 단어 존재한다는 사실에 놀랐다. 대표적인 예로 AB (Abdominal의 약자), BAA (양의 울음 소리), AA (용암의 종류), ABBA (스웨덴 팝 그룹)이 있다. 이런 사실에 놀란 수빈

www.acmicpc.net

처음 문제를 봤을때 S에서 T로 만드는 것은 힘들 것이라 생각하여 T를 S로 만들자 생각했다.

틀린코드

original_text = list(input())
target_text = list(input())
gap = len(target_text) - len(original_text)
for i in range(gap):
    if target_text[0] == "A":
        target_text = target_text[1:]
        # print(target_text)
    elif target_text[0] == "B":
        target_text = target_text[1:]
        target_text = target_text[::-1]
        # print(target_text)


if original_text == target_text:
    print(1)
else:
    print(0)

사실 위와같이 접근을 시작했는데, 주어진 테스트케이스는 통과하지만 에러가 나는 경우가 발생했다. 그 이유는 BAA와 같이

AA문자열에서 B를 만나 BAA가 됐을수도있고, BA문자열에서 A를 만나 BAA가 되는 경우도 발생했다. 이를 통해 백트래킹과 같이 함수를 통해 알고리즘을 구현하기로 진행했다.

맞는코드

import sys
original_text = list(input())
target_text = list(input())

def check(t): # 문자열 T 리스트를 입력받아
    if t==original_text:
        print(1)
        sys.exit()
    if len(t)==0:
        return 0
    if t[-1]=='A': # 마지막이 A이면
        check(t[:-1]) # 제거해서 재귀
    if t[0]=='B': # 처음이 B이면
        check(t[1:][::-1]) # B제거하고, 뒤집어서 재귀
check(target_text)
print(0)

위와 같이 접근하면서 다중적으로 조건을 걸어 한번에 처리하도록 진행했다.

MySQL 코테준비 - 대여 기록이 존재하는 자동차 리스트 구하기

Shine_sunho — Sat, 20 Jan 2024 10:41:58 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/157341

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제 풀이

-- 코드를 입력하세요
SELECT DISTINCT CAR_RENTAL_COMPANY_CAR.CAR_ID
FROM CAR_RENTAL_COMPANY_CAR LEFT JOIN
CAR_RENTAL_COMPANY_RENTAL_HISTORY ON CAR_RENTAL_COMPANY_CAR.CAR_ID = CAR_RENTAL_COMPANY_RENTAL_HISTORY.CAR_ID
WHERE MONTH(START_DATE) = 10 AND car_type = '세단'
ORDER BY CAR_RENTAL_COMPANY_CAR.CAR_ID DESC

문제 접근

GROUP으로 묶는 것이 아닌 단순 중복 제거 문제이기 때문에, JOIN함수를 통해 2개의 테이블을 결합한 후, WHERE절로 문제의 조건에 맞춰 테이블 쿼리를 진행했습니다.

Baekjoon [1743] 음식물 피하기 - python

Shine_sunho — Fri, 19 Jan 2024 11:02:01 +0900

1743번: 음식물 피하기

첫째 줄에 통로의 세로 길이 N(1 ≤ N ≤ 100)과 가로 길이 M(1 ≤ M ≤ 100) 그리고 음식물 쓰레기의 개수 K(1 ≤ K ≤ N×M)이 주어진다. 그리고 다음 K개의 줄에 음식물이 떨어진 좌표 (r, c)가 주어진다

www.acmicpc.net

문제

코레스코 콘도미니엄 8층은 학생들이 3끼의 식사를 해결하는 공간이다. 그러나 몇몇 비양심적인 학생들의 만행으로 음식물이 통로 중간 중간에 떨어져 있다. 이러한 음식물들은 근처에 있는 것끼리 뭉치게 돼서 큰 음식물 쓰레기가 된다.

이 문제를 출제한 선생님은 개인적으로 이러한 음식물을 실내화에 묻히는 것을 정말 진정으로 싫어한다. 참고로 우리가 구해야 할 답은 이 문제를 낸 조교를 맞추는 것이 아니다.

통로에 떨어진 음식물을 피해가기란 쉬운 일이 아니다. 따라서 선생님은 떨어진 음식물 중에 제일 큰 음식물만은 피해 가려고 한다.

선생님을 도와 제일 큰 음식물의 크기를 구해서 “10ra"를 외치지 않게 도와주자.

입력

첫째 줄에 통로의 세로 길이 N(1 ≤ N ≤ 100)과 가로 길이 M(1 ≤ M ≤ 100) 그리고 음식물 쓰레기의 개수 K(1 ≤ K ≤ N×M)이 주어진다. 그리고 다음 K개의 줄에 음식물이 떨어진 좌표 (r, c)가 주어진다.

좌표 (r, c)의 r은 위에서부터, c는 왼쪽에서부터가 기준이다. 입력으로 주어지는 좌표는 중복되지 않는다.

출력

첫째 줄에 음식물 중 가장 큰 음식물의 크기를 출력하라.

예제 입력 1

예제 출력 1

문제 풀이

from collections import deque
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline

n,m,k = map(int,input().split())
matrix = [[0 for _ in range(m)] for _ in range(n)]
visited = [[0 for _ in range(m)] for _ in range(n)]
for i in range(k):
    y,x = map(int,input().split())
    matrix[y-1][x-1] = 1

def dfs(y,x):
    que = deque()
    que.append((y,x))
    cnt = 1
    dx = [-1,1,0,0]
    dy = [0,0,-1,1]
    while que:
        # print(y,x)
        y,x = que.popleft()
        for i in range(4):
            xx = dx[i] + x
            yy = dy[i] + y
            if 0<= xx < m and 0<= yy < n:
                if matrix[yy][xx] != 0 and visited[yy][xx] ==0:
                    visited[yy][xx] = 1
                    cnt +=1
                    que.append((yy,xx))
    return cnt

answer = []
for i in range(n):
    for j in range(m):
        if matrix[i][j] == 1 and visited[i][j] == 0:
            visited[i][j] = 1
            num1 = dfs(i,j)
            answer.append(num1)
print(max(answer))

문제 해석

기본적인 DFS , BFS 문제 입니다. 간만에 해당 유형을 풀어서 그런지 살짝 실수를 하더라구요. BFS또는 DFS에서 중요한점은 메모리 초과 방지를 위해 4방탐색 또는 8방탐색 조건 내에서 방문노드를 체크해야 메모리 초과를 방지 할 수 있습니다. 참고하시길 바라겠습니다

Baekjoon [11501] 주식 - python

Shine_sunho — Thu, 18 Jan 2024 19:29:36 +0900

11501번: 주식

입력의 첫 줄에는 테스트케이스 수를 나타내는 자연수 T가 주어진다. 각 테스트케이스 별로 첫 줄에는 날의 수를 나타내는 자연수 N(2 ≤ N ≤ 1,000,000)이 주어지고, 둘째 줄에는 날 별 주가를 나타

www.acmicpc.net

문제

홍준이는 요즘 주식에 빠져있다. 그는 미래를 내다보는 눈이 뛰어나, 날 별로 주가를 예상하고 언제나 그게 맞아떨어진다. 매일 그는 아래 세 가지 중 한 행동을 한다.

주식 하나를 산다.
원하는 만큼 가지고 있는 주식을 판다.
아무것도 안한다.
홍준이는 미래를 예상하는 뛰어난 안목을 가졌지만, 어떻게 해야 자신이 최대 이익을 얻을 수 있는지 모른다. 따라서 당신에게 날 별로 주식의 가격을 알려주었을 때, 최대 이익이 얼마나 되는지 계산을 해달라고 부탁했다.

예를 들어 날 수가 3일이고 날 별로 주가가 10, 7, 6일 때, 주가가 계속 감소하므로 최대 이익은 0이 된다. 그러나 만약 날 별로 주가가 3, 5, 9일 때는 처음 두 날에 주식을 하나씩 사고, 마지막날 다 팔아 버리면 이익이 10이 된다.

입력

입력의 첫 줄에는 테스트케이스 수를 나타내는 자연수 T가 주어진다. 각 테스트케이스 별로 첫 줄에는 날의 수를 나타내는 자연수 N(2 ≤ N ≤ 1,000,000)이 주어지고, 둘째 줄에는 날 별 주가를 나타내는 N개의 자연수들이 공백으로 구분되어 순서대로 주어진다. 날 별 주가는 10,000이하다.

출력

각 테스트케이스 별로 최대 이익을 나타내는 정수 하나를 출력한다. 답은 부호있는 64bit 정수형으로 표현 가능하다.

예제 입력 1

3
3
10 7 6
3
3 5 9
5
1 1 3 1 2

예제 출력 1

0
10
5

문제 풀이

test_case = int(input())

for i in range(test_case):
    sum1 = 0
    cnt = int(input())
    price_list = list(map(int,input().split()))
    purchase_cnt = []
    max_num = 0
    for i in range(len(price_list)-1,-1,-1):
        # print(price_list[i])
        if price_list[i] > max_num:
            max_num = price_list[i]
        else:
            sum1 += max_num-price_list[i]
    print(sum1)

문제 해석

숫자가 어디까지 커지는지 알아야 합니다. 이때 접근법을 다르게 생각하여 왼쪽에서 탐색이 아닌, 오른쪽에서 부터 탐색을 한 후, 대소비교를 통해 탐색했을 때 값이 작아지면 그전까지 큰 값을 저장해놨다가 값의 차이를 추가하여 계산합니다.

MySQL 코테준비 - 상품 별 오프라인 매출 구하기

Shine_sunho — Fri, 12 Jan 2024 17:05:50 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/131533

프로그래머스

programmers.co.kr

-- 코드를 입력하세요
SELECT product_code, sum(sales_amount) * price AS "SALES"
FROM PRODUCT
LEFT JOIN OFFLINE_SALE ON PRODUCT.PRODUCT_ID = OFFLINE_SALE.PRODUCT_ID
GROUP BY PRODUCT_CODE
ORDER BY SALES DESC, product_code

기본적인 JOIN문제이다. group by를 통해 column을 기준으로 group을 묶었으면 그룹함수를 어떻게 효율적으로 사용할지 생각해보자.

MySQL 코테준비 - 자동차 대여 기록에서 장기/단기 대여 구분하기

Shine_sunho — Thu, 11 Jan 2024 16:39:28 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/151138

프로그래머스

programmers.co.kr

-- 코드를 입력하세요
SELECT HISTORY_ID,CAR_ID,
    DATE_FORMAT(START_DATE,"%Y-%m-%d") AS START_DATE,
    DATE_FORMAT(END_DATE,"%Y-%m-%d") AS END_DATE,
    (
    CASE
    WHEN DATEDIFF(END_DATE,START_DATE) + 1 >= 30 THEN "장기 대여"
    ELSE "단기 대여"
    END
    ) AS "RENT_TYPE"
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY
WHERE MONTH(START_DATE) = 9 AND YEAR(START_DATE) = 2022 
ORDER BY HISTORY_ID DESC

DATE_FORMAT 함수를 통해 데이트 형식을 수정하며, 30일 이상 대여 기록을 갖고 있는 경우 DATEDIFF함수를 사용하여 계산해줬습니다.

MySQL 코테준비 - 조건에 부합하는 중고거래 상태 조회하기

Shine_sunho — Thu, 11 Jan 2024 16:24:08 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/164672

프로그래머스

programmers.co.kr

-- 코드를 입력하세요
SELECT BOARD_ID,WRITER_ID,TITLE,PRICE,
    (
    CASE
        WHEN STATUS = "DONE" THEN "거래완료"
        WHEN STATUS = "SALE" THEN "판매중"
        ELSE "예약중"
        END
    ) AS "STATUS"
FROM USED_GOODS_BOARD
WHERE CREATED_DATE = "2022-10-05"
ORDER BY BOARD_ID DESC

CASE WHEN문을 사용하여 조건에 맞춰 column내의 data값을 변경하며 테이블 조회를 진행했습니다.

CASE

WHEN 조건1 THEN 변경값1

WHEN 조건2 THEN 변경값2

ELSE 변경값3

END

위와 같은 방식으로 CASE WHEN 문을 사용합니다.

프로그래머스 level3 베스트앨범 - python

Shine_sunho — Mon, 8 Jan 2024 17:33:15 +0900

베스트앨범

문제 설명

스트리밍 사이트에서 장르 별로 가장 많이 재생된 노래를 두 개씩 모아 베스트 앨범을 출시하려 합니다. 노래는 고유 번호로 구분하며, 노래를 수록하는 기준은 다음과 같습니다.

속한 노래가 많이 재생된 장르를 먼저 수록합니다.
장르 내에서 많이 재생된 노래를 먼저 수록합니다.
장르 내에서 재생 횟수가 같은 노래 중에서는 고유 번호가 낮은 노래를 먼저 수록합니다.
노래의 장르를 나타내는 문자열 배열 genres와 노래별 재생 횟수를 나타내는 정수 배열 plays가 주어질 때, 베스트 앨범에 들어갈 노래의 고유 번호를 순서대로 return 하도록 solution 함수를 완성하세요.

제한사항

genres[i]는 고유번호가 i인 노래의 장르입니다.
plays[i]는 고유번호가 i인 노래가 재생된 횟수입니다.
genres와 plays의 길이는 같으며, 이는 1 이상 10,000 이하입니다.
장르 종류는 100개 미만입니다.
장르에 속한 곡이 하나라면, 하나의 곡만 선택합니다.
모든 장르는 재생된 횟수가 다릅니다.

입출력 예

genres	plays	return
["classic", "pop", "classic", "classic", "pop"]	[500, 600, 150, 800, 2500]	[4, 1, 3, 0]

입출력 예 설명

classic 장르는 1,450회 재생되었으며, classic 노래는 다음과 같습니다.

고유 번호 3: 800회 재생
고유 번호 0: 500회 재생
고유 번호 2: 150회 재생
pop 장르는 3,100회 재생되었으며, pop 노래는 다음과 같습니다.
고유 번호 4: 2,500회 재생
고유 번호 1: 600회 재생

따라서 pop 장르의 [4, 1]번 노래를 먼저, classic 장르의 [3, 0]번 노래를 그다음에 수록합니다.

장르 별로 가장 많이 재생된 노래를 최대 두 개까지 모아 베스트 앨범을 출시하므로 2번 노래는 수록되지 않습니다.

문제 풀이

def solution(genres, plays):
    answer = []
    unique_genres = list(set(genres))
    music_cnt = {}
    music_idx = {}
    for i in range(len(genres)):
        if genres[i] not in music_cnt:
            music_cnt[genres[i]] = 0  # 노래 카운트
            music_cnt[genres[i]] += plays[i]

            music_idx[genres[i]] = []
            music_idx[genres[i]].append((str(i), plays[i]))
        else:
            music_cnt[genres[i]] += plays[i]
            music_idx[genres[i]].append((str(i), plays[i]))

    music_cnt = sorted(music_cnt.items(), key=lambda x: x[1], reverse=True)
    # print(music_cnt)
    # 튜플의 두 번째 원소를 기준으로 리스트 정렬
    for i in music_idx:
        music_idx[i] = sorted(music_idx[i], key=lambda x: x[1], reverse=True)
    for i, j in music_cnt:
        if len(music_idx[i]) == 1:
            answer.append(int(music_idx[i][0][0]))
        else:
            for k in range(len(music_idx[i]) // 2):
                answer.append(int(music_idx[i][k * 2][0]))
                answer.append(int(music_idx[i][k * 2 + 1][0]))
                break
                # answer.append(music_idx[k*2+1][0])
    return answer

문제 해석

music_cnt는 장르의 총합 수를 계산하기 위해 쓰인 딕셔너리 변수며, music_idx는 idx와 장르내의 수록곡을 담기 위한 변수입니다. 주석에도 작성하듯이 수록곡의 개수를 바탕으로 정렬을 진행한다음, 정렬된 장르에서 탐색을 진행하며 장르내의 수록곡에서 2곡을 가져옵니다. 마지막 break문 걸어준 이유는 한 장르에서 여러 수록곡을 지속해서 2개씩 가져오는 방식인줄 알았는데 딱 2곡만 가져오는 방식이라 break문으로 2곡만 가져오고 for문을 멈춰줬습니다.

2024년 동계 IBK 청년인턴 체험형 디지털 직무 서류 및 면접 전형 합격 후기

Shine_sunho — Mon, 8 Jan 2024 16:14:45 +0900

위 IBK 기업은행 체험형 청년인턴 공고를 보고 금융 데이터 및 디지털 관련 본부에서 인턴으로 다양한 경험을 하고싶은 생각에 위 채용을 지원하게 됐습니다.

자기소개서 문항

자기소개서 문항 각 500자로 다음과 같았습니다.

1 .본인에게 중요한 가치관은 무엇이며, 그러한 가치관을 바탕으로 IBK에 지원한 이유와 인턴 경험을 통해 달성하고자 하는 목표는 무엇인지 구체적으로 기술하여 주십시오.

2 .타인과의 신뢰를 형성하는데 기여한 본인만의 노하우는 무엇이며, 신뢰를 유지하기 위해 책임감 있게 행동했던 경험을 기술하여 주십시오.

3 .본인의 인생에서 자신이 이루어냈던 가장 어려운 변화가 무엇이며, 어떻게 변화를 이루어냈는지 구체적으로 기술하여 주십시오.

4 .타인과 협업 또는 의사소통하면서 결과적으로 성공 또는 어려움을 극복했던 경험과 이를 통해 본인이 배운점을 구체적으로 기술하여 주십시오.

위 내용을 토대로 어떻게 자기소개서 문항을 접근했는지 경험을 공유하고자 합니다.

먼저 1번 문항에 대해선, 제 가치관을 먼저 두괄식으로 서술하며, 해당 가치관을 바탕으로 IBK 기업은행과의 공통점을 간단하게 서술한 후, 위의 경험을 바탕으로 지원하게 됐다 작성했습니다. 이후 문단에서는 저의 가치관에 해당하는 근거와 경험을 작성하며 1번 문항에 대해 위와 같이 접근했습니다.

2번 문항에 대해서는 교내 학생회 활동을 기재했습니다.

3번 문항에 대해서는 부족했던 전공경험을 어떻게 변화시켰는지 중점을 바탕으로 기재했습니다. 지금 보니 3번문항을 제일 못 쓴거 같습니다.

4번 문항에 대해서는 졸업 프로젝트를 진행하며, 어떻게 성공(수상)을 도출했는지 경험을 녹여 작성했습니다.

실기 전형

운이 좋게도, 서류전형을 뚫고 다음은 PT면접 및 다대다 면접 전형을 준비하게 됐습니다.

PT면접은 IBK 본사에서 진행됐으며, 제 생각은 디지털 직무는 따로 디지털 직무끼리 경쟁하는 것 같았습니다. PT 면접을 준비해본 경험이 없어서 IBK 인턴 오카방에서 면접 스터디 방을 구하며 준비하며 감을 잡았습니다.

실제 면접 전형을 다음과 같이 진행됐습니다. 최대 10명의 인원이 한 조로 구성되며, 하나의 주제에 대해 찬반으로 나눈 다음, 찬반끼리 마인드맵을 작성하며 PR을 진행했습니다. 이후, 서로간의 토론 면접을 통해 면접 평가가 진행됐습니다.

이후, 면접관과 1: N 면접을 통해 서류 기반 면접을 진행했습니다.

제한된 시간내에 면접을 보다보니, 평균 2~3 문항정도 면접관분께서 질문을 하셨습니다.

저는 총 3개의 질문을 받았는데 질문 문항은 다음과 같았습니다.

1. 지원동기

2. 자기소개서 기반 질문

3. 나를 한단어로 표현하자면?

위 문항에 대해 적절히 답변을 하며, 최종합격을 할 수 있었습니다. 추후 배정이 어떻게 될지 모르겠지만, IBK 인턴경험이 끝나면 회고록으로 다시 돌아오도록 하겠습니다.

추후 IBK 기업인턴을 준비하는 분들에게 좋은 참고 자료가 됐으면 좋겠습니다.

감사합니다.

SKT FLY AI 4기 서류 및 면접 합격 후기

Shine_sunho — Mon, 8 Jan 2024 15:55:46 +0900

SKT 회고록

2023년 하반기 채용 공고가 끝나고 결국 최종 합격까지 진행하지 못하여 2024년 상반기를 준비하기 전, 방학기간 할 수 있는 프로젝트나 프로그램을 찾아보다 SKT FLY AI를 발견하여 신청하게 됐습니다!

방학기간 동안 할 수 있는 점이 제일 매력적이였고, AI의 선두기업인 SKT에서 AI관련 교육을 받는 점이 굉장히 흥미로웠다. 이런 점에 끌려 준비를 하게 됐고 그간 경험들을 공유하고자 해당 블로그를 작성하게 됐습니다. 추후 5기,6기를 준비하는 분들에게 좋은 자료가 되길 바라겠습니다.

자기소개서 문항

처음 자기소개서 문항은 다음과 같았습니다.

1. 지원동기

2. 취업이력

3. 자기소개서

4. 대외활동

5. 향후계획

위 5가지 항목을 각각 500자를 적는 것이였습니다. 각 문항에 대해 말씀드리겠습니다!

지원동기

저는 지원동기 항목에는 SKT의 비전과 더불어 제가 왜 지원하게 됐는지 말을 요약하여 작성하는데 포커스를 두었습니다.

취업이력

2번 취업이력 항목에는 2번의 인턴경험을 녹여 서술형이 아닌 이력서 형식처럼 요약하여 목록을 나눠 작성했습니다.

ex) @@회사 / @개월

* 주요업무 : ~~

* 과정 설명

* 경험

위와 같은 형식으로 2개의 인턴경험을 녹였습니다.

자기소개서

저의 성장과정을 녹여내며 저는 이런 사람이다를 정해 진행했던 활동에 대해 나열하며 배운 경험을 강조했습니다.

대외활동

GDSC 멤버로 활동하며 세미나 참가했던 경험과, 산학협력을 통해 학부연구생으로 한국통신학회에서 주관하는 논문발표에 참가하여 논문을 발표했던 경험을 서술했습니다.

향후계획

향후계획은 크게 신경쓰지 않아 단기적 목표와 장기적 목표를 설정하여 ~를 하겠다라는 포부를 중점적으로 기재했습니다.

실기 전형

운이 좋게 위 서류를 바탕으로 서류를 합격하게 됐습니다. 추후 일정은 면접과 더불어 코딩테스트를 진행했습니다.

이에 코딩테스트는 python언어로 준비했으며, 시간이 좀 지나 기억이 잘 나지 않지만, 3~4문제 정도 나왔던걸로 기억합니다. 좀 특이한점은 실기와 더불어 면접을 합쳐 점수를 계산해 합격자를 선정하는 점이였습니다. 따라서 코딩테스트랑 면접준비를 같이 했어야 했습니다. 또 다르게 생각하면 코딩테스트를 잘 보지 못했더라도 면접준비를 충분히 잘 하신다면 좋은 결과가 나올거라 생각합니다.

면접은 SKT T타워에서 진행했고 2명의 면접관과 더불어 4~5명의 인원이 같이 들어가는 면접이였습니다. 아무래도 교육프로그램이다 보니 면접의 질문자체에 전공성이 강한 질문은 갖고있지 않았고, 지원동기와 자기소개 등 기본적인 질문과 더불어 자기소개서에 적은 간단한 내용들을 물어보는 것이 주 질문이였습니다.

운이 좋게?! 합격을 하게 되어 SKT 보라매 사옥에서 교육생으로 교육을 받았습니다.

하지만 지금은 타회사 인턴으로 채용이 되어 해당 교육을 퇴소했습니다. 약 3주정도 교육을 받으며 느꼈던 경험과 느낀점을 공유하고자 합니다.

느낀점

초기 1주차에 OT를 진행하며 바로 팀구성을 들어갑니다. 이에 자기 PR을 정말 잘하셔야 한다고 생각합니다. 실제로 PR을 하는 사람들의 스펙와 경험들을 봤을 때 다들 굉장히 잘하시는 교육생들로 구성됐던거 같습니다. 실제로 대학원생들도 있으셨고 실제 현업을 종사하셨던 분들, 고학력자 분들, 많은 사람들이 존재했습니다. 이런 사람들과 같이 한 조를 이뤄 SKT FLY AI의 프로젝트를 같이 진행한다면 많은 것을 배우며 좋은 경험이 될 것 같습니다.

또한 SKT의 교육프로그램이다보니 아무래도 지원이 좋았습니다. 타 회사 국비 지원 프로그램을 참가하지 않아 비교가 힘들지만, 기본적으로 주는 사은품들과 간식 등이 굉장히 많았고, 조,중,석식이 교육생들에게 무료로 지원해준다는 점이 굉장히 좋았습니다. 6시에 교육이 끝나고 자율적으로 학습할 수 있는 환경이 구성되어 석식을 먹고 자유롭게 공부를 할 수 있는 환경을 조성해준다는 점이 좋았습니다.

그리고 많은 운영진분들과 강사님들의 지원 또한 좋았습니다. 비교적 2달정도의 짧은 시간의 부트캠프 프로그램이다 보니 큰 개념을 잡아가는 교육이 중점이였지만, 위 과정에서도 배울점도 많았고, 지속적으로 팀단위 프로젝트를 간단하게 진행하며 직무전문성을 높여주셨던거 같습니다. 하지만 짧은시간에 있어 나가는 진도가 상당히 빠른편이라 생각합니다. 실제로 해당 직무를 전공하지 않은 비전공생 분들은 개인적인 자습이 없으면 교육프로그램을 따라가기 벅찰 수도 있다 생각합니다.

위 내용을 바탕으로 추후 준비를 하시는 분들에게 좋은 참고자료가 됐으면 좋겠습니다.

Clustering이란?

Shine_sunho — Mon, 11 Dec 2023 01:35:14 +0900

클러스터링이란

범주 구조를 생성하는 통계적 기법입니다.
동일 그룹에 속하는 개체들은 결속력이 강하고, 다른 그룹에 속하는 개체들은 결속력이 약합니다.
classfication과 차이점 : 클러스터 그룹이 알려져 있지 않습니다.

클러스터링 기법의 분류

분류하기전, 각 문서들에 대해 matrix 연산을 진행해야 합니다.
계층적 구조와 비계층적 구조로 나뉠 수 있습니다.
응집 vs 분할 방식으로 나눌 수 있습니다.
Distribution-based(분포 기반) vs density-based(밀집 기반)
- cluster의 분포를 중요시 한다면 각 cluster들의 크기가 일정합니다.
- cluster의 밀집도를 중요시 한다면 DBSCAN과 같은 방식을 사용할 수 있습니다. 이러한 방식은 불규칙을 처리가능 하며, Noise와 outlier가 많을 때 비교적 사용 가능합니다.

Clustering 방법

N object를 M groups으로 바꿉니다.
Agglomerative(응집) vs Divisive(분할)
- 응집 : unclustered data set -> N-1 pairwise joins 진행
- 분할 : 하나의 single cluster안에 있는 모든 object가 존재 -> N-1 division 진행

계층적 클러스터링 알고리즘

HACM(Hierarchical Agglomerative Clustering method)이라고 불리며 연결기반 클러스터링 알고리즘입니다.
해당 클러스터 구조는 Dendrogram형식을 띕니다.
SLINK, CLINK, Group Average Link, Ward'method 등이 존재합니다.

SLINK (Single Linkage):
- SLINK는 가장 가까운 이웃 간의 거리를 클러스터 간 거리로 사용하는 방법입니다.
- 이 방법은 단일 연결법이라고도 불립니다.
- SLINK는 클러스터의 크기가 크거나 이상치(outlier)가 있는 경우에 민감할 수 있습니다.
- 길쭉한 형태의 클러스터가 생성됨
CLINK (Complete Linkage):
- CLINK는 가장 먼 이웃 간의 거리를 클러스터 간 거리로 사용하는 방법입니다.
- 두 클러스터에서 가장 먼 데이터 포인트 사이의 거리를 클러스터 간 거리로 측정합니다.
- 이 방법은 완전 연결법이라고도 불립니다.
- CLINK는 이상치에 대해 상대적으로 덜 민감하며, 클러스터 내의 다양성을 보존하는 경향이 있습니다.
GA Link (Group Average Link):
- 그룹 평균 연결법(Group Average Linkage)은 두 클러스터 내의 모든 데이터 포인트 쌍의 평균 거리를 사용하여 클러스터 간 거리를 측정합니다.
- 모든 데이터 포인트 사이의 거리를 고려하여 클러스터 간의 거리를 계산합니다.
- 이 방법은 SLINK와 CLINK의 중간 정도로 간주되며, 일반적으로 이상치에 대해 상대적으로 덜 민감합니다.
Ward's method:
- Ward의 방법은 클러스터를 합치면서 클러스터 내 분산 증가를 최소화하는 방향으로 클러스터를 형성합니다. 이때 중심점 사이의 계산은 유클리안 distance를 기반으로 함.
- 각 클러스터를 합치면서 총 제곱 오차(Sum of Squares Error, SSE)를 최소화하는 방향으로 클러스터 간 거리를 정의합니다.
- 동질적인 클러스터와 대칭적인 계층 구조를 생성하는 경향이 있습니다
- 클러스터 무게중심에 대한 정의는 클러스터를 나타내는 유용한 방법을 제공합니다

비계층적 클러스터링 알고리즘

자료 집합이 N이 클러스터 M보다 매운 큰 자료 집합을 분할하는데 계층적 방법보다 효율적임
계산자원에 한계가 있었던 초기의 클러스터링 연구에 사용함
단일 패스
- 단일패스 알고리즘은 데이터를 한 번만 스캔하여 클러스터를 형성합니다.
- 일반적으로 알고리즘은 데이터 포인트를 하나씩 순서대로 처리하면서, 각 데이터 포인트를 기존 클러스터에 할당하거나 새로운 클러스터를 만듭니다.
- 각 데이터 포인트와 클러스터 간의 거리나 유사성을 기준으로 클러스터링을 수행합니다
재배치
- 재배치 알고리즘은 초기 클러스터를 임의로 생성한 후, 데이터 포인트를 다시 할당하여 클러스터의 중심 또는 경계를 조정하는 방식으로 클러스터를 개선합니다.
- 주로 k-means와 같은 알고리즘이 재배치 알고리즘의 대표적인 예입니다.
- k-means algorithm
  - 클러스터 개수 k가 주어졌을 때 각 클러스터들에 대한 전체 분산을 총합v를 최소화하는 s을 찾는 기계학습 알고리즘
유사도 측정 방법
- Dice coefficient
- Jaccard coefficient
- Cosine coefficient
문서 클러스터링 방법
- 문서들을 벡터화하여 유사한 문서끼리 클러스터를 이루게 하는것이 문서 클러스터링이다.
  각 문서들을 벡터화(document-term matrix) 합니다
  tf-idf를 이용하여 유사도를 비교해서 유사도가 큰 문서끼리 클러스터를 생성
  비교 및 평가를 하면서 바꾼다.

Baekjoon [1051] 숫자 정사각형 - python

Shine_sunho — Sun, 10 Dec 2023 22:21:06 +0900

숫자 정사각형

문제

N×M크기의 직사각형이 있다. 각 칸에는 한 자리 숫자가 적혀 있다. 이 직사각형에서 꼭짓점에 쓰여 있는 수가 모두 같은 가장 큰 정사각형을 찾는 프로그램을 작성하시오. 이때, 정사각형은 행 또는 열에 평행해야 한다.

입력

첫째 줄에 N과 M이 주어진다. N과 M은 50보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에 수가 주어진다.

출력

첫째 줄에 정답 정사각형의 크기를 출력한다.

예제 입력 1

3 5
42101
22100
22101

예제 출력 1

예제 입력 2

2 2
12
34

예제 출력 2

예제 입력 3

2 4
1255
3455

예제 출력 3

예제 입력 4

1 10
1234567890

예제 출력 4

예제 입력 5

11 10
9785409507
2055103694
0861396761
3073207669
1233049493
2300248968
9769239548
7984130001
1670020095
8894239889
4053971072

예제 출력 5

문제 풀이

n,m = map(int,input().split())
matrix = []
for i in range(n):
    a = list(input())
    matrix.append(a)
# print(matrix)

min_num = min(n,m)  # ex)3 최대 정사각형 크기는 3이 넘을 수 없음
# range_len = min_num +1
answer = []


while True:
    for i in range(n-min_num):
        for j in range(m-min_num):
         # print(i,j)
            if matrix[i][j] == matrix[i][j+min_num] == matrix[i+min_num][j] == matrix[i+min_num][j+min_num]:
                # print(matrix[i][j])
                # print(min_num)
                print((min_num+1)**2)
                exit()
    else:
        min_num-=1

문제 해석

딥러닝 기법중에 CNN기법이랑 비슷하다 생각하면된다. min_num을 기반으로 filter를 만들어서 양 모서리를 비교할 수 있도록 한다. 필터의 크기를 1씩 줄여가며 탐색을 진행하면서 정사각형이 만들어지면 그 즉시 종료한다.

Baekjoon [2477] 참외밭 - python

Shine_sunho — Thu, 7 Dec 2023 23:35:42 +0900

참외밭

문제

시골에 있는 태양이의 삼촌 댁에는 커다란 참외밭이 있다. 문득 태양이는 이 밭에서 자라는 참외가 도대체 몇 개나 되는지 궁금해졌다. 어떻게 알아낼 수 있는지 골똘히 생각하다가 드디어 좋은 아이디어가 떠올랐다. 유레카! 1m2의 넓이에 자라는 참외 개수를 헤아린 다음, 참외밭의 넓이를 구하면 비례식을 이용하여 참외의 총개수를 구할 수 있다.

1m2의 넓이에 자라는 참외의 개수는 헤아렸고, 이제 참외밭의 넓이만 구하면 된다. 참외밭은 ㄱ-자 모양이거나 ㄱ-자를 90도, 180도, 270도 회전한 모양(┏, ┗, ┛ 모양)의 육각형이다. 다행히도 밭의 경계(육각형의 변)는 모두 동서 방향이거나 남북 방향이었다. 밭의 한 모퉁이에서 출발하여 밭의 둘레를 돌면서 밭경계 길이를 모두 측정하였다.

예를 들어 참외밭이 위 그림과 같은 모양이라고 하자. 그림에서 오른쪽은 동쪽, 왼쪽은 서쪽, 아래쪽은 남쪽, 위쪽은 북쪽이다. 이 그림의 왼쪽위 꼭짓점에서 출발하여, 반시계방향으로 남쪽으로 30m, 동쪽으로 60m, 남쪽으로 20m, 동쪽으로 100m, 북쪽으로 50m, 서쪽으로 160m 이동하면 다시 출발점으로 되돌아가게 된다.

위 그림의 참외밭 면적은 6800m2이다. 만약 1m2의 넓이에 자라는 참외의 개수가 7이라면, 이 밭에서 자라는 참외의 개수는 47600으로 계산된다.

1m2의 넓이에 자라는 참외의 개수와, 참외밭을 이루는 육각형의 임의의 한 꼭짓점에서 출발하여 반시계방향으로 둘레를 돌면서 지나는 변의 방향과 길이가 순서대로 주어진다. 이 참외밭에서 자라는 참외의 수를 구하는 프로그램을 작성하시오.

입력

첫 번째 줄에 1m2의 넓이에 자라는 참외의 개수를 나타내는 양의 정수 K (1 ≤ K ≤ 20)가 주어진다. 참외밭을 나타내는 육각형의 임의의 한 꼭짓점에서 출발하여 반시계방향으로 둘레를 돌면서 지나는 변의 방향과 길이 (1 이상 500 이하의 정수) 가 둘째 줄부터 일곱 번째 줄까지 한 줄에 하나씩 순서대로 주어진다. 변의 방향에서 동쪽은 1, 서쪽은 2, 남쪽은 3, 북쪽은 4로 나타낸다.

출력

첫째 줄에 입력으로 주어진 밭에서 자라는 참외의 수를 출력한다.

예제 입력 1

7
4 50
2 160
3 30
1 60
3 20
1 100

예제 출력 1

47600

문제 풀이

melon = int(input())

list1= [] # 방향 정보 담을 리스트
width = [] # min, max 구할 리스트
length = []
for i in range(6):
    dirc,line = map(int,input().split())
    list1.append((dirc,line))
    if dirc == 2 or dirc == 1:
        width.append(line)
    elif dirc == 3 or dirc == 4:
        length.append(line)
# print(list1)
min_field = []
for i in range(6):
    if list1[i][0] == list1[(i+2)%6][0]:
        min_field.append(list1[(i+1)%6][1])

max_filed = max(width) * max(length)
min_field = min_field[0] * min_field[1]
print((max_filed-min_field) * melon)

문제 해석

개수가 2개인 방향을 바탕으로 탐색했을 때 그 다음 idx값을 가져온다. 이때 index error를 벗어나기 위해 6을 나눠주며 탐색을 진행했다.

Batch normalization이란?

Shine_sunho — Thu, 7 Dec 2023 17:58:12 +0900

Batch란?

기본적으로 딥러닝에서 batch란, 전체 데이터에서 일부분을 칭하는 단어입니다. 이에 따라 학습의 효율성을 위해 전체 큰 데이터를 분할하여 학습을 하게 되는데 이를 batch단위로 쪼개 학습을 한다고 말합니다.

이때, Neural network의 depth가 깊어질수록, 즉 Layer가 많아질수록 "internal covariate shift" 현상이 발생합니다.

internal convariate shift 현상이란, 모델 학습 과정에서 Layer를 통과할 때마다 출력값의 데이터 분포는 Layer마다 다르게 나타나는 현상입니다.

왜 데이터의 분포가 달라지냐 묻는다면, 학습이 진행될수록 정규화를 하지 않으면 x,y의 학습폭이 다르게 나타날 수 있기 때문입니다.

위 사진처럼 gradient를 진행할 때, 정규화를 하지 않으면 x의 폭과 y폭이 일정하지 않아, 일정하게 학습이 일어나지 않을 수 있습니다. 이에 따라 정규화를 진행합니다.

해당 Normalize를 하지 않는 학습과정을 시각화 한다면, 다음과 같이 분포가 나올 수 있습니다.

위 사진 처럼 기존 분포는 가우시안 분포를 띄지만 학습을 진행하고, 활성화 함수를 통해 나온 값의 분포가 점점 바뀌는 모습을 확인할 수 있습니다. 이런 문제를 해결하기 위해 Batch normalize를 진행합니다.

수식은 다음과 같습니다. 위 수식을 통해 배치 결과값의 평균값과 분산값을 각각 0과 1을 맞추기위해 진행합니다.

이후 베타와 감마값을 통해 활성화 함수로 값이 들어갈 때, 비선형 스케일을 잃지않도록 값을 조정하며 학습을 진행합니다.

결론

이런 Batch 정규화를 통해 다음과 같은 장점을 얻을 수 있습니다.

Layer가 많아실수록 학습이 어려웠던 문제를 해결하며 학습이 일정하게 진행됩니다.
overfitting을 피할 수 있습니다.
Regularization 효과: 배치 정규화는 일종의 Regularization 효과를 가지고 있어 일반화 성능을 향상시킵니다.
큰 학습이 가능해집니다.

참고

https://wooono.tistory.com/227

[DL] 배치 정규화(Batch Normalization)

기존에는 Gradient Vanishing, Exploding 현상을 해결하고 학습을 안정화하기 위해서 새로운 활성화 함수를 찾거나 가중치를 초기화하는 방법을 사용했었다. 하지만, 배치 정규화를 통해서 보다 근본적

wooono.tistory.com

https://www.jeremyjordan.me/batch-normalization/

Normalizing your data (specifically, input and batch normalization).

In this post, I'll discuss considerations for normalizing your data - with a specific focus on neural networks. In order to understand the concepts discussed, it's important to have an understanding of gradient descent.

www.jeremyjordan.me

https://heytech.tistory.com/438

[Deep Learning] Batch Normalization(배치 정규화) 개념 및 장점

들어가며 본 포스팅에서는 딥러닝 Generalization 기법 중 하나인 배치 정규화(Batch Normalization)에 대해 알아봅니다. 먼저, 데이터 정규화의 필요성에 대해 알아보고, Batch Normalization의 등장 배경인

heytech.tistory.com

Regularization, L1, L2 Regularization이란?

Shine_sunho — Wed, 6 Dec 2023 00:15:03 +0900

Regularization이란?

Overfitting을 피하기 위한 기법으로, 과적합을 예방하기 위한 Loss finction에 대한 추가 기준입니다. 이에 모델을 조금더 General하게 만들고자합니다.
Overfitting이란, 모델이 noise에 대해 높은 수용력을 가지며 기존 훈련 데이터에는 높은 성능을 가지지만, 새로운 예제에 대해선 그만큼의 성능을 보이지 못하는 경우를 의미합니다.

기본적인 Regularization의 수식은 다음과 같습니다.

기존 Data loss를 통해 모델 예측을 하는 수식에 hyperparameter를 추가하여 overfitting을 피하도록 진행합니다.

이에 따라 L2 정규화와 L1정규화에 대해 설명하겠습니다.

L2 정규화란?

Ridge Regression이라고도 불리며, Loss function에 제곱한 가중치 값을 더해줌으로써 미분을 통해 back propagation 할 때 Cost 뿐만 아니라 가중치 또한 줄어드는 방식으로 학습을 진행 합니다. 특정 가중치가 비이상적으로 커지는 상황을 방지하고, Weight decay가 가능해지는 장점이 있습니다. 람다에 대해 클수록 value에 대한 penaly를 더 부가한다고 보시면 됩니다. 이에 필요한 Feature(이상치)에 대응하는 Weight를 0에 가깝게 만들 뿐, 0으로 만들지는 않습니다.

L1 정규화란?

Ridge Regression이라고도 불리며, 가중치의 절대값을 더해주고, 편미분을 진행하면 부호만 남게 됩니다. 이에따라 불필요한 Feature에 대응하는 Weight를 정확히 0으로 만들어버려, 이에따라 결과적으로 몇몇 중요한 가중치만 남게 됩니다.

위 L1정규화와 L2정규화를 혼합하여 만드는 정규화를 Elastic net이라고 불립니다.

참고

https://seongyun-dev.tistory.com/52

[최적화] 가중치 규제 L1, L2 Regularization의 의미, 차이점 (Lasso, Ridge)

1. 수학적 최적화(Optimization)와 과적합 (Overfitting) 수학에서 최적화란, 특정 집합에 대한 목적 함수(Objective Function)를 최소화 혹은 최대화시키는 최적해 (파라미터)를 찾는 것을 말합니다. 머신러닝

seongyun-dev.tistory.com

https://junklee.tistory.com/29

L1, L2 Norm, Loss, Regularization?

정규화 관련 용어로 자주 등장하는 L1, L2 정규화(Regularization)입니다. 이번에는 단순하게 이게 더 좋다 나쁘다보다도, L1, L2 그 자체가 어떤 의미인지 짚어보고자합니다. 사용된 그림은 위키피디아

junklee.tistory.com

https://esj205.oopy.io/4b321662-5d02-4559-8677-7e974cf080a8

L1 정규화, L2 정규화

출처:

esj205.oopy.io

사용자 MBTI 유추하기 프로젝트

Shine_sunho — Tue, 5 Dec 2023 16:03:50 +0900

MBTI Personality Types 500 Dataset

~100K preprocessed records of posts and personality types

www.kaggle.com

본 프로젝트는 Kaggle에 있는 MBTI dataset을 사용하여 colab환경에서 진행했습니다.

from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive

%cd /content/drive/MyDrive/텍스트마이닝_기말과제

/content/drive/MyDrive/텍스트마이닝_기말과제

!ls

'MBTI 500.csv'                svm_classifier.pkl     텍스트마이닝_기말과제.ipynb
 random_forest_classifier.pkl   tfidf_vectorizer.pkl

import pandas as pd
import numpy as np
from sklearn.utils import resample
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
import joblib
import wordcloud
from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt
from collections import Counter
import seaborn as sns
from sklearn.feature_extraction.text import CountVectorizer

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer

nltk.download('punkt')
nltk.download('stopwords')
nltk.download('wordnet')

stop_words = set(stopwords.words('english'))
stop_words.update(['er', 'ikke',"0o", "0s", "3a", "3b", "3d", "6b", "6o", "a", "a1", "a2", "a3", "a4", "ab", "able", "about", "above", "abst", "ac", "accordance", "according", "accordingly", "across", "act", "actually", "ad", "added", "adj", "ae", "af", "affected", "affecting", "affects", "after", "afterwards", "ag", "again", "against", "ah", "ain", "ain't", "aj", "al", "all", "allow", "allows", "almost", "alone", "along", "already", "also", "although", "always", "am", "among", "amongst", "amoungst", "amount", "an", "and", "announce", "another", "any", "anybody", "anyhow", "anymore", "anyone", "anything", "anyway", "anyways", "anywhere", "ao", "ap", "apart", "apparently", "appear", "appreciate", "appropriate", "approximately", "ar", "are", "aren", "arent", "aren't", "arise", "around", "as", "a's", "aside", "ask", "asking", "associated", "at", "au", "auth", "av", "available", "aw", "away", "awfully", "ax", "ay", "az", "b", "b1", "b2", "b3", "ba", "back", "bc", "bd", "be", "became", "because", "become", "becomes", "becoming", "been", "before", "beforehand", "begin", "beginning", "beginnings", "begins", "behind", "being", "believe", "below", "beside", "besides", "best", "better", "between", "beyond", "bi", "bill", "biol", "bj", "bk", "bl", "bn", "both", "bottom", "bp", "br", "brief", "briefly", "bs", "bt", "bu", "but", "bx", "by", "c", "c1", "c2", "c3", "ca", "call", "came", "can", "cannot", "cant", "can't", "cause", "causes", "cc", "cd", "ce", "certain", "certainly", "cf", "cg", "ch", "changes", "ci", "cit", "cj", "cl", "clearly", "cm", "c'mon", "cn", "co", "com", "come", "comes", "con", "concerning", "consequently", "consider", "considering", "contain", "containing", "contains", "corresponding", "could", "couldn", "couldnt", "couldn't", "course", "cp", "cq", "cr", "cry", "cs", "c's", "ct", "cu", "currently", "cv", "cx", "cy", "cz", "d", "d2", "da", "date", "dc", "dd", "de", "definitely", "describe", "described", "despite", "detail", "df", "di", "did", "didn", "didn't", "different", "dj", "dk", "dl", "do", "does", "doesn", "doesn't", "doing", "don", "done", "don't", "down", "downwards", "dp", "dr", "ds", "dt", "du", "due", "during", "dx", "dy", "e", "e2", "e3", "ea", "each", "ec", "ed", "edu", "ee", "ef", "effect", "eg", "ei", "eight", "eighty", "either", "ej", "el", "eleven", "else", "elsewhere", "em", "empty", "en", "end", "ending", "enough", "entirely", "eo", "ep", "eq", "er", "es", "especially", "est", "et", "et-al", "etc", "eu", "ev", "even", "ever", "every", "everybody", "everyone", "everything", "everywhere", "ex", "exactly", "example", "except", "ey", "f", "f2", "fa", "far", "fc", "few", "ff", "fi", "fifteen", "fifth", "fify", "fill", "find", "fire", "first", "five", "fix", "fj", "fl", "fn", "fo", "followed", "following", "follows", "for", "former", "formerly", "forth", "forty", "found", "four", "fr", "from", "front", "fs", "ft", "fu", "full", "further", "furthermore", "fy", "g", "ga", "gave", "ge", "get", "gets", "getting", "gi", "give", "given", "gives", "giving", "gj", "gl", "go", "goes", "going", "gone", "got", "gotten", "gr", "greetings", "gs", "gy", "h", "h2", "h3", "had", "hadn", "hadn't", "happens", "hardly", "has", "hasn", "hasnt", "hasn't", "have", "haven", "haven't", "having", "he", "hed", "he'd", "he'll", "hello", "help", "hence", "her", "here", "hereafter", "hereby", "herein", "heres", "here's", "hereupon", "hers", "herself", "hes", "he's", "hh", "hi", "hid", "him", "himself", "his", "hither", "hj", "ho", "home", "hopefully", "how", "howbeit", "however", "how's", "hr", "hs", "http", "hu", "hundred", "hy", "i", "i2", "i3", "i4", "i6", "i7", "i8", "ia", "ib", "ibid", "ic", "id", "i'd", "ie", "if", "ig", "ignored", "ih", "ii", "ij", "il", "i'll", "im", "i'm", "immediate", "immediately", "importance", "important", "in", "inasmuch", "inc", "indeed", "index", "indicate", "indicated", "indicates", "information", "inner", "insofar", "instead", "interest", "into", "invention", "inward", "io", "ip", "iq", "ir", "is", "isn", "isn't", "it", "itd", "it'd", "it'll", "its", "it's", "itself", "iv", "i've", "ix", "iy", "iz", "j", "jj", "jr", "js", "jt", "ju", "just", "k", "ke", "keep", "keeps", "kept", "kg", "kj", "km", "know", "known", "knows", "ko", "l", "l2", "la", "largely", "last", "lately", "later", "latter", "latterly", "lb", "lc", "le", "least", "les", "less", "lest", "let", "lets", "let's", "lf", "like", "liked", "likely", "line", "little", "lj", "ll", "ll", "ln", "lo", "look", "looking", "looks", "los", "lr", "ls", "lt", "ltd", "m", "m2", "ma", "made", "mainly", "make", "makes", "many", "may", "maybe", "me", "mean", "means", "meantime", "meanwhile", "merely", "mg", "might", "mightn", "mightn't", "mill", "million", "mine", "miss", "ml", "mn", "mo", "more", "moreover", "most", "mostly", "move", "mr", "mrs", "ms", "mt", "mu", "much", "mug", "must", "mustn", "mustn't", "my", "myself", "n", "n2", "na", "name", "namely", "nay", "nc", "nd", "ne", "near", "nearly", "necessarily", "necessary", "need", "needn", "needn't", "needs", "neither", "never", "nevertheless", "new", "next", "ng", "ni", "nine", "ninety", "nj", "nl", "nn", "no", "nobody", "non", "none", "nonetheless", "noone", "nor", "normally", "nos", "not", "noted", "nothing", "novel", "now", "nowhere", "nr", "ns", "nt", "ny", "o", "oa", "ob", "obtain", "obtained", "obviously", "oc", "od", "of", "off", "often", "og", "oh", "oi", "oj", "ok", "okay", "ol", "old", "om", "omitted", "on", "once", "one", "ones", "only", "onto", "oo", "op", "oq", "or", "ord", "os", "ot", "other", "others", "otherwise", "ou", "ought", "our", "ours", "ourselves", "out", "outside", "over", "overall", "ow", "owing", "own", "ox", "oz", "p", "p1", "p2", "p3", "page", "pagecount", "pages", "par", "part", "particular", "particularly", "pas", "past", "pc", "pd", "pe", "per", "perhaps", "pf", "ph", "pi", "pj", "pk", "pl", "placed", "please", "plus", "pm", "pn", "po", "poorly", "possible", "possibly", "potentially", "pp", "pq", "pr", "predominantly", "present", "presumably", "previously", "primarily", "probably", "promptly", "proud", "provides", "ps", "pt", "pu", "put", "py", "q", "qj", "qu", "que", "quickly", "quite", "qv", "r", "r2", "ra", "ran", "rather", "rc", "rd", "re", "readily", "really", "reasonably", "recent", "recently", "ref", "refs", "regarding", "regardless", "regards", "related", "relatively", "research", "research-articl", "respectively", "resulted", "resulting", "results", "rf", "rh", "ri", "right", "rj", "rl", "rm", "rn", "ro", "rq", "rr", "rs", "rt", "ru", "run", "rv", "ry", "s", "s2", "sa", "said", "same", "saw", "say", "saying", "says", "sc", "sd", "se", "sec", "second", "secondly", "section", "see", "seeing", "seem", "seemed", "seeming", "seems", "seen", "self", "selves", "sensible", "sent", "serious", "seriously", "seven", "several", "sf", "shall", "shan", "shan't", "she", "shed", "she'd", "she'll", "shes", "she's", "should", "shouldn", "shouldn't", "should've", "show", "showed", "shown", "showns", "shows", "si", "side", "significant", "significantly", "similar", "similarly", "since", "sincere", "six", "sixty", "sj", "sl", "slightly", "sm", "sn", "so", "some", "somebody", "somehow", "someone", "somethan", "something", "sometime", "sometimes", "somewhat", "somewhere", "soon", "sorry", "sp", "specifically", "specified", "specify", "specifying", "sq", "sr", "ss", "st", "still", "stop", "strongly", "sub", "substantially", "successfully", "such", "sufficiently", "suggest", "sup", "sure", "sy", "system", "sz", "t", "t1", "t2", "t3", "take", "taken", "taking", "tb", "tc", "td", "te", "tell", "ten", "tends", "tf", "th", "than", "thank", "thanks", "thanx", "that", "that'll", "thats", "that's", "that've", "the", "their", "theirs", "them", "themselves", "then", "thence", "there", "thereafter", "thereby", "thered", "therefore", "therein", "there'll", "thereof", "therere", "theres", "there's", "thereto", "thereupon", "there've", "these", "they", "theyd", "they'd", "they'll", "theyre", "they're", "they've", "thickv", "thin", "think", "third", "this", "thorough", "thoroughly", "those", "thou", "though", "thoughh", "thousand", "three", "throug", "through", "throughout", "thru", "thus", "ti", "til", "tip", "tj", "tl", "tm", "tn", "to", "together", "too", "took", "top", "toward", "towards", "tp", "tq", "tr", "tried", "tries", "truly", "try", "trying", "ts", "t's", "tt", "tv", "twelve", "twenty", "twice", "two", "tx", "u", "u201d", "ue", "ui", "uj", "uk", "um", "un", "under", "unfortunately", "unless", "unlike", "unlikely", "until", "unto", "uo", "up", "upon", "ups", "ur", "us", "use", "used", "useful", "usefully", "usefulness", "uses", "using", "usually", "ut", "v", "va", "value", "various", "vd", "ve", "ve", "very", "via", "viz", "vj", "vo", "vol", "vols", "volumtype", "vq", "vs", "vt", "vu", "w", "wa", "want", "wants", "was", "wasn", "wasnt", "wasn't", "way", "we", "wed", "we'd", "welcome", "well", "we'll", "well-b", "went", "were", "we're", "weren", "werent", "weren't", "we've", "what", "whatever", "what'll", "whats", "what's", "when", "whence", "whenever", "when's", "where", "whereafter", "whereas", "whereby", "wherein", "wheres", "where's", "whereupon", "wherever", "whether", "which", "while", "whim", "whither", "who", "whod", "whoever", "whole", "who'll", "whom", "whomever", "whos", "who's", "whose", "why", "why's", "wi", "widely", "will", "willing", "wish", "with", "within", "without", "wo", "won", "wonder", "wont", "won't", "words", "world", "would", "wouldn", "wouldnt", "wouldn't", "www", "x", "x1", "x2", "x3", "xf", "xi", "xj", "xk", "xl", "xn", "xo", "xs", "xt", "xv", "xx", "y", "y2", "yes", "yet", "yj", "yl", "you", "youd", "you'd", "you'll", "your", "youre", "you're", "yours", "yourself", "yourselves", "you've", "yr", "ys", "yt", "z", "zero", "zi", "zz"])
pattern = r'[^\w\s]'

[nltk_data] Downloading package punkt to /root/nltk_data...
[nltk_data]   Unzipping tokenizers/punkt.zip.
[nltk_data] Downloading package stopwords to /root/nltk_data...
[nltk_data]   Unzipping corpora/stopwords.zip.
[nltk_data] Downloading package wordnet to /root/nltk_data...

df = pd.read_csv("MBTI 500.csv")

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 106067 entries, 0 to 106066
Data columns (total 2 columns):
 #   Column  Non-Null Count   Dtype 
---  ------  --------------   ----- 
 0   posts   106067 non-null  object
 1   type    106067 non-null  object
dtypes: object(2)
memory usage: 1.6+ MB

df

	posts	type
0	know intj tool use interaction people excuse a...	INTJ
1	rap music ehh opp yeah know valid well know fa...	INTJ
2	preferably p hd low except wew lad video p min...	INTJ
3	drink like wish could drink red wine give head...	INTJ
4	space program ah bad deal meing freelance max ...	INTJ
...	...	...
106062	stay frustrate world life want take long nap w...	INFP
106063	fizzle around time mention sure mistake thing ...	INFP
106064	schedule modify hey w intp strong wing underst...	INFP
106065	enfj since january busy schedule able spend li...	INFP
106066	feel like men good problem tell parent want te...	INFP

106067 rows × 2 columns

df.head(5)

	posts	type
0	know intj tool use interaction people excuse a...	INTJ
1	rap music ehh opp yeah know valid well know fa...	INTJ
2	preferably p hd low except wew lad video p min...	INTJ
3	drink like wish could drink red wine give head...	INTJ
4	space program ah bad deal meing freelance max ...	INTJ

df.type.value_counts()

INTP    24961
INTJ    22427
INFJ    14963
INFP    12134
ENTP    11725
ENFP     6167
ISTP     3424
ENTJ     2955
ESTP     1986
ENFJ     1534
ISTJ     1243
ISFP      875
ISFJ      650
ESTJ      482
ESFP      360
ESFJ      181
Name: type, dtype: int64

for i in range(len(df)):
  text = df.loc[i, 'posts']
  text = text.lower() # 소문자 처리
  text = re.sub(pattern, '', text)
  # 단어 토큰화
  tokens = word_tokenize(text)

  # 불용어 제거
  # stop_words = set(stopwords.words('english'))
  filtered_tokens = [word for word in tokens if word not in stop_words]

  # 단어의 원형 복원 (lemmatization)
  lemmatizer = WordNetLemmatizer()
  lemmatized_tokens = [lemmatizer.lemmatize(word) for word in filtered_tokens]

  # 전처리된 텍스트 출력
  processed_text = ' '.join(filtered_tokens)
  df.loc[i,'posts'] = processed_text

# 중복된 행 제거
df.drop_duplicates(subset='posts', keep='first', inplace=True)

# 클래스별 데이터 수 확인
class_counts = df['type'].value_counts()

# 가장 적은 데이터 수 확인
min_class_count = class_counts.min()

# 각 클래스별 데이터 언더샘플링
undersampled_data = pd.DataFrame()

for cls in class_counts.index:
    cls_data = df[df['type'] == cls]
    undersampled_cls_data = resample(cls_data, replace=False, n_samples=min_class_count, random_state=42)
    undersampled_data = pd.concat([undersampled_data, undersampled_cls_data])

# 언더샘플링된 데이터 출력
print(undersampled_data['type'].value_counts())

INTP    181
INTJ    181
INFJ    181
INFP    181
ENTP    181
ENFP    181
ISTP    181
ENTJ    181
ESTP    181
ENFJ    181
ISTJ    181
ISFP    181
ISFJ    181
ESTJ    181
ESFP    181
ESFJ    181
Name: type, dtype: int64

undersampled_data.head(5)

	posts	type
36501	time resus entp intj intp answer truthfully iv...	INTP
32633	dispose fe aim unbiased channel damn good job ...	INTP
31392	people time arrow represent laptop awesome sch...	INTP
47256	achieve success future career choose ditto dif...	INTP
45097	term meditation region brain active wander act...	INTP

undersampled_data = undersampled_data.reset_index(drop=True)

undersampled_data.head(5)

	posts	type
0	time resus entp intj intp answer truthfully iv...	INTP
1	dispose fe aim unbiased channel damn good job ...	INTP
2	people time arrow represent laptop awesome sch...	INTP
3	achieve success future career choose ditto dif...	INTP
4	term meditation region brain active wander act...	INTP

print(len(undersampled_data))

undersampled_data[undersampled_data['type']== "ESTJ"].head(5)

	posts	type
2353	work introvert analytically work logic logical...	ESTJ
2354	ozziechick guess shud post hey kwaran pretty c...	ESTJ
2355	reckon scandinavian country germany fluid term...	ESTJ
2356	realize truth life song ground root case talka...	ESTJ
2357	concrete backfire theory humanity discipline c...	ESTJ

# TF-IDF 벡터화
tfidf_vectorizer = TfidfVectorizer(max_features=500)
X = tfidf_vectorizer.fit_transform(undersampled_data['posts'])
y = undersampled_data['type']

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Random Forest 모델 생성 및 학습
rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)  # 예시로 트리 100개 사용
rf_classifier.fit(X_train, y_train)

# 모델 평가
accuracy = rf_classifier.score(X_test, y_test)
print(f'Accuracy: {accuracy}')

# 학습된 모델 저장
joblib.dump(rf_classifier, 'random_forest_classifier.pkl')
joblib.dump(tfidf_vectorizer, 'tfidf_vectorizer.pkl')

Accuracy: 0.6706896551724137





['tfidf_vectorizer.pkl']

a = list(set(undersampled_data['type'].tolist()))
a

['INFJ',
 'ISFP',
 'ISFJ',
 'ENFJ',
 'ENFP',
 'ISTJ',
 'INTP',
 'ENTP',
 'ISTP',
 'INTJ',
 'ENTJ',
 'ESFP',
 'ESTP',
 'INFP',
 'ESFJ',
 'ESTJ']

estj_posts = undersampled_data[undersampled_data['type'] == 'ESTJ']['posts']
estj = estj_posts.to_list()
estj

from wordcloud import WordCloud, STOPWORDS

fig, ax = plt.subplots(len(undersampled_data['type'].unique()), sharex=True, figsize=(5,5*len(df['type'].unique())))

k = 0
for i in undersampled_data['type'].unique():
    df_4 = undersampled_data[undersampled_data['type'] == i]
    wordcloud = WordCloud().generate(df_4['posts'].to_string())
    ax[k].imshow(wordcloud)
    ax[k].set_title(i)
    ax[k].axis("off")
    k+=1

최다 빈도수 단어들 확인

post_counter = Counter()
for i in undersampled_data['type'].unique():

  new_df =  undersampled_data[undersampled_data['type'] == i]
  text_data = [k.split(" ") for k in new_df['posts'].to_list()]
  # print(text_data)
  # break
  # if i == "ESTJ":
  for d in text_data:
    post_counter = Counter(d)
  print(i,":",post_counter.most_common(10))
  # print(post_counter)

INTP : [('test', 7), ('type', 6), ('intp', 6), ('people', 6), ('function', 5), ('vote', 5), ('feel', 5), ('order', 4), ('point', 4), ('time', 3)]
INTJ : [('thing', 7), ('year', 6), ('state', 5), ('point', 4), ('respect', 4), ('totally', 3), ('people', 3), ('term', 3), ('elect', 3), ('programme', 3)]
INFJ : [('infjs', 6), ('good', 5), ('group', 5), ('fe', 5), ('understand', 4), ('people', 4), ('friend', 4), ('feel', 4), ('point', 3), ('sound', 3)]
INFP : [('people', 10), ('thing', 7), ('time', 6), ('speak', 5), ('feel', 4), ('fe', 4), ('understand', 4), ('good', 4), ('game', 3), ('thought', 3)]
ENTP : [('people', 11), ('bad', 8), ('fe', 6), ('thing', 5), ('care', 4), ('read', 4), ('woman', 4), ('love', 3), ('book', 3), ('post', 3)]
ENFP : [('friend', 6), ('talk', 6), ('enfp', 5), ('thing', 5), ('feel', 5), ('people', 5), ('type', 5), ('good', 4), ('idea', 4), ('social', 4)]
ISTP : [('people', 6), ('job', 5), ('thing', 5), ('talk', 4), ('interview', 4), ('hamas', 4), ('charter', 4), ('pay', 3), ('relationship', 3), ('bad', 3)]
ENTJ : [('people', 6), ('personality', 4), ('test', 4), ('time', 4), ('great', 3), ('friend', 3), ('good', 3), ('person', 3), ('life', 3), ('thing', 3)]
ESTP : [('place', 5), ('people', 4), ('state', 4), ('berlin', 4), ('yeah', 3), ('german', 3), ('nazi', 3), ('germany', 3), ('infj', 3), ('problem', 3)]
ENFJ : [('thing', 6), ('feel', 6), ('fe', 6), ('istp', 5), ('people', 5), ('thought', 4), ('bite', 3), ('bad', 3), ('lot', 3), ('answer', 3)]
ISTJ : [('good', 11), ('time', 8), ('wear', 7), ('pretty', 5), ('question', 5), ('process', 5), ('hat', 5), ('fish', 5), ('experience', 4), ('error', 4)]
ISFP : [('good', 6), ('eye', 4), ('work', 4), ('post', 4), ('people', 4), ('thing', 4), ('action', 4), ('contact', 3), ('share', 3), ('life', 3)]
ISFJ : [('feel', 6), ('isfj', 6), ('love', 5), ('thing', 5), ('listen', 5), ('good', 5), ('fun', 5), ('sensor', 4), ('isfp', 3), ('song', 3)]
ESTJ : [('people', 8), ('det', 7), ('read', 4), ('enjoy', 4), ('time', 4), ('man', 4), ('har', 4), ('på', 3), ('jeg', 3), ('good', 3)]
ESFP : [('fuck', 5), ('decision', 5), ('hand', 4), ('game', 4), ('feel', 3), ('play', 3), ('good', 3), ('memory', 3), ('people', 3), ('buy', 3)]
ESFJ : [('people', 5), ('thing', 5), ('study', 5), ('lol', 4), ('type', 4), ('small', 4), ('day', 4), ('person', 3), ('live', 3), ('life', 3)]

# 'E' (Extraversion)와 'S' (Sensing) 성향을 가진 데이터 추출
e_data = undersampled_data[undersampled_data['type'].str.contains('E')]['posts']
i_data = undersampled_data[undersampled_data['type'].str.contains('I')]['posts']

# 전처리 및 단어 추출 함수 정의
def extract_words(data):
    # CountVectorizer를 사용하여 단어 빈도수 계산
    count_vectorizer = CountVectorizer(stop_words='english')
    count_data = count_vectorizer.fit_transform(data)
    words = count_vectorizer.get_feature_names_out()
    word_frequencies = count_data.toarray().sum(axis=0)
    word_freq_dict = dict(zip(words, word_frequencies))
    return word_freq_dict

# 'E' 성향에 해당하는 단어 추출
e_word_freq = extract_words(e_data)

# 'S' 성향에 해당하는 단어 추출
i_word_freq = extract_words(i_data)

# 'E'와 'S' 성향에서 곂치는 단어 중 빈도수가 가장 높은 상위 5개의 단어 추출
e_common_words = [word for word, _ in Counter(e_word_freq).most_common(10)]
i_common_words = [word for word, _ in Counter(i_word_freq).most_common(10)]

# 'E'와 'S' 성향에서 곂치는 단어를 제외한 단어 추출
e_unique_words = [word for word in e_word_freq if word not in i_common_words]
i_unique_words = [word for word in i_word_freq if word not in e_common_words]

# WordCloud 객체 생성하여 시각화
e_wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies({word: freq for word, freq in e_word_freq.items() if word in e_unique_words})
i_wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies({word: freq for word, freq in i_word_freq.items() if word in i_unique_words})

# 'E' 성향 WordCloud 시각화
plt.figure(figsize=(10, 6))
plt.imshow(e_wordcloud, interpolation='bilinear')
plt.title("WordCloud for 'E' (Extraversion) - Unique Words")
plt.axis('off')
plt.show()

# 'I' 성향 WordCloud 시각화
plt.figure(figsize=(10, 6))
plt.imshow(i_wordcloud, interpolation='bilinear')
plt.title("WordCloud for 'I' (Introversion) - Unique Words")
plt.axis('off')
plt.show()

S와 N의 주요 빈도 단어 시각화

# 'S' (Sensing)와 'N' (Intuition) 성향을 가진 데이터 추출
s_data = undersampled_data[undersampled_data['type'].str.contains('S')]['posts']
n_data = undersampled_data[undersampled_data['type'].str.contains('N')]['posts']

# 전처리 및 단어 추출 함수 정의
def extract_words(data):
    # CountVectorizer를 사용하여 단어 빈도수 계산
    count_vectorizer = CountVectorizer(stop_words='english')
    count_data = count_vectorizer.fit_transform(data)
    words = count_vectorizer.get_feature_names_out()
    word_frequencies = count_data.toarray().sum(axis=0)
    word_freq_dict = dict(zip(words, word_frequencies))
    return word_freq_dict

# 'S' 성향에 해당하는 단어 추출
s_word_freq = extract_words(s_data)

# 'N' 성향에 해당하는 단어 추출
n_word_freq = extract_words(n_data)

# 'S'와 'N' 성향에서 곂치는 단어 중 빈도수가 가장 높은 상위 10개의 단어 추출
s_common_words = [word for word, _ in Counter(s_word_freq).most_common(10)]
n_common_words = [word for word, _ in Counter(n_word_freq).most_common(10)]

# 'S'와 'N' 성향에서 곂치는 단어를 제외한 단어 추출
s_unique_words = [word for word in s_word_freq if word not in n_common_words]
n_unique_words = [word for word in n_word_freq if word not in s_common_words]

# WordCloud 객체 생성하여 시각화
s_wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies({word: freq for word, freq in s_word_freq.items() if word in s_unique_words})
n_wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies({word: freq for word, freq in n_word_freq.items() if word in n_unique_words})

# 'S' 성향 WordCloud 시각화
plt.figure(figsize=(10, 6))
plt.imshow(s_wordcloud, interpolation='bilinear')
plt.title("WordCloud for 'S' (Sensing) - Unique Words")
plt.axis('off')
plt.show()

# 'N' 성향 WordCloud 시각화
plt.figure(figsize=(10, 6))
plt.imshow(n_wordcloud, interpolation='bilinear')
plt.title("WordCloud for 'N' (Intuition) - Unique Words")
plt.axis('off')
plt.show()

'T'와 'F'의 주요 빈도 단어 시각화

# 'F' (Feeling)와 'T' (Thinking) 성향을 가진 데이터 추출
f_data = undersampled_data[undersampled_data['type'].str.contains('F')]['posts']
t_data = undersampled_data[undersampled_data['type'].str.contains('T')]['posts']

# 전처리 및 단어 추출 함수 정의
def extract_words(data):
    # CountVectorizer를 사용하여 단어 빈도수 계산
    count_vectorizer = CountVectorizer(stop_words='english')
    count_data = count_vectorizer.fit_transform(data)
    words = count_vectorizer.get_feature_names_out()
    word_frequencies = count_data.toarray().sum(axis=0)
    word_freq_dict = dict(zip(words, word_frequencies))
    return word_freq_dict

# 'F' 성향에 해당하는 단어 추출
f_word_freq = extract_words(f_data)

# 'T' 성향에 해당하는 단어 추출
t_word_freq = extract_words(t_data)

f_common_words = [word for word, _ in Counter(f_word_freq).most_common(10)]
t_common_words = [word for word, _ in Counter(t_word_freq).most_common(10)]

# 'F', 'T' 성향에서 곂치는 단어를 제외한 단어 추출
f_unique_words = [word for word in f_word_freq if word not in s_common_words + n_common_words + t_common_words]
t_unique_words = [word for word in t_word_freq if word not in s_common_words + n_common_words + f_common_words]

# WordCloud 객체 생성하여 시각화
f_wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies({word: freq for word, freq in f_word_freq.items() if word in f_unique_words})
t_wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies({word: freq for word, freq in t_word_freq.items() if word in t_unique_words})

# 'F' 성향 WordCloud 시각화
plt.figure(figsize=(10, 6))
plt.imshow(f_wordcloud, interpolation='bilinear')
plt.title("WordCloud for 'F' (Feeling) - Unique Words")
plt.axis('off')
plt.show()

# 'T' 성향 WordCloud 시각화
plt.figure(figsize=(10, 6))
plt.imshow(t_wordcloud, interpolation='bilinear')
plt.title("WordCloud for 'T' (Thinking) - Unique Words")
plt.axis('off')
plt.show()

'P'와 'J'의 주요 빈도 단어 시각화

# 'P' (Perceiving)와 'J' (Judging) 성향을 가진 데이터 추출
p_data = undersampled_data[undersampled_data['type'].str.contains('P')]['posts']
j_data = undersampled_data[undersampled_data['type'].str.contains('J')]['posts']

# 전처리 및 단어 추출 함수 정의
def extract_words(data):
    # CountVectorizer를 사용하여 단어 빈도수 계산
    count_vectorizer = CountVectorizer(stop_words='english')
    count_data = count_vectorizer.fit_transform(data)
    words = count_vectorizer.get_feature_names_out()
    word_frequencies = count_data.toarray().sum(axis=0)
    word_freq_dict = dict(zip(words, word_frequencies))
    return word_freq_dict

# 'P' 성향에 해당하는 단어 추출
p_word_freq = extract_words(p_data)

# 'J' 성향에 해당하는 단어 추출
j_word_freq = extract_words(j_data)

# 'P'와 'J' 성향에서 곂치는 단어 중 빈도수가 가장 높은 상위 10개의 단어 추출
p_common_words = [word for word, _ in Counter(p_word_freq).most_common(10)]
j_common_words = [word for word, _ in Counter(j_word_freq).most_common(10)]

# 'P'와 'J' 성향에서 곂치는 단어를 제외한 단어 추출
p_unique_words = [word for word in p_word_freq if word not in j_common_words]
j_unique_words = [word for word in j_word_freq if word not in p_common_words]

# WordCloud 객체 생성하여 시각화
p_wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies({word: freq for word, freq in p_word_freq.items() if word in p_unique_words})
j_wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies({word: freq for word, freq in j_word_freq.items() if word in j_unique_words})

# 'P' 성향 WordCloud 시각화
plt.figure(figsize=(10, 6))
plt.imshow(p_wordcloud, interpolation='bilinear')
plt.title("WordCloud for 'P' (Perceiving) - Unique Words")
plt.axis('off')
plt.show()

# 'J' 성향 WordCloud 시각화
plt.figure(figsize=(10, 6))
plt.imshow(j_wordcloud, interpolation='bilinear')
plt.title("WordCloud for 'J' (Judging) - Unique Words")
plt.axis('off')
plt.show()

vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(undersampled_data['posts'])

# 클러스터링 (K-means)
kmeans = KMeans(n_clusters=5)  # 클러스터 개수 설정
kmeans.fit(X)

# 차원 축소 (PCA)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X.toarray())

# 시각화
undersampled_data['cluster'] = kmeans.labels_
undersampled_data['pca1'] = X_pca[:, 0]
undersampled_data['pca2'] = X_pca[:, 1]

plt.figure(figsize=(10, 6))

# MBTI 유형에 따른 색상 지정
mbti_colors = {'INTJ': 'red', 'ENTP': 'blue', 'INTP': 'green', 'ENTJ': 'orange', 'INFJ': 'purple',
               'ENFJ': 'yellow', 'INFP': 'brown', 'ENFP': 'pink', 'ISTJ': 'gray', 'ISFJ': 'cyan',
               'ESTJ': 'olive', 'ESFJ': 'magenta'}

for mbti_type, color in mbti_colors.items():
    temp_df = undersampled_data[undersampled_data['type'] == mbti_type]
    plt.scatter(temp_df['pca1'], temp_df['pca2'], c=color, label=mbti_type, alpha=0.5)

plt.title('Clustering Visualization by MBTI Type')
plt.xlabel('PCA Component 1')
plt.ylabel('PCA Component 2')
plt.legend()
plt.show()

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  warnings.warn(

# TF-IDF 벡터 생성
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(undersampled_data['posts'])

# t-SNE를 사용하여 2차원으로 축소하여 각 MBTI 유형별로 시각화
mbti_types = undersampled_data['type'].unique()

plt.figure(figsize=(12, 8))

for mbti_type in mbti_types:
    # 해당 MBTI 유형에 해당하는 데이터 추출
    temp_df = undersampled_data[undersampled_data['type'] == mbti_type]

    # TF-IDF 벡터화
    X_mbti = vectorizer.transform(temp_df['posts'])

    # t-SNE를 사용하여 2차원으로 축소
    tsne = TSNE(n_components=2, random_state=200)
    X_tsne = tsne.fit_transform(X_mbti.toarray())

    # 시각화
    plt.scatter(X_tsne[:, 0], X_tsne[:, 1], label=mbti_type, alpha=0.5)

plt.title('t-SNE Visualization by MBTI Types')
plt.xlabel('t-SNE Component 1')
plt.ylabel('t-SNE Component 2')
plt.legend()
plt.show()

# 특성 추출 (TF-IDF 활용)
tfidf_vectorizer = TfidfVectorizer(max_features=2300)  # TF-IDF 벡터화
X = tfidf_vectorizer.fit_transform(undersampled_data['posts'])  # 텍스트 데이터를 TF-IDF 특성으로 변환
y = undersampled_data['type']  # MBTI 유형 (타겟)

# 데이터 분할 (훈련 데이터와 테스트 데이터)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 훈련 (SVM 분류기 사용 예시)
svm_classifier = SVC(kernel='linear')  # SVM 모델 생성
svm_classifier.fit(X_train, y_train)  # 모델 훈련
# 학습된 모델을 파일로 저장
joblib.dump(svm_classifier, 'svm_classifier.pkl')

# 모델 평가
predictions = svm_classifier.predict(X_test)  # 테스트 데이터 예측
accuracy = accuracy_score(y_test, predictions)  # 정확도 계산
print(f'Accuracy: {accuracy}')

# 분류 보고서 출력
print(classification_report(y_test, predictions))

Accuracy: 0.7172413793103448
              precision    recall  f1-score   support

        ENFJ       0.73      0.75      0.74        36
        ENFP       0.74      0.85      0.79        34
        ENTJ       0.77      0.62      0.69        32
        ENTP       0.62      0.68      0.65        31
        ESFJ       0.97      0.74      0.84        43
        ESFP       0.76      0.74      0.75        34
        ESTJ       0.97      0.78      0.86        40
        ESTP       0.90      0.83      0.86        42
        INFJ       0.77      0.61      0.68        49
        INFP       0.52      0.71      0.60        31
        INTJ       0.47      0.74      0.58        38
        INTP       0.66      0.68      0.67        34
        ISFJ       0.82      0.76      0.79        37
        ISFP       0.47      0.75      0.58        24
        ISTJ       0.74      0.59      0.66        34
        ISTP       0.82      0.66      0.73        41

    accuracy                           0.72       580
   macro avg       0.73      0.72      0.72       580
weighted avg       0.75      0.72      0.72       580

import joblib
from sklearn.feature_extraction.text import TfidfVectorizer

# 임의의 텍스트 데이
new_text = ["In the realm of intellect and innovation, certain individuals possess an innate ability to envision the future, dissect complex problems, and engineer innovative solutions. These individuals exhibit a unique blend of analytical prowess, strategic thinking, and a relentless pursuit of knowledge. Their visionary mindset is characterized by an insatiable curiosity and a deep understanding of underlying patterns. They excel in dissecting intricate systems, identifying inefficiencies, and architecting solutions that push the boundaries of conventional thinking. Moreover, these individuals are driven by a passion for continuous improvement. They meticulously gather information, analyze data, and meticulously plan their actions, ensuring that every decision aligns with their long-term goals. Their independent and analytical nature often leads them to question established norms, challenge conventions, and seek unconventional pathways. They value autonomy and are not afraid to stand apart from the crowd in pursuit of their vision. Furthermore, their confidence in their ideas coupled with their ability to foresee potential outcomes aids them in making informed decisions. They possess a rare ability to foresee obstacles and plan contingencies in advance. In summary, individuals embodying these traits operate as strategic visionaries in their fields, steering through complexity with precision and constantly seeking innovative solutions that shape the future.",
            "I like making plans and I like animals. And he is very empathetic and likes to hang out with people.",
            "I like making plans and I prefer hang out with under 3 people. Many people who is stupid makes me mad. I love playing games alone in my home",
            "You are a stable and reliable individual. You tend to be pragmatic, organized, and systematic in handling tasks. Additionally, you pay attention to details and value real-life experiences and facts. You have a strong adaptability to change and enjoy taking responsibility and doing your best in the tasks assigned to you."]
# 불러온 학습된 모델
loaded_model = joblib.load('svm_classifier.pkl')

# TF-IDF 벡터화
tfidf_vectorizer = TfidfVectorizer(max_features=2300)
tfidf_vectorizer.fit(undersampled_data['posts'])
# 기존에 학습된 TF-IDF 벡터화 모델 사용하여 새로운 데이터 벡터화


X_new = tfidf_vectorizer.transform(new_text)


# 예측
predictions_new = loaded_model.predict(X_new)

# 결과 출력
for text, prediction in zip(new_text, predictions_new):
    print(f"Text: {text}")
    print(f"Predicted MBTI Type: {prediction}")
    print("--------------")

Text: In the realm of intellect and innovation, certain individuals possess an innate ability to envision the future, dissect complex problems, and engineer innovative solutions. These individuals exhibit a unique blend of analytical prowess, strategic thinking, and a relentless pursuit of knowledge. Their visionary mindset is characterized by an insatiable curiosity and a deep understanding of underlying patterns. They excel in dissecting intricate systems, identifying inefficiencies, and architecting solutions that push the boundaries of conventional thinking. Moreover, these individuals are driven by a passion for continuous improvement. They meticulously gather information, analyze data, and meticulously plan their actions, ensuring that every decision aligns with their long-term goals. Their independent and analytical nature often leads them to question established norms, challenge conventions, and seek unconventional pathways. They value autonomy and are not afraid to stand apart from the crowd in pursuit of their vision. Furthermore, their confidence in their ideas coupled with their ability to foresee potential outcomes aids them in making informed decisions. They possess a rare ability to foresee obstacles and plan contingencies in advance. In summary, individuals embodying these traits operate as strategic visionaries in their fields, steering through complexity with precision and constantly seeking innovative solutions that shape the future.
Predicted MBTI Type: ENTJ
--------------
Text: I like making plans and I like animals. And he is very empathetic and likes to hang out with people.
Predicted MBTI Type: INTJ
--------------
Text: I like making plans and I prefer hang out with under 3 people. Many people who is stupid makes me mad. I love playing games alone in my home
Predicted MBTI Type: ISTP
--------------
Text: You are a stable and reliable individual. You tend to be pragmatic, organized, and systematic in handling tasks. Additionally, you pay attention to details and value real-life experiences and facts. You have a strong adaptability to change and enjoy taking responsibility and doing your best in the tasks assigned to you.
Predicted MBTI Type: ISTJ
--------------

MBTI.ipynb

5.65MB

프로그래머스 level2 의상 - python

Shine_sunho — Wed, 29 Nov 2023 21:12:40 +0900

의상

문제 설명

코니는 매일 다른 옷을 조합하여 입는것을 좋아합니다.

예를 들어 코니가 가진 옷이 아래와 같고, 오늘 코니가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야합니다.

종류	이름
얼굴	동그란 안경, 검정 선글라스
상의	파란색 티셔츠
하의	청바지
겉옷	긴 코트

코니는 각 종류별로 최대 1가지 의상만 착용할 수 있습니다. 예를 들어 위 예시의 경우 동그란 안경과 검정 선글라스를 동시에 착용할 수는 없습니다.
착용한 의상의 일부가 겹치더라도, 다른 의상이 겹치지 않거나, 혹은 의상을 추가로 더 착용한 경우에는 서로 다른 방법으로 옷을 착용한 것으로 계산합니다.
코니는 하루에 최소 한 개의 의상은 입습니다.
코니가 가진 의상들이 담긴 2차원 배열 clothes가 주어질 때 서로 다른 옷의 조합의 수를 return 하도록 solution 함수를 작성해주세요.

제한사항

clothes의 각 행은 [의상의 이름, 의상의 종류]로 이루어져 있습니다.
코니가 가진 의상의 수는 1개 이상 30개 이하입니다.
같은 이름을 가진 의상은 존재하지 않습니다.
clothes의 모든 원소는 문자열로 이루어져 있습니다.
모든 문자열의 길이는 1 이상 20 이하인 자연수이고 알파벳 소문자 또는 '_' 로만 이루어져 있습니다.

입출력 예

clothes	return
[["yellow_hat", "headgear"], ["blue_sunglasses", "eyewear"], ["green_turban", "headgear"]]	5
[["crow_mask", "face"], ["blue_sunglasses", "face"], ["smoky_makeup", "face"]]	3

입출력 예 설명

예제 #1

headgear에 해당하는 의상이 yellow_hat, green_turban이고 eyewear에 해당하는 의상이 blue_sunglasses이므로 아래와 같이 5개의 조합이 가능합니다.

yellow_hat
blue_sunglasses
green_turban
yellow_hat + blue_sunglasses
green_turban + blue_sunglasses

예제 #2

face에 해당하는 의상이 crow_mask, blue_sunglasses, smoky_makeup이므로 아래와 같이 3개의 조합이 가능합니다.

crow_mask
blue_sunglasses
smoky_makeup

문제 풀이

def solution(clothes):
    answer = 1
    clothes_closet = {}
    for i in range(len(clothes)):
        cloth = clothes[i][0]
        types = clothes[i][1]
        if types not in clothes_closet:
            clothes_closet[types] = 0
            clothes_closet[types] +=1
        else:
            clothes_closet[types] +=1
    for i in clothes_closet.values():
        answer = answer * (i+1)
    answer -=1
    # 한종류에 있는 수를 n이라 뽑는 경우의수
    # (n+1) * (n1+1) * (n2+1)- 1

    return answer

프로그래머스 level2 [2019 카카오 개발자 겨울 인턴십]튜플 - python

Shine_sunho — Thu, 23 Nov 2023 13:07:19 +0900

튜플

문제 설명

셀수있는 수량의 순서있는 열거 또는 어떤 순서를 따르는 요소들의 모음을 튜플(tuple)이라고 합니다. n개의 요소를 가진 튜플을 n-튜플(n-tuple)이라고 하며, 다음과 같이 표현할 수 있습니다.

(a1, a2, a3, ..., an)
튜플은 다음과 같은 성질을 가지고 있습니다.

중복된 원소가 있을 수 있습니다. ex : (2, 3, 1, 2)
원소에 정해진 순서가 있으며, 원소의 순서가 다르면 서로 다른 튜플입니다. ex : (1, 2, 3) ≠ (1, 3, 2)
튜플의 원소 개수는 유한합니다.

원소의 개수가 n개이고, 중복되는 원소가 없는 튜플 (a1, a2, a3, ..., an)이 주어질 때(단, a1, a2, ..., an은 자연수), 이는 다음과 같이 집합 기호 '{', '}'를 이용해 표현할 수 있습니다.

{{a1}, {a1, a2}, {a1, a2, a3}, {a1, a2, a3, a4}, ... {a1, a2, a3, a4, ..., an}}

예를 들어 튜플이 (2, 1, 3, 4)인 경우 이는

{{2}, {2, 1}, {2, 1, 3}, {2, 1, 3, 4}}

와 같이 표현할 수 있습니다. 이때, 집합은 원소의 순서가 바뀌어도 상관없으므로

{{2}, {2, 1}, {2, 1, 3}, {2, 1, 3, 4}}
{{2, 1, 3, 4}, {2}, {2, 1, 3}, {2, 1}}
{{1, 2, 3}, {2, 1}, {1, 2, 4, 3}, {2}}

는 모두 같은 튜플 (2, 1, 3, 4)를 나타냅니다.

특정 튜플을 표현하는 집합이 담긴 문자열 s가 매개변수로 주어질 때, s가 표현하는 튜플을 배열에 담아 return 하도록 solution 함수를 완성해주세요.

[제한사항]

s의 길이는 5 이상 1,000,000 이하입니다.
s는 숫자와 '{', '}', ',' 로만 이루어져 있습니다.
숫자가 0으로 시작하는 경우는 없습니다.
s는 항상 중복되는 원소가 없는 튜플을 올바르게 표현하고 있습니다.
s가 표현하는 튜플의 원소는 1 이상 100,000 이하인 자연수입니다.
return 하는 배열의 길이가 1 이상 500 이하인 경우만 입력으로 주어집니다.

[입출력 예]

s	result
"{{2},{2,1},{2,1,3},{2,1,3,4}}"	[2, 1, 3, 4]
"{{1,2,3},{2,1},{1,2,4,3},{2}}"	[2, 1, 3, 4]
"{{20,111},{111}}"	[111, 20]
"{{123}}"	[123]
"{{4,2,3},{3},{2,3,4,1},{2,3}}"	[3, 2, 4, 1]

입출력 예에 대한 설명

입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

문제 예시와 같습니다.

입출력 예 #3

(111, 20)을 집합 기호를 이용해 표현하면 {{111}, {111,20}}이 되며, 이는 {{20,111},{111}}과 같습니다.

입출력 예 #4

(123)을 집합 기호를 이용해 표현하면 {{123}} 입니다.

입출력 예 #5

(3, 2, 4, 1)을 집합 기호를 이용해 표현하면 {{3},{3,2},{3,2,4},{3,2,4,1}}이 되며, 이는 {{4,2,3},{3},{2,3,4,1},{2,3}}과 같습니다.

문제 풀이

def solution(s):
    answer = []
    s = s[2:-2]
    s = s.split("},{")
    # print(s)
    s.sort(key=len)

    for i in s:
        new_text = i.split(",")
        # print(new_text)
        for i in new_text:
            if int(i) not in answer:
                answer.append(int(i))
    # print(answer)
    return answer

문제 해석

문자열을 얼마나 잘 다루냐에 대한 문제인거 같습니다. 이에 따라 split을 통해 문자열을 분해한 후, sort(key = len)을 통해 리스트 안 문자열 길이에 따라 정렬을 진행했습니다. 이후, 각 원소에 맞춰 처음보는 원소인경우 answer list에 추가하며 답을 도출했습니다.

캡스톤디자인 회고 및 프로젝트 정리 5장 - 마무리 -

Shine_sunho — Thu, 9 Nov 2023 14:29:43 +0900

캡스톤디자인 회고 및 프로젝트 정리 4장

캡스톤디자인 회고 및 프로젝트 정리 3장 캡스톤디자인 회고 및 프로젝트 정리 2장 캡스톤디자인 프로젝트를 구성하기 위해 먼저 주기적인 회의 및 소통을 통해 팀 프로젝트의 진행방향을 잡아

sunho99.tistory.com

해당 글은 4장에 이어 추가적으로 작성을 하고 있습니다. 과정을 보고 싶으신 분은 1장부터 차례대로 보시면 될 것 같습니다.

4장까지 코드를 진행하며 프로젝트를 마무리 할 수 있었습니다. 이후 프로젝트에 대한 과정과 그 결과에 대해 얘기하고자 합니다.

캡스톤디자인 최종발표회에 참석하여 부스를 운영하며 부스에 참가하는 사람들에게 진행과정과 아키텍처 설계방향에 대해 설명을 하며 참석자에 대한 이해를 높이는데 노력했습니다.

또한 교수님들과의 평가에 대해 높은 점수를 받아 캡스톤 조에서 우수작품에 선정되어 다른 조들과 함께 외부인분들과 교수님들 앞에서 추가 발표를 진행했습니다.

해당 발표를 진행하면서 저희가 사용했던 기술들을 발표를 통해 정리하며 저희팀이 진행했던 과정과 프로젝트의 추친방향 이점, 강점, 기술 등을 명확히 이해하는 과정을 갖었습니다.

약 4달 동안 프로젝트를 진행하며 수상을 목표로 진행했던 팀 단위 프로젝트는 교수님들의 평가와 외부인의 평가에 있어 좋은 점수를 받을 수 있었고 약 50팀이 참가하는 졸업작품, 캡스톤디자인에서 장려상을 수상하는 긍정적인 결과를 도출했습니다.

4달 동안 프로젝트를 진행하며 일정관리 및 계획을 자세히 정하는 것이 긴 시간동안 프로젝트를 효과적으로 수행하는데 큰 도움이 된 것 같습니다. Notion을 사용하여 일정관리를 진행했으며, 주기적인 소통을 통해 팀 진행 프로세스를 공유하며 협업을 하는데 효율을 올렸습니다.

또한 교내에서 진행하는 모여서각자코딩 프로그램에 참여하며 개발 능력을 키우는 것 또한 프로젝트를 성공적으로 마무리하는데 도움이 된것 같습니다.

Notion

지금까지 관심을 갖고 긴 글을 읽어준 분들께 감사의 인사를 전하며 궁금하신 내용이 있으면 댓글 달아주시면 감사하겠습니다.

감사합니다.

캡스톤디자인 회고 및 프로젝트 정리 4장

Shine_sunho — Thu, 9 Nov 2023 14:11:32 +0900

캡스톤디자인 회고 및 프로젝트 정리 3장

캡스톤디자인 회고 및 프로젝트 정리 2장 캡스톤디자인 프로젝트를 구성하기 위해 먼저 주기적인 회의 및 소통을 통해 팀 프로젝트의 진행방향을 잡아갔습니다. 먼저 캡스톤 디자인주제를 선정

sunho99.tistory.com

해당 글은 3장에 이어 추가적으로 작성을 하고 있습니다. 과정을 보고 싶으신 분은 1장부터 차례대로 보시면 될 것 같습니다.

3장까지 진행한 결과를 요약하자면 서울시 실시간 인구 데이터를 바탕으로 인구예측 모델을 통해 인구 혼잡 정보를 사용자에게 제공했습니다. 인구데이터에 대해 '왜 사람들이 특정 지역에 모이는가?' 라는 의문을 가질 수 있는데 해당 궁금증을 해소하기 위해 지역별 트렌드를 분석하여 제공하도록 했습니다.

위는 모바일 어플리케이션 설계도 입니다. 저희 팀은 트렌드 분석을 위해 게시물 기능을 추가하여 저희가 갖고있는 카페와 문화 데이터에 게시물을 작성할 수 있도록 하였습니다.

사용자는 지역별 위치하고 있는 카페 정보와 문화 정보에 대해 마커 UI를 통해 정보를 접할 수 있습니다. 이를 통해 사용자는 해당 장소에 대해 정보를 확인할 수 있으며, 추가적으로 해당 장소에 대한 소비를 진행했다면, SNS 형식으로 게시물을 작성할 수 있도록 했습니다.

해당 예시 데이터처럼 카멜 커피라는 장소에 대해 게시물을 작성할 수 있는데 해당 카멜 커피가 어떤 특정 지역(ex) 성수 카페거리)에 포함되어 있는지 ERD 설계 및 데이터베이스 구축을 통해 지역별 게시물 데이터를 확보 할 수 있었습니다.

해당 데이터베이스를 이용하여 query문을 통해 지역에 대한 게시물데이터를 확보 할 수 있었습니다. 다음 이미지는 진행 과정입니다.

사용자가 게시물을 작성하면 해당 게시물은 RDS에 적재하게 되며, EC2에서 RDS와 연동을 하고 query를 통해 데이터를 추출합니다. 해당 데이터를 바탕으로 자연어 처리 오픈소스인 soynlp를 사용하여 wordcloud를 진행했습니다. 이때 사용자 게시물을 가져오는 것은 상당히 주관적인 정보를 포함하고 있으므로, 뉴스 데이터를 같이 접목하여 주관적인 데이터에 객관적인 정보를 더했습니다.

import time

import pymysql
import csv
import pandas as pd
from konlpy.tag import Okt
from soynlp.normalizer import *
from wordcloud import WordCloud
import matplotlib.pyplot as plt
import matplotlib as mpl
from collections import Counter
import re
import numpy as np
from PIL import Image
import boto3
import io
import os
import schedule
from bs4 import BeautifulSoup as bs
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
import pandas as pd
import requests



def job():
    try:
        # S3 클라이언트 생성
        s3 = boto3.client('s3', aws_access_key_id="AKI####U", aws_secret_access_key="/ZMZI7E###")


        host = 'sesohaeng.cf3###t.ap-northeast-2.rds.amazonaws.com'
        user = 'sesohaeng'
        port = 3306
        password = 'ssh-##0'
        database = 'sesohaeng_db'

        conn = pymysql.connect(host=host,port=port,user=user, password=password, database=database)
        cursor = conn.cursor()
        # feed,place,area
        query = "SELECT area_name,content FROM place LEFT JOIN feed ON place.id = feed.place_id JOIN area ON place.area_id = area.id WHERE length(content)>=1"
        cursor.execute(query) # 쿼리 실행
        results = cursor.fetchall()
        # CSV 파일로 저장
        csv_filename = 'query_results.csv'
        with open(csv_filename, 'w', newline='') as csv_file:
            csv_writer = csv.writer(csv_file)
            csv_writer.writerow([i[0] for i in cursor.description])  # 헤더 생성
            csv_writer.writerows(results)
        # 연결 종료
        cursor.close()
        conn.close()

        df = pd.read_csv("/home/ubuntu/wordcloud/query_results.csv")
        combined_reviews = df.groupby('area_name')['content'].apply(list).reset_index()

        for index, row in combined_reviews.iterrows():
            area_name = row['area_name']
            chrome_options = webdriver.ChromeOptions()
            chrome_options.add_argument("--headless")
            # linux 환경에서 필요한 option
            chrome_options.add_argument('--no-sandbox')
            chrome_options.add_argument('--disable-dev-shm-usage')
           #options.add_argument("--disable-blink-features=AutomationControlled")

            #options.add_experimental_option("excludeSwitches", ["enable-automation"])
            #options.add_experimental_option("useAutomationExtension", False)
            #options.add_experimental_option("prefs", {"prfile.managed_default_content_setting.images": 2})
            driver = webdriver.Chrome(
            executable_path='chromedriver',chrome_options=chrome_options)

            area_name = row['area_name']
            url = 'https://news.google.com/?hl=ko&gl=KR&ceid=KR%3Ako'
            driver.get(url)
            driver.implicitly_wait(3)
            keywords = area_name
            search = driver.find_element(By.XPATH,
                                     '//*[@id="gb"]/div[2]/div[2]/div/form/div[1]/div/div/div/div/div[1]/input[2]')

            search.send_keys(keywords)
            search.send_keys(Keys.ENTER)
            driver.implicitly_wait(30)
            url = driver.current_url
            resp = requests.get(url)
            soup = bs(resp.text, 'lxml')

            titles = [] # new 제목

            for link in soup.select('h3 >a'):
                href = 'https://news.google.com' + link.get('href')[1:]
                title = link.string
                titles.append(title)
            driver.quit()
            review_data = row['content']
            if len(review_data) < 10:
                continue
            total_reviews = []
            for review in review_data:
                total_reviews.append(review)
            okt = Okt()
            total_reviews = total_reviews + titles
            normalization_total_review = []

            # 문장 이상한거 수정 및 정규화 진행 전처리
            for review in total_reviews:  # 긍정리뷰
                pattern = '([ㄱ-ㅎㅏ-ㅣ]+)'  # 한글 자음, 모음 제거
                review = re.sub(pattern=pattern, repl='', string=review)
                pattern = '<[^>]*>'  # HTML 태그 제거
                review = re.sub(pattern=pattern, repl='', string=review)
                pattern = '[^\w\s\n]'  # 특수기호제거
                review = re.sub(pattern=pattern, repl='', string=review)
                clean_review = emoticon_normalize(review, num_repeats=3)  # 반복되는 이모티콘 정리 최대 3회
                clean_review = repeat_normalize(clean_review, num_repeats=3)  # 반복되는 문구 정리 최대 3회
                clean_review = only_hangle(clean_review)  # 리뷰중 영어 제외
                clean_review = okt.normalize(clean_review)  # 정리
                normalization_total_review.append(clean_review)

            pos_reviews = []
            for review in normalization_total_review:  # 형태소 분석
                clean_review = okt.pos(review, stem=True, join=True)

                pos_reviews.append(clean_review)
                # {'Adjective': '형용사',
                #  'Adverb': '부사',
                #  'Alpha': '알파벳',
                #  'Conjunction': '접속사',
                #  'Determiner': '관형사',
                #  'Eomi': '어미',
                #  'Exclamation': '감탄사',
                #  'Foreign': '외국어, 한자 및 기타기호',
                #  'Hashtag': '트위터 해쉬태그',
                #  'Josa': '조사',
                #  'KoreanParticle': '(ex: ㅋㅋ)',
                #  'Noun': '명사',
                #  'Number': '숫자',
                #  'PreEomi': '선어말어미',
                #  'Punctuation': '구두점',
                #  'ScreenName': '트위터 아이디',
                #  'Suffix': '접미사',
                #  'Unknown': '미등록어',
                #  'Verb': '동사'}
            tag_reviews = []
            for i in pos_reviews:  # 형용사 , 명사 가져오기
                for j in i:
                    text_tag = j.split("/")  # '편리하다/Adjective'
                    if  text_tag[1] == "Noun":
                        tag_reviews.append(text_tag[0])

            # 가장 많이 나온 단어부터 30개를 저장한다.
            count_tag_reviews = Counter(tag_reviews)
            tags = count_tag_reviews.most_common(50)
            # WordCloud를 생성한다.
            # 한글을 분석하기위해 font를 한글로 지정해주어야 된다. macOS는 .otf , window는 .ttf 파일의 위치를
            # 지정해준다. (ex. '/Font/GodoM.otf')
            masking_image = np.array(Image.open("/home/ubuntu/wordcloud/img2.png"))
            wc = WordCloud(font_path="/usr/share/fonts/truetype/nanum/NanumGothic.ttf",
                       random_state=123, background_color="white", max_font_size=200, max_words=30,
                       width=2000, height=1000,
                       mask=masking_image,  # masking
                       colormap='rainbow'
                       )

            cloud = wc.generate_from_frequencies(dict(tags))

            # 생성된 WordCloud를 test.jpg로 보낸다.
            cloud.to_file("%s.jpg"%area_name)
            plt.rcParams["font.family"] = 'NanumGothic' # 한글 폰트 적용
            mpl.rcParams['axes.unicode_minus'] = False
            plt.figure(figsize=(10, 10))
            plt.axis('off')
            plt.imshow(cloud, interpolation='bilinear')
            #plt.title("%s 트랜드"%area_name)
            plt.savefig("%s.jpg" % area_name) # 각 구에 맞는 나이 비율 이미지

            plt.close()

            output_filename = "%s.jpg" % area_name
            file_name = output_filename

            file_path = os.path.realpath(output_filename)
            # # # S3 버킷 이름과 업로드할 객체 키를 지정합니다.
            bucket_name = 'mlops-models-bucket'
            object_key = "wordcloud/" + "%s/" % area_name + file_name
            # 로컬 파일을 S3에 업로드합니다.
            s3.upload_file(file_path, bucket_name, object_key)
    except ValueError:
            pass
schedule.every(5).minutes.do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

query문을 통해 데이터를 조회하며 해당 데이터를 가져오고 이를 wordcloud로 표현하는 코드입니다. 이때 추가적으로 뉴스데이터를 합쳐 진행합니다.

from bs4 import BeautifulSoup as bs
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
import pandas as pd
import requests

options = webdriver.ChromeOptions()
options.add_argument("--disable-blink-features=AutomationControlled")

options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option("useAutomationExtension", False)
options.add_experimental_option("prefs", {"prfile.managed_default_content_setting.images": 2})
driver = webdriver.Chrome(executable_path='/Users/sunho99/PycharmProjects/python_Project/캡스톤디자인/wordcloud_test/chromedriver', options=options)


keyword_data = []
url = 'https://news.google.com/?hl=ko&gl=KR&ceid=KR%3Ako'
driver.get(url)
driver.implicitly_wait(3)
keywords = input('Search keyword: ')
search = driver.find_element(By.XPATH,'//*[@id="gb"]/div[2]/div[2]/div/form/div[1]/div/div/div/div/div[1]/input[2]')

search.send_keys(keywords)
search.send_keys(Keys.ENTER)
driver.implicitly_wait(30)
url = driver.current_url
resp = requests.get(url)
soup = bs(resp.text, 'lxml')

titles = []

for link in soup.select('h3 >a'):
    href = 'https://news.google.com' + link.get('href')[1:]
    title = link.string
    titles.append(title)

print(titles)

해당 데이터를 통해 뉴스 헤드라이드 기사를 가져오며 데이터를 합쳐 wordcloud를 진행했습니다.

그 결과 지역별로 다른 키워드들이 추출됐으며 이를 통해 지역별 트렌드 및 특징을 사용자가 확인 할 수 있었습니다.

창덕궁, 종묘 wordcloud

성수 카페거리 wordcloud

이를 통해 지역별 특징이 분리되어 나타났으며, 소비자는 해당 인구가 왜 모이는지에 대한 의문을 해소 할 수 있었습니다. 당시 프로젝트를 진행하면서 카드사 소비데이터를 바탕으로 지역별 특징을 나타내려 했는데, 앱 특성상 실시간으로 정보를 제공하는 취지에 있어 실시간 소비데이터를 구할 수 없다는 문제점에 직면하여 위 프로세스로 진행을 했습니다.

또한 현재 많이 작성되고 있는 게시물 순위를 UI를 통해 보여주며 MZ 세대의 '디깅 소비' 욕구를 증진시켰습니다.

이를 통해 사용자는 인구데이터와 지역별 트렌드를 확인할 수 있었습니다.

캡스톤디자인 회고 및 프로젝트 정리 3장

Shine_sunho — Thu, 9 Nov 2023 13:50:20 +0900

캡스톤디자인 회고 및 프로젝트 정리 2장

캡스톤디자인 프로젝트를 구성하기 위해 먼저 주기적인 회의 및 소통을 통해 팀 프로젝트의 진행방향을 잡아갔습니다. 먼저 캡스톤 디자인주제를 선정하기에 있어 상당히 많은 노력과 리서치

sunho99.tistory.com

해당 글은 2장에 이어 추가적으로 작성을 하고 있습니다. 과정을 보고 싶으신 분은 1장부터 차례대로 보시면 될 것 같습니다.

2장에서 API 통신을 통해 1시간마다 데이터를 적재하며 시계열 데이터를 구축했습니다. 해당 데이터를 바탕으로 Prophet 모델을 사용하여 인구 모델 데이터 예측을 진행했습니다.

import pandas as pd
import numpy as np
from prophet import Prophet
from datetime import datetime, timedelta
import holidays
import os
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
import boto3
from matplotlib import rc, font_manager
# from sklearn.metrics import mean_absolute_error, mean_absolute_percentage_error
import matplotlib as mpl
import io
import schedule
import time


# def job():
# S3 버킷 및 파일 경로
bucket_name = 'mlops-api-output'
file_key = '2023/2023.csv'

# S3 클라이언트 생성
s3 = boto3.client('s3', aws_access_key_id="AKI###", aws_secret_access_key="/ZMZI7###")

# CSV 파일 다운로드 및 읽기
response = s3.get_object(Bucket=bucket_name, Key=file_key)
df = pd.read_csv(io.BytesIO(response["Body"].read()))

df_index_list = df.index
df.insert(0,"지역",df_index_list)
df_reset= df.reset_index(drop=True)
df_reset['PPLTN_TIME']=df_reset['PPLTN_TIME'].apply(lambda _ : datetime.strptime(_,'%Y-%m-%d %H:%M'))
df_reset['PPLTN_TIME'] = df_reset['PPLTN_TIME'].dt.strftime('%Y-%m-%d %H:00:00')
local_list = df_reset["지역"].unique()


# 한국 휴일 객체 생성
kr_holidays = holidays.KR()
df_reset['holiday'] = df_reset.PPLTN_TIME.apply(lambda x: True if x in kr_holidays else False)
df = df_reset.rename(columns={'PPLTN_TIME': 'ds', 'AREA_PPLTN_MAX': 'y'})
df['ds'] = pd.to_datetime(df['ds'])


for i in local_list:

    plt.clf() # plt 초기화
    local_df = df["지역"] == "광화문·덕수궁"  # "지역" column에서 "경복궁" 값을 가지고 있는 행 추출
    print(i)
    filtered_local_df = df[local_df]


    # 날짜를 기준으로 정렬
    filtered_local_df = filtered_local_df.sort_values('ds', ascending=False)

    # 오늘 날짜 가져오기
    # latest_date = filtered_local_df.iloc[0]['ds']
    today = datetime.today().strftime("%Y-%m-%d 00:00:00")
    latest_date = datetime.today().strptime(today, "%Y-%m-%d 00:00:00")

    # 최근 n 일 동안의 데이터 선택
    start_date = latest_date - timedelta(days=30)

    new_df = filtered_local_df[filtered_local_df['ds'] >= start_date]

    test_day = latest_date
    new_df = new_df[new_df['ds'] <= test_day]

    # print(df['ds'])
    new_df = new_df.sort_values('ds', ascending=True)
    model = Prophet(
                #Trend
                growth="linear",
                changepoints=None,
                n_changepoints=10,
                changepoint_range=1,
                changepoint_prior_scale=0.5,
                interval_width=0.95,

                #Holiday
                holidays=None)
    model.fit(new_df)
    # 미래 예측 생성
    future = model.make_future_dataframe(freq="H",periods=24)
    # print(future)
    # 미래 예측
    forecast = model.predict(future)

    test_day = latest_date
    start_day = test_day - timedelta(days=1)

    test = new_df[new_df['ds'] > start_day]

    train = forecast[forecast['ds'] <= test_day]
    train = train[train['ds'] > start_day]
    # print(train)
    # print(train.info())

    predict = forecast[forecast['ds'] >= test_day]

    forecast = forecast[forecast['ds'] > start_day]



    # 관측된 데이터 포인트 제거
    # print(model.history.y)
    # future_predictions = forecast[df.shape[0]:]
    model.history.loc[:new_df.shape[0], 'y'] = None

    # 시각화
    fig = model.plot(forecast)
    ax = fig.gca()
    # x 축 눈금 설정
    locator = mdates.HourLocator(interval=2)  # 2시간 간격으로 눈금 설정
    formatter = mdates.DateFormatter('%m-%d %H')  # 날짜 형식 지정
    ax.xaxis.set_major_locator(locator)
    ax.xaxis.set_major_formatter(formatter)
    plt.rcParams["font.family"] = 'NanumGothic' # 한글 폰트 적용
    mpl.rcParams['axes.unicode_minus'] = False
    # x축 눈금 설정
    plt.gca().spines['right'].set_visible(False)  # 오른쪽 테두리 제거
    #plt.gca().spines['top'].set_visible(False)  # 위 테두리 제거
    plt.gca().spines['left'].set_visible(False)  # 왼쪽 테두리 제거
    plt.gca().set_facecolor('#E6F0F8')  # 배경색

    # fcst_t = forecast['ds'].dt.to_pydatetime()
    # ax.plot(model.history['ds'].dt.to_pydatetime(), model.history['y'], color = 'black')
    ax.spines['left'].set_visible(False) # 왼쪽 여백 제거
    ax.spines['top'].set_visible(False) # 위쪽 여백 제거

    line0 = ax.fill_between(forecast['ds'], forecast['yhat_lower'], forecast['yhat_upper'], color='#edade4', alpha=0.3,label='bound') # 범주값 표시
    line1, = ax.plot(test['ds'], test['y'],color = 'black',label = 'Real data')
    line2, = ax.plot(predict['ds'], predict['yhat'], color='#8d2edb',label='Predict data') # 예측 값
    line3,= ax.plot(train['ds'], train['yhat'], color='#e64f3e', label='model data') # 실제값 추이

    # yticks = list(ax.get_yticks())  ## y축 눈금을 가져온다.
 #
    # for y in yticks:
    #     ax.axhline(y, linestyle=(0, (5, 2)), color='grey', alpha=0.5)  ## 눈금선 생성

    #plt.title("%s 인구혼잡도" % i, weight='bold',fontsize=10)
    plt.xlabel("날짜")
    plt.xticks(rotation=45, ha='right',weight='bold')
    plt.ylabel('인구혼잡도', rotation='vertical', ha='right',weight='bold')
    ax.legend(handles=[line0, line1, line2, line3], loc='upper left', fontsize=8,
          labels=['예측값범위', '실제 값', '예측 값','모델 결과값'], edgecolor='black', shadow=True)

    plt.savefig("%s_model.png" % i,bbox_inches = 'tight') # 각 구에 맞는 나이 비율 이미지
    # plt.show()
    plt.close()

    output_filename = "%s_model.png" % i
    file_name = output_filename

    file_path = os.path.realpath(output_filename)
# # # S3 버킷 이름과 업로드할 객체 키를 지정합니다.
    bucket_name = 'mlops-models-bucket'
    object_key = "prophet/" + "%s/" % i + file_name
    # 로컬 파일을 S3에 업로드합니다.
    s3.upload_file(file_path, bucket_name, object_key)
    # break
# schedule.every().day.at("00:05").do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

해당 코드를 통해 30일간의 인구 데이터를 기반으로 당일날 예측 데이터 시각화를 진행했습니다.

위 이미지가 서울 50 개 지역중 쌍문동 맛집거리에 대한 모델 예측 결과 예시입니다.

사용자는 해당 데이터를 바탕으로 전날까지의 실제 유동인구의 데이터를 볼 수 있으며, 추가적으로 당일날 인구 예측값을 확인 할 수 있었습니다.

또한 지역별로 나이대 분포도와 남녀 성비, 주간혼잡도를 보여주며, 해당 지역에서 나이대 분포를 통해 지역별 특징을 나타냈습니다. 위 데이터를 바탕으로 MZ세대에서 인기있는 홍대, 건대 등 특정 지역에 있어 20대와 30대 분포가 많은 것을 확인 할 수 있었습니다. 또한 모델의 정확도를 측정하기 위해 RMSE 지표를 추출했습니다. 모델의 예측 결과값과 실제 데이터 값의 RMSE 도출을 통해 모델 정확도를 판별할 수 있었습니다.

import pandas as pd
import numpy as np
from prophet import Prophet
from datetime import datetime, timedelta
import holidays
import os
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
import boto3
import matplotlib as mpl
import io
from sklearn.metrics import mean_squared_error
import math


# S3 버킷 및 파일 경로
bucket_name = 'mlops-api-output'
file_key = '2023/2023.csv'

# S3 클라이언트 생성
s3 = boto3.client('s3', aws_access_key_id="AKIA3IWALKWTEQNRFASU",
                  aws_secret_access_key="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")

# CSV 파일 다운로드 및 읽기
response = s3.get_object(Bucket=bucket_name, Key=file_key)
df = pd.read_csv(io.BytesIO(response["Body"].read()))

df_index_list = df.index
df.insert(0, "지역", df_index_list)
df_reset = df.reset_index(drop=True)
df_reset['PPLTN_TIME'] = df_reset['PPLTN_TIME'].apply(lambda _: datetime.strptime(_, '%Y-%m-%d %H:%M'))
df_reset['PPLTN_TIME'] = df_reset['PPLTN_TIME'].dt.strftime('%Y-%m-%d %H:00:00')
local_list = df_reset["지역"].unique()

# 한국 휴일 객체 생성
kr_holidays = holidays.KR()
df_reset['holiday'] = df_reset.PPLTN_TIME.apply(lambda x: True if x in kr_holidays else False)
df = df_reset.rename(columns={'PPLTN_TIME': 'ds', 'AREA_PPLTN_MAX': 'y'})
df['ds'] = pd.to_datetime(df['ds'])

# RMSE, y 평균값, yhat 평균값을 저장할 데이터프레임 생성
rmse_df = pd.DataFrame(columns=['지역', 'RMSE', 'y 평균값', 'yhat 평균값'])


for i in local_list:
    plt.clf()  # plt 초기화
    local_df = df["지역"] == i  # "지역" column에서 "경복궁" 값을 가지고 있는 행 추출
    print(i)
    filtered_local_df = df[local_df]

    # 날짜를 기준으로 정렬
    filtered_local_df = filtered_local_df.sort_values('ds', ascending=False)

    # 오늘 날짜 가져오기
    # latest_date = filtered_local_df.iloc[0]['ds']
    today = datetime.today().strftime("%Y-%m-%d 00:00:00")
    latest_date = datetime.today().strptime(today, "%Y-%m-%d 00:00:00")

    # 최근 n 일 동안의 데이터 선택
    start_date = latest_date - timedelta(days=30)

    new_df = filtered_local_df[filtered_local_df['ds'] >= start_date]

    test_day = latest_date
    new_df = new_df[new_df['ds'] <= test_day]

    # print(df['ds'])
    new_df = new_df.sort_values('ds', ascending=True)
    model = Prophet(
        # Trend
        growth="linear",
        changepoints=None,
        n_changepoints=10,
        changepoint_range=1,
        changepoint_prior_scale=0.5,
        interval_width=0.95,

        # Holiday
        holidays=None)
    model.fit(new_df)
    # 미래 예측 생성
    future = model.make_future_dataframe(freq="H", periods=24)
    # print(future)
    # 미래 예측
    forecast = model.predict(future)
    test_day = latest_date
    start_day = test_day - timedelta(days=1) # 어제 날짜
    test = new_df[new_df['ds'] > start_day]
    predict = forecast[forecast['ds'] > test_day]
    # 실제 값
    actual_values = test['y']
    # 예측 값
    predicted_values = predict['yhat']
    # RMSE 계산
    rmse = round(math.sqrt(mean_squared_error(actual_values, predicted_values)),2)
    # 평균 값 계산
    mean_value = round(predicted_values.mean(),2)

    # y의 평균값 계산
    y_mean = round(actual_values.mean(),2)

    # yhat의 평균값 계산
    yhat_mean = round(predicted_values.mean(),2)

    # 데이터프레임에 결과 값 추가
    rmse_df = rmse_df.append({'지역': i, 'RMSE': rmse, 'y 평균값': y_mean, 'yhat 평균값': yhat_mean}, ignore_index=True)

# CSV 파일로 저장
rmse_df.to_csv('result.csv', index=False)

시각화 이미지는 s3 bucket에 저장됐으며 s3 bucket에 있는 이미지를 가져와 어플리케이션 내에서 해당 데이터를 보여줬습니다.

데이터를 실시간으로 1시간마다 계속해서 가져오기때문에 현재 인구혼잡도에 대한 정보를 지속적으로 갱신하며 제공했고 이를 통해 사용자들은 현재 자기가 원하고자 하는 지역에 대한 인구정보 통계및 인구혼잡도를 확인 할 수 있었습니다.

프로그래머스 [level2] 롤케이크 자르기 - python3

Shine_sunho — Thu, 9 Nov 2023 12:51:11 +0900

롤케이크 자르기

문제 설명

철수는 롤케이크를 두 조각으로 잘라서 동생과 한 조각씩 나눠 먹으려고 합니다. 이 롤케이크에는 여러가지 토핑들이 일렬로 올려져 있습니다. 철수와 동생은 롤케이크를 공평하게 나눠먹으려 하는데, 그들은 롤케이크의 크기보다 롤케이크 위에 올려진 토핑들의 종류에 더 관심이 많습니다. 그래서 잘린 조각들의 크기와 올려진 토핑의 개수에 상관없이 각 조각에 동일한 가짓수의 토핑이 올라가면 공평하게 롤케이크가 나누어진 것으로 생각합니다.

예를 들어, 롤케이크에 4가지 종류의 토핑이 올려져 있다고 합시다. 토핑들을 1, 2, 3, 4와 같이 번호로 표시했을 때, 케이크 위에 토핑들이 [1, 2, 1, 3, 1, 4, 1, 2] 순서로 올려져 있습니다. 만약 세 번째 토핑(1)과 네 번째 토핑(3) 사이를 자르면 롤케이크의 토핑은 [1, 2, 1], [3, 1, 4, 1, 2]로 나뉘게 됩니다. 철수가 [1, 2, 1]이 놓인 조각을, 동생이 [3, 1, 4, 1, 2]가 놓인 조각을 먹게 되면 철수는 두 가지 토핑(1, 2)을 맛볼 수 있지만, 동생은 네 가지 토핑(1, 2, 3, 4)을 맛볼 수 있으므로, 이는 공평하게 나누어진 것이 아닙니다. 만약 롤케이크의 네 번째 토핑(3)과 다섯 번째 토핑(1) 사이를 자르면 [1, 2, 1, 3], [1, 4, 1, 2]로 나뉘게 됩니다. 이 경우 철수는 세 가지 토핑(1, 2, 3)을, 동생도 세 가지 토핑(1, 2, 4)을 맛볼 수 있으므로, 이는 공평하게 나누어진 것입니다. 공평하게 롤케이크를 자르는 방법은 여러가지 일 수 있습니다. 위의 롤케이크를 [1, 2, 1, 3, 1], [4, 1, 2]으로 잘라도 공평하게 나뉩니다. 어떤 경우에는 롤케이크를 공평하게 나누지 못할 수도 있습니다.

롤케이크에 올려진 토핑들의 번호를 저장한 정수 배열 topping이 매개변수로 주어질 때, 롤케이크를 공평하게 자르는 방법의 수를 return 하도록 solution 함수를 완성해주세요.

제한사항

1 ≤ topping의 길이 ≤ 1,000,000
1 ≤ topping의 원소 ≤ 10,000

입출력 예

topping	result
[1, 2, 1, 3, 1, 4, 1, 2]	2
[1, 2, 3, 1, 4]	0

입출력 예 설명

입출력 예 #1

롤케이크를 [1, 2, 1, 3], [1, 4, 1, 2] 또는 [1, 2, 1, 3, 1], [4, 1, 2]와 같이 자르면 철수와 동생은 각각 세 가지 토핑을 맛볼 수 있습니다. 이 경우 공평하게 롤케이크를 나누는 방법은 위의 두 가지만 존재합니다.

입출력 예 #2

롤케이크를 공평하게 나눌 수 없습니다.**

문제 풀이

from collections import Counter

def solution(topping):
    answer = 0
    bro = Counter(topping)
    chulsoo = set()
    for i in topping:
        bro[i] -=1
        if bro[i] == 0:
            del bro[i]
        chulsoo.add(i)
        if len(bro) == len(chulsoo):
            answer +=1
    return answer

문제 해석

set과 counter를 이용하여 계산을 했습니다.