빅데이터분석기사 취득기

들어가며

이번 포스팅은 빅데이터 분석기사 시험을 준비하며 공부했던 내용들을 공유하는 글입니다.

• 시험난이도 : 중
• 준비시간 : 약 10일 (평일 2시간, 주말 4시간)

[ 필기 시험 준비내용 ]

PART1. 빅데이터 분석 기획 (기본개념)

1. (상) 빅데이터 개요 및 활용
   • 가트너 3V : Volume(규모), Variety(다양성), Velocity(속도), +Veracity(품질), +Value(가치)
   • 빅데이터 활용 3요소 : 자원(빅데이터), 기술(빅데이터플랫폼,AI), 인력(알고리즈미스트,데이터사이언티스트)
   • 정보의 특징 : 정확성, 적시성, 적당성, 관련성 (일관성은 아님;;)
   • 지식창조 메커니즘 단계 : 공통화(인식 공유하여 암묵지로) - 표출화(암묵지가 구체화되어 형식지로) - 연결화(형식지를 재분류하여 체계화) - 내면화(전달받은 형식지를 개인의 것으로)

     암묵지) 학습과 경험을 통하여 개인에게 체화되어 있지만 겉으로 드러나지 않은 지식
     형식지) 명시적으로 알 수 없는 형태. 형식을 갖추어 표현되고 공유가 가능한 지식

• DW 구성요소 : 데이터 모델, ETL, ODS(다양한 DBMS 통합관리), Meta-Data, OLAP, 데이터마이닝, 분석TOOL & 경영기반 솔루션(BI)

  데이터 웨어하우스 특징 : 주제지향성(Subject-Orientation), 통합성(Integration), 시계열성(Time-variant), 비휘발성(Non-volatilzation)

• 조직의 구성 : 집중형(전사분석업무를 별도의 전담조직-DSCoE에서 수행), 기능형(각 부서에서 분석업무를 직접 수행), 분산형(분석 전문 인력-DSCoE 을 현업 부서에 배치하여 분석업무 수행)

  DSCoE : Data Science Center of Excellence - 분석전담조직

1. (상) 빅데이터 기술 및 제도
   • 빅데이터 플랫폼 기능 : 컴퓨팅부하 ->(클러스터 자원할당), 저장부하 -> (메모리파일시스템), 네트워크부하 -> (최단거리노드탐색,대역폭분배)
   • 빅데이터 3계층 : 소프트웨어 계층(데이터 수집정제처리 등), 플랫폼 계층(작업스케줄링,자원할당), 인프라스트럭처 계층(스토리지관리,네트워크 배치 & 관리)
   • 빅데이터 처리과정 : 데이터생성 -> 수집(crawling,로그,sensor,openapi,ETL) -> 저장(NoSQL,HDFS,S3,NAS등) -> 처리(HADOOP,SPARK,MapReduce) -> 분석(분규,군집화,머신러닝,데이터마이닝,감정분석 등) -> 시각화

1) RDBMS 트랜젝션 속성 : 원자성(Atomicity), 일관성(Consistency), 독립성(Isolation), 지속성(Durability)
2) MapReduce 단계 : Split -> Map -> Shuffle -> Reduce
3) 분석 분류 : 탐구요인분석(EFA: 데이터간 상호관계), 확인요인분석(CFA: 변수들의 집합요소 구조파악)

• 머신러닝 분류
  • 지도학습(Supervised Learning) : 분류, 회귀
  • 비지도학습(Unsupervised Learning) : 군집, 오토인코더(라벨이 설정되어 있지 않은 학습데이터로부터 효율적인 코드로 표현) -> 이상징후탐지, 노이즈제거, GAN(생성적 적대 신경망) -> 생성자는 가짜 사례를 생성, 감별자는 진위 판별하는 식으로 공방반복
  • 준지도학습(Semi-supervised Learning)
  • 강화학습(Reinforcement Learning) : 강화학습
• 데이터 3법
  • 개인정보보호법/일반법 : 당사자의 동의 없이 개진정보의 수집,활용을 금지 -> 개인정보를 구체적으로 개인정보, 가명정보(도압), 익명정보로 구분
  • 정보통신망법/특별법-우선적용(정보통신망 이용 촉진 및 정보보호 등에 관한 법률) : 이용자의 동의 필요, 개인정보 위탁 시 동의 필요. -> 개인정보 관련 사항을 개인정보 보호법으로 이관
  • 신용정보보호법(신용정보의 이용 및 보호에 관한 법률) : 개인신용정보를 타 회사등에 제공하고자 하는 경우에는 서명 및 동의가 필요하다. -> 가명정보는 신용정보 주체의 동의없이 이용가능하다
• GDPR : 유럽의회에서 유럽 시민들의 개인정보보호 강화를 위해 만든 규정
• 비식별화 : 개인을 식별할 수 있는 요소를 전부 삭제하거나 대체하여 개인식별 불가하도록 만듬
  • 사전검토 -> 비식별조치 -> 적정성평가 -> 사후관리

1. (상) 분석 방안 수립
   • 데이터 분석 기획 : 실제 분석을 시행하기에 앞서 분석을 수행할 과제의 정의 및 방안을 사전에 계획
   • 분석 기획의 절차 : 비즈니스 이해범위 설정 -> 프로젝트 정의 -> 수행계획 수립 -> 위험계획 수립
   • 목표 시점에 따라 : 단기적접근방식(과제중심적 접근), 중장기적접근방식(마스터플랜 접근), 혼합방식(분석기획시)
     • 마스터플랜 : 전체적인 방향성을 제시하는 기본계획
     • 분석로드맵 : 마스터플랜에서 정의한 목표를 기반으로 분석과제를 수행하기 위해 필요한 기준등을 담아 만든 계획 - 분석 문제 정의
   • 하향식 접근 : 문제가 먼저 주어지고 이에 대한 해법을 찾아감
     • 수렴(Converge) 단계 : 도출된 옵션을 분석하고 검증
   • 상향식 접근 : 문제 정의가 어려운 경우, 데이터 기반으로 문제의 재정의 및 해결방안을 탐색
     • 발산(Diverge) 단계 : 가능한 옵션을 도출 - 분석방법론 :
   • KDD : 통계적인 패턴이나 지식을 탐색할 수 있는 데이터 마이닝 프로세스
     • 데이터 선택 -> 전처리 -> 변환 -> 마이닝 -> 결과평가
   • CRISP-DM : 데이터 탐색을 바탕으로 비즈니스에 맞게 마이닝을 반복적으로 실시
     • 최상위레벨, 일반화tast,세분화task,프로세스 실행의 4계층으로 나뉜다.
     • 업무이헤 -> 데이터이해 -> 준비 -> 모델링 -> 평가 -> 전개(배포)
   • SEMMA : 기술 통계 중심의 데이터 마이닝 프로세스
     • 추출 -> 탐색 -> 수정 -> 모델링 -> 평가
   • 분석방법론 계층 : 단계(데이터 분석을 수행하기 위한 절차), 테스크(각 단계별로 수행되어야 하는 세부업무), 스텝(단기간 내에 수행가능한 워크패키지)
   • 분석방법론 개발절차 : 분석기획 -> 데이터 준비 -> 데이터 분석 -> 시스템 구현 -> 평가 및 배포
   • 데이터 거버넌스 : 데이터 분석 업무를 하나의 기업문화로 정착하고 지속적으로 고도화해나간다.
     • 주요 관리 대상은 마스터데이터, 메타데이터, 데이터사전 이다.
   • 데이터 분석 수준진단 :
     • 분석 준비도 : 총 6가지 영역 대상으로 현재 수준을 파악한다.
     • 분석 성숙도 : 비즈니스 부문, 조직 및 역량 부문, IT부문 총 3개를 대상으로 실시한다.
       • 도입 -> 활용 -> 확산 -> 최적화
2. (하) 분석 작업 계획
   • 데이터 분석 영역 : 데이터를 추출,가공한 후 분석을 수행하고 결과를 표현한다.
   • 데이터 분석 : 도메인 이슈 도출, 분석 목표 수립, 프로젝트 계획 수립, 보유 데이터 자산 확인
   • 데이터 표현 : 빅데이터 분석 결과 시각화 - 데이터 확보시 분석 변수 점검 항목 : 데이터 적정성, 가용성, 기술적 타당성 - 분석 작업 계획 절차 : 데이터 분석과제 정의 -> 데이터 준비,탐색 -> 데이터 분석 모델링 & 검증 -> 산출물 정리
3. (하) 데이터 수집 및 전환
   • 수집, 빅데이터 ETL 기술들 -> Pass
   • 데이터 비식별화 : 개인정보를 식별할 수 있는 값들을 몇가지 정해진 규칙으로 대체하거나 가공하여 개인을 식별할 수 없게 가공
   • 적정성 평가 : 프라이버시 보호모델 중 최소한으로 k-익명성, 필요시 l-다양성, t-근접성
     • k-익명성 : 특정인 추론 가능한지 검토. 동일 값을 가진 레코드를 k개 이상
     • l-다양성 : 민감한 정보의 다양성을 높인다. 각 레코드는 l개 이상의 다양성
     • t-근접성 : 민감한 정보의 분포를 낮춘다. 전체 정보분포와 특정분포 차이을 t 이하로
4. (하) 데이터 적재 및 저장
   • 데이터 적재, HDFS, GFS 등 -> Pass
   • CAP 이론 : 분산 컴퓨팅 환경의 특징을 일관성(Consistency), 가용성(Vailability), 지속성(Partition-Tolerance) 3가지로 정의함. 어떤 시스템이던지 이 세가지 특성을 동시에 만족하기는 힘듬.
   • 일관성(Consistency) : 분산 환경에서 모든 노드가 같은 시점에 같은 데이터를 보여준다.
   • 가용성(Availability) : 일부 노드가 다운되어도 다른 노드에 영향을 주지 않아야 한다.
   • 지속성(Partition-Tolerance) : 데이터 전송 중에 일부 데이터를 손실하더라도 시스템은 정상 동작해야 한다. - CAP에 따른 RDBMS vs RDBMS
   • RDBMS : (Consistency + Availability)
     • 트랜젝션 ACID 보장 (ex: 금융서비스)
   • NoSQL : (Consistency or Availability 중 1개) + Partition Tolerance
     • Consistency + Partition-Tolerance : 대용량 분산 파일 시스템 (ex: Bigtable, HBase)
     • Availability + Partition-Tolerance : 비동기식 서비스 (ex: Dynamo, Cassandra)

       NoSQL 의 기술적 특성 1) 스키마리스, 2) 탄력성(시스템 일부에 장애가 발생해도 시스템에 접근 가능하다) 3) 질의 가능, 4) 캐싱(대규모 질의에도 고성능 응답속도를 제공할 수 있는 메모리 기반 캐싱 기술 적용이 중요하다)

• NoSQL 종류별 구분
  • Key-Value 데이터베이스 : 키벨류 기반으로 확장성과 질의응답시간이 뛰어나다.
    • 간단하지만 범위질의가 DB에서 지원하지 않는다면 힘들다.
    • AWS DynamoDB, Redis 와 같은 In-Memory Database
  • Column-Oriented 데이터베이스 : 데이터를 row 가 아닌 column 기반으로 저장하며, 확장성을 보장하기 위해 여러 노드로 분할 저장된다.
    • 연관된 데이터 위주로 읽는데 유리하다.
    • 하나의 레코드를 수정하려면 여러곳을 수정해야 한다.
    • 동일 도메인 값이 연속되므로 압축 효율이 좋고 범위 질의에 유리하다.
    • Google BigTable, Cassandra, HBase
  • Document 데이터베이스 : 문서 형식의 정보를 저장, 검색, 관리하기 위한 DB.
    • 문서마다 다른 스키마를 가지고 있고, 레코드간의 관계 설명이 가능하다.
    • MongoDB, CouchDB

PART2. 빅데이터 탐색 (약간의 수학)

1. (상) 데이터 정제
   • 결측 데이터의 종류
   • MCAR(Missing Completely At Random) : 완전 무작위 결측, (결측 데이터가) 다른 변수와 아무 연관이 없는 경우.
   • MAR(Missing At Random) : 무작위 결측, (결측 데이터가) 관측된 다른 변수와 연관되어 있지만 비관측값들과는 연관없는 경우
   • NMAR(Not Missing At Random) :비 무작위 결측, 어떤 변수 데이터가 MCAR, MAR가 아닌 결측데이터로 정의. 즉 다른 변수와 연관있음

     3) 질의 가능, 4) 캐싱(대규모 질의에도 고성능 응답속도를 제공할 수 있는 메모리 기반 캐싱 기술 적용이 중요하다)

• 데이터 이상값(Outlier) 탐지
  • 시각화(Box Plot, Scatter Plot) 를 통한 방법(비모수, 단변량)
  • Z-score(모수, 단변량)
  • DBSCAN(Density Based Spatial Clustering of Application with Noise) : 군집간의 밀도를 이용하여 특정 거리 내의 데이터 수가 지정 개수 이상이면 군집으로 정의
  • Isolation Forest : Decision Tree 기반으로 정상치의 단말노드보다 이상치의 단말노드에 이르는 길이(Path Lengh)가 더 짧은 성질을 이용한다.

1. (상) 분석 변수 처리
   • 변수의 선택방법 :
   • 전진 선택법(Forward Selection) : 유의미한 변수를 선택해나감
   • 후진 선택법(Backward Selection) : 설명력이 떨어지는 변수를 소거해나감
   • 단계적 선택법(Stepwise Selection) : 전진선택과 후진선택을 반복하여 유의한 변수가 없을때까지 진행한다.

• 파생 변수 생성, 학습데이터 불균형, 차원의 저주, 군집 불균형, 차원 축소, 변수 변환

1. (중) 데이터 탐색 기초
   • 박스플롯, 산점도, 상관계수, median, 표본 추출, 왜도, 기초통계 량, 이상치
2. (중) 고급 데이터 탐색
   • 주성분분석, 비정형데이터
3. (중) 기술통계
   • 전수조사, 불량률, 확률 계산, 층화추출, 확률분포, 포아송분포, 중심극한정리, 군집추출, 층화추출. 카이제곱, 확률밀도함수
4. (중) 추론통계
   • 최대우도, Z 계산, 점추정, 1종/2종 오류, 유의수준, 표본분산

PART3. 빅데이터 모델링 (모델링 알고리즘)

1. 분석 절차 수립
   • 모델링 절차
2. 분석 환경 구축

K-fold 검정, 데이터 분할

1. (상) 분석 기법
   • 회귀분석(중요)
   • 로지스틱 회귀분석(중요)

변수 선택. 인공신경망, 합성곱 계층, 잔차진단, SVM, L人SSO, 로지스틱 회귀, 앙상블, 비지도학습, 지도학습분류, 군집분석, 회귀분석, 활성화함수, 의사결정나무. DNN, CNN, RNN, 초매개변수

1. (상) 고급 분석 기법

자료 분석, 다차원 척도, 베이즈 정리, 시계열 자료, 자기상관, 비 정형 데이터 형태, 랜덤 포레스트, 비모수적 통계 검정법, 배징, 부 스팅, ARIMA

PART4. 빅데이터 결과 해석 (시각화)

1. (상) 분석 모형 평가
   • 분류성능
   • 정확도(Accuracy) = 전체맞힘/전체 = TP + TN / TP + FP + FN + TN
   • 민감도,재현율(Sensitivity,Recall) = T맞힘/실T = TP / TP + FN
   • 특이도(Specificity) = F맞힘/실F = TN / FP + TN
   • 정밀도(Precision) = T맞힘/예T = TP / TP + FP
   • F1 Score = 2 x 정밀도 x 재현율 / 정밀도 + 재현율
2. (상)분석 모형 개선
   • 초매개변수, 모형 선택. 매개변수 최적화
3. 분석 결과 해석
   • MAE, MAPE, 선형회귀, ROC, 지지도, 신뢰도
4. (상) 분석 결과 시각화
   • 인포그래픽(중요)
   • 산섬도. 박대그래프
5. 분석 결과 활용
   • 모델링 타입, 분석결과의 활용, 성과지표

[ 실기 시험 준비내용 ]

실기 시험도 무사히 통과..!

실기 시험 역시 기본적인 예제만 잘 숙지하면 크게 어렵지 않게 통과할 수 있습니다.

PART1. 빅데이터 분석 기사 실기 - 제1유형

• series 가 여러개 모인 것이 dataframe 이다. 하지만 series와 dataframe이 제공하는 함수가 다르기 때문에 타입을 잘 선택해야 한다.

import numpy as np
import pandas as pd

# 데이터 생성 - Series
sr = pd.Series([1,2,3,4])

# 데이터 생성 - DataFrame
df = pd.DataFrame(
    {
        'A' : 10,
        'B' : [1,2,3,4],
        'C' : [11111,2,3,4],
        'E' : sr
    }
)

# 파일 읽기
df_from_excel = pd.read_csv('data/iris.csv')

# 파일 쓰기 -> 2유형 파일 제출, index 는 false!!
df_iris.to_csv('./data/iris_1.csv', index=False)

# 데이터 정보 보기 - 기본
df.head()
df.index
df.columns
df.T
df.to_numpy() # 배열 전환
df.describe()
df.info() # 시리즈별 타입을 확인함

# 데이터 정보 보기 - 통계
df_iris.isnull().sum() # 결측치 확인법
df_iris['variety'].isnull().sum()
dpct = df_iris['variety'].duplicated() # `duplicated()` 메서드는 각 행에 대해 이전에 등장한 동일한 값이 있는지 여부를 Boolean 값으로 반환
df_iris['variety'].unique()
df_iris['variety'].value_counts() # 각 데이터별 카운트 세어줌
df_iris.count()
df_iris.min(numeric_only=True)
df_iris.max(numeric_only=True)
df_iris.quantile(numeric_only=True) # 분위수
df_iris.sum(numeric_only=True)
df_iris.mean(numeric_only=True) # 평균
df_iris.median(numeric_only=True) # 중앙값
df_iris.var(numeric_only=True) # 분산
df_iris.std(numeric_only=True)  # 표준편차
df_iris.skew(numeric_only=True) # 왜도 (왜도가 양수이면 오른쪽으로 꼬리가 긴 분포)
df_iris.kurtosis(numeric_only=True) # 첨도 () 

# 데이터 정보 보기 - 상관계수(두 변수 간의 선형 관계의 강도)
df_iris.corr(numeric_only=True) 
df_iris.corrwith(df_iris['sepal_length'], numeric_only=True) # 칼럼 선택하여 상관계수 표현

# 데이터 선택하기 -데이터
# 1. subset : 부분집합 만들기
df[   'A'     ]  # 한개 컬럼만 뽑는것. Series 로 뽑힘. 다만  df[ ['A'] ] 로 넘기면 dataframe으로 반환해줌
df[ ['A','B'] ]  # 여러 칼럼을 뽑으려면 리스트로 넘겨야 한다.
df[0:4] # 0 ~ 3 행까지
df[df['A'] < 0] # 조건 주는 법

# 2. loc : [헹의 조건 : 열의 조건] 
df.loc[:, ['A','B']] # 단 행의 조건은 생략불가
df.loc[(df['A'] < 0) & (df['B'] > 0), ['A','B']]

# 3. iloc # loc 와 동일하나, 인덱스 중심으로 계산
df.iloc[0:4, 1:4]

# 아래 두개는 같음
df_iris.loc[5:9, ['sepal_width', 'petal_width', 'variety']]
df_iris[5:10][['sepal_width', 'petal_width', 'variety']]
df_iris.loc[(df_iris['petal_width'] < 0.2), ['sepal_length','variety']]
df_iris.loc[(df_iris['variety'] == 'Setosa')&(df_iris['sepal_length'] > 5.5), :]

# 데이터 변경하기
df1.drop('A', axis=1, inplace=True)
df1

# 변수 타입 바꾸기
df1.astype({'B': 'int64'})

# 데이터 변환하기
df2 = df_iris.copy()
df2['variety'] = df2[['variety']].replace({'Setosa':0, 'Versicolor':1, 'Virginica':2})
df2

# 범주화
df1 = df.copy()
df1['New_A1'] = pd.cut(df1['A'], 4, labels=False)
df1
df1['New_A2'] = pd.cut(df1['A'], [-3,-1,0,1,3], labels=[1,2,3,4])
df1

# Set_index, Reset_index
df1 = df.copy()
df1.reset_index(inplace=True) # 인덱스를 제외함
df1.set_index(['A'], inplace=True) # 인덱스를 넣어줌
df1

# sort
df.sort_index(axis=1, ascending=False) # 인덱스로 정렬, axis 가 1이면 열을 정렬

df.sort_values(by='A', ascending=False) # 값으로 정렬, 


# 인코딩
df2 = df_iris.copy()
df2['variety_label'] = pd.Categorical(df2['variety']).codes
df2

# df2 = pd.get_dummies(df2, columns=['variety'])
df2 = pd.get_dummies(df2)
df2

# 결측치 

# 결측치 채움
df1['A'] = df1['A'].fillna(0)
df1

# 결측치 버림
df1.dropna(subset=['A'], inplace=True)
df1

# 중복 제거
df_iris['variety'].unique()

df_iris['variety'].value_counts()

df2 = df_iris.copy()
df2.drop_duplicates(subset=['variety'], inplace=True)
df2

# group by
tips.groupby('day').mean(numeric_only=True)
tips.groupby(['day', 'smoker']).mean(numeric_only=True)
# 각기 다른 집계
tips.groupby('day')[['total_bill','tip']].agg({'total_bill':'sum','tip':'mean'})

# merge
# 중복되는 컬럼 이름 자동 변경
pd.merge(left, right, on='key1')

# 중복되는 컬럼 이름 뒤에 붙일 문자열 지정
pd.merge(left, right, on='key1', suffixes=('_left', '_right'))

# Concat
pd.concat([df1, df2], axis=1, join='outer')
pd.concat([df1, df2], axis=1, join='inner')

# Reshaping
#### 1. Pivot: Long format data --> Wide format data
#### 2. Melt: Wide format data --> Long format data

# Pivot - Long to Wide format data
df1.pivot_table(index='date', columns='item', values=['value'], aggfunc=['sum'])
# value_vars 생략하면 모든 컬럼에 적용
df2.melt(id_vars='date', var_name='item', value_name='value1')

• Age 변수의 제 3사분위수를 구하고 반올림하여 소수점 둘째까지 구하시오.

Q3 = df['Age'].quantile(0.75)
print(round(Q3,2))

• Age 값이 20세 이상 30세 이하인 데이터의 수를 구하시오.

df1 = df[(df['Age']>=20) & (df['Age']<=30)]
print(len(df1))

• Age 변수의 IQR값을 구하시오.

Q1 = df['Age'].quantile(0.25)
Q3 = df['Age'].quantile(0.75)

IQR = Q3-Q1
print(IQR)

# IQR 값의 위로 1.5배, 아래로 1.5배를 양 끝단으로 보며, 이를 넘어가는 수치는 outlier 로 간주한다.

• Age 값이 큰 순서로 5개 값의 합계를 구하고 반올림하여 정수로 구하시오.

res = df.sort_values('Age', ascending=False).head(5)['Age'].sum()
print(round(res))

• Age값이 20세인 비율을 구하고 반올림하여 소수점 둘째자리까지 구하시오.

res = len(df[df['Age'] == 20]) / len(df)
print(round(res,2))

• Age 변수의 결측치 갯수를 구하시오.

res = df['Age'].isnull().sum()
print(res)

• Age 변수의 결측치를 중앙값으로 대체하고 Age의 평균을 반올림하여 소수점 둘째 자리 까지 구하시오.

res = df['Age'].fillna(df['Age'].median()).mean()  # 애초에 mean() 은 결측치를 제외하고 평균을 내주기는 함
print(round(res))

• Age 변수가 결측치인 행을 삭제하고 Age의 평균을 반올림하여 소수점 둘째 자리 까지 구하시오.

res = df['Age'].dropna().mean()
print(round(res))

• Gender 변수가 male인 행의 Age 평균을 반올림하여 소수점 둘째 자리 까지 구하시오.

res = df.loc[df['Gender'] == 'male','Age'].mean()
print(round(res))

• Age 변수의 이상치 갯수를 구하시오.

Q1 = df['Age'].quantile(0.25)
Q3 = df['Age'].quantile(0.75)

IQR = Q3-Q1

upper = Q3 + (1.5*IQR)
lower = Q1 - (1.5*IQR)

print(len(df[df['Age'] > upper]) + len(df[df['Age'] < lower]))

• Name 변수에 문자열 ‘Miss’를 포함하고 있는 행의 Age 평균을 반올림하여 소수점 둘째 자리 까지 구하시오.

res = df.loc[df['Name'].str.contains('Miss'), 'Age'].mean()
print(round(res, 2))

• Date 변수가 1월인 행의 Open 변수 평균을 반올림하여 소수점 둘째 자리 까지 구하시오.

df_ks['Date'] = pd.to_datetime(df_ks['Date'])

df_ks['year'] = df_ks['Date'].dt.year
df_ks['month'] = df_ks['Date'].dt.month
df_ks['day'] = df_ks['Date'].dt.day
df_ks['wday'] = df_ks['Date'].dt.weekday
df_ks['day_name'] = df_ks['Date'].dt.day_name()

res = df_ks.loc[df_ks['month'] == 1, 'Open'].mean()
print(round(res,2))

• Date 변수를 인덱스로 설정하고 2021 ~ 2022 데이터의 Open 변수 평균을 반올림하여 소수점 둘째 자리 까지 구하시오.

df_ks.set_index('Date', inplace=True)

res = df_ks.loc['2021-12':'2022-01', 'Open'].mean() # 날짜를 datetime 타입으로 바꾸면 굉장히 편리하다
print(round(res,2))

from sklearn.preprocessing import StandardScaler,MinMaxScaler

zscaler = StandardScaler()
df['mpg_z'] = zscaler.fit_transform(df[['mpg']])

mscaler = MinMaxScaler()
df['wt_m'] = mscaler.fit_transform(df[['wt']])

df.head()

PART2. 빅데이터 분석 기사 실기 - 제2유형

작업흐름

1. 데이터 읽기
2. 데이터 탐색
3. 데이터 전처리 (처음에는 기본적인 것만)
   • 필요없는 컬럼 삭제
   • 결측치 처리
   • 범주형 변수 : 인코딩
   • 수치형 변수 : 스케일링
4. 데이터 분리
5. 모델 생성
   • 랜덤포레스트 or XGBoost 로 통일
6. 학습
7. 예측
8. 평가
9. 최종 결과값 예측 및 제출
   • 문제에서 제공되는 train data
     • x_train, y_train 으로 학습
     • x_test -> predict 만들어서 y_test 와 비교하여 성능 측정
   • 문제에서 제공되는 test data

sklearn
│
├── 01 preprocessing (전처리)
│   │
│   ├── 스케일러  :  수치형
│   │   ├── MinMaxScaler
│   │   ├── RobustScaler
│   │   └── StandardScaler
│   │
│   └── 인코더  :  범주형
│       ├── LabelEncoder
│       └── OneHotEncoder
│  
├── 02 모델학습
│   │
│   ├── ensemble
│   │   ├── AdaBoostClassifier
│   │   ├── GradientBoostingClassifier
│   │   ├── RandomForestClassifier  :  범주형
│   │   └── RandomForestRegressor   :  수치형
│   │
│   ├── linear_model
│   │   ├── LogisticRegression
│   │   └── RidgeClassifier
│   │
│   ├── svm
│   │   ├── SVC
│   │   └── SVR
│   │
│   └── tree
│       ├── DecisionTreeClassifier
│       ├── DecisionTreeRegressor
│       ├── ExtraTreeClassifier
│       └── ExtraTreeRegressor
│
├── 03 모델평가
│   │
│   ├── metrics
│   │   ├── accuracy_score   
│   │   ├── classification_report
│   │   ├── confusion_matrix
│   │   ├── f1_score
│   │   ├── log_loss
│   │   ├── mean_absolute_error    
│   │   ├── mean_squared_error  :  수치형
│   │   └── roc_auc_score
│   │
│   └── model (정의된 모델에서 추출)
│       ├── predict
│       └── predict_proba
│

예제)

# 1. 데이터 읽기
import numpy as np
import pandas as pd

df_wine = pd.read_csv('data/wine.csv')

# 2. 데이터 탐색
df_wine.shape
df_wine.info() # 이 단계에서 데이터의 개수를 확인한다. 데이터의 분포가 어떻게 되어 있는지 파악한다.
df_wine.describe()

# 3. 데이터 전처리 (처음에는 기본적인 것만)
df_wine.is_null().sum()  # 결측치 확인 (결측치 발생 시 fillna )

# 4. 데이터 분리
from sklearn.model_selection import train_test_split

X_col = []
y_col = []

X_train, X_test, y_train, y_test = train_test_split(df[X_col], df[y_col])

# 5. 모델 생성
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier()

# 6. 학습
model.fit(X_train, y_train)

# 7. 예측
pred = model.predict(X_test)

# 8. 평가
from sklearn import metrics

# 9. 최종 결과값 예측 및 제출
print(metrics.classification_report(y_test, pred))
print(round(metrics.accuracy_score(y_test, pred),2))

PART3. 빅데이터 분석 기사 실기 - 제3유형

t 검정 ( t-test )

• 단일 표본(표본 하나)에서의 t검정
  • 예시) 신장의 평균이 149가 아니 라고 할 수 있는가?
    • 귀무가설(H0) : 신장의 평균이 149 이다. -> 반증의 대상
    • 대립가설(H1) : 신장의 평균은 149가 아니다.(인과관계 있다) -> 대립가설은 증명하고자 하는 연구의 대상
    • 유의수준 : 0.05(거의 고정)
    • 독립성, 정규성 검정을 우선해야 하나, 중심극한 정리에 의해 30이 넘어가면 정규성 검사를 하지 않아도 됨
  • 결과) 검정통계량, p-value
  • 기타) alternative는 대립가설을 따라가면 된다. 예를 들어 yes/no 는 two-sided, 크다는 greater, 작다는 less

from scipy import stats

mu = 149
alpha = 0.05  # 유의수준

# t-test
t_statistic, p_value = stats.ttest_1samp(df['신장'], mu, alternative='two-sided')
#t_statistic, p_value = stats.ttest_1samp(df['신장'], mu, alternative='greater')
#t_statistic, p_value = stats.ttest_1samp(df['신장'], mu, alternative='less')

# 결과 출력
print('t-statistic:', round(t_statistic,2))
print('p-value:', round(p_value,2))

# 귀무가설 채택
t-statistic: 0.87
p-value: 0.39. # -> 유의수준 0.05보다 크다. 어떤 일이 우연히 발생할 확률이 39%이다. 따라서 인과관계가 없다. 따라서 귀무가설(인과관계 없음)을 채택한다. 

• 대응 표본(표본 한쌍)에서의 t검정
  • 예시) 사후 체력이 사전 체력보다 크다고 할 수 있는가?
    • 귀무가설(H0): 사후체력 - 사전체력 <= 0
    • 대립가설(H1): 사후체력 - 사전체력 > 0
    • 유의수준 : 0.05
  • 기타)

from scipy import stats

alpha = 0.05  # 유의수준

df['diff'] = df['사후체력'] - df['사전체력']

print('평균차이:',round(df['diff'].mean(),2))

t_statistic, p_value = stats.ttest_rel(df['사후체력'], df['사전체력'], alternative='greater')
print('t-statistic:', round(t_statistic,2))
print('p-value:', round(p_value,2))

# 귀무가설 기각, 대립가설 채택
평균차이: 4.18
t-statistic: 2.94
p-value: 0.0

• 독립 표본(서로 다른 표본)에서의 t검정
  • 표본의 그룹이 다른 경우에는 분산이 같은지를 먼저 검정[^1]하고 t-test 로 넘어간다. (stats.ttest_ind 내의 equal_var 에 true/false 가 들어감)
  • 예시) 남성과 여성의 수학 성적은 차이가 있는가?
    • 귀무가설(H0) : 남성과 여성의 수학성적은 같다.
    • 대립가설(H1) : 남성과 여성의 수학성적은 차이가 있다.
  • 기타)

from scipy import stats

alpha = 0.05  # 유의수준

t_statistic, p_value = stats.ttest_ind(group1, group2, equal_var=True,  alternative='two-sided')
#t_statistic, p_value = stats.ttest_ind(group1, group2, equal_var=False, alternative='two-sided')

print('t-statistic:', round(t_statistic,2))
print('p-value:', round(p_value,2))

# 귀무가설 채택

• 등분산 검정

# 등분산 검정
# 귀무가설: 두 그룹의 분산이 같다.

from scipy import stats

statistic, p_value = stats.levene(group1, group2, center='mean')

print('statistic:', round(statistic,2))
print('p-value:', round(p_value,2))

# 귀무가설 채택
statistic: 1.56
p-value: 0.22

분산 분석

• 크루스칼-왈리스 검정(정규성X)
• 등분산 검정
• 분산을 이용해서 평균을 검정한다.
• t-test 는 두개 집단간의 비교까지 가능하나, 분산 분석은 여러 그룹이 가능하다.

# 등분산 검정
# 귀무가설: 모든 그룹의 분산이 같다.

from scipy import stats

statistic, p_value = stats.levene(group_A, group_B, group_C, group_D, center='mean')

print('statistic:', round(statistic,2))
print('p-value:', round(p_value,2))

# 귀무가설 채택

# One-way ANOVA
import statsmodels.formula.api as smf
from statsmodels.stats.anova import anova_lm

model  = smf.ols('판매실적 ~ C(교육방법)', df)
    # C로 감싸주면 인코딩 됨
result = model.fit()
anova_lm(result)

# 사후분석 Post-hoc: Tukey HSD
from statsmodels.sandbox.stats.multicomp import MultiComparison
res = MultiComparison(df['판매실적'], df['교육방법']).tukeyhsd(alpha=0.05)
res.summary()

카이제곱 검정

• 적합도 검정 : 두 그룹간의 비율이 같은지 ?

• 독림성 검정 : 두 그룹이 서로 독립인지 ?

• 적합도 검정
  • 예시) 감기약의 부작용 비율과 항암제의 부작용 관찰 값이 통계적으로 유의미하게 차이가 있는지 카이제곱 검정을 이용하여 검정 통계량과 p-value를 구하시오.

# 감기약 투여 환자들의 부작용 발생 비율
# 무증상 70% / 조금아픔 10% / 아픔 5% / 속쓰림 15%

total = len(df['항암제'])

val1 = df['항암제'].value_counts().to_list()

val2 = [total*0.7, total*0.1, total*0.05, total*0.15]

import scipy.stats as stats

statistic, p_value = stats.chisquare(val1, val2)

• 독립성 검정
  • 예시) 세탁기크기와 가족규모는 서로 관계가 있는가?
    • 귀무가설(H0): 세탁기크기와 가족 규모는 서로 관계가 없다.(독립이다)
    • 대립가설(H1): 세탁기크기와 가족 규모는 서로 관계가 있다.
    • 유의 수준: 0.05

from scipy import stats

obs  = pd.crosstab(index=df['세탁기크기'], columns=df['가족규모'])

# statistic(통계량), p_value, dof(자유도), expected_freq(기대빈도)
statistic, p_value, dof, expected = stats.chi2_contingency(obs)

print(round(statistic,2))
print(round(p_value,2))
print(dof) # 자유도 = (행-1)*(열-1)
print(np.round(expected, 2) )

# 귀무가설 기각: 세탁기 크기와 가족 규모는 관계가 있다.

다중회귀분석

import statsmodels.formula.api as smf
model  = smf.logit('성별 ~ 외관 + 편의성 + 유용성 + 만족감', df)
result = model.fit()
print(result.summary())

상관분석

• 귀무가설(H0): 상관계수가 0이다. 두 변수간에 상관관계가 없다.
• 대립가설(H1): 두 변수간에 상관관계가 있다.

from scipy.stats import pearsonr

r, p_value = pearsonr(df['외관'], df['만족감'])

# 1. 상관계수
print(round(r, 2) )

# 2. p-value
print(round(p_value, 2))

# 3. 검정통계량
# T = r * root(n-2) / root(1-r2)

n = len(df)
r2 = r**2
statistic = r * ((n-2)**0.5) / ((1-r2)**0.5)
print(round(statistic, 2))

로지스틱회귀분석

df.replace({'남자':0, '여자':1}, inplace=True)

import statsmodels.formula.api as smf
model  = smf.logit('성별 ~ 외관 + 편의성 + 유용성 + 만족감', df)
result = model.fit()
print(result.summary())

[ 추가 참고 자료 ]

• 실기시험 강의
• 실기시험 예제

[ 실기시험 핵심 요약 ]

• 제 1유형(데이터 다루기) : 3문항, 각 10점
  • 데이터 타입(object, int, float, bool)
  • 기초통계량(평균:mean, 중앙값:median, 최빈값:mode, 사분위수:quantile, IQR:Q3-Q1, 표준편차:std)
  • 데이터 인덱싱, 필터링, 정렬, 변경
  • 중복값 제거:drop_duplicates() , 결측치, 이상치
  • 데이터 Scaling,(데이터 표준화(z), 데이터정규화(min-max))
  • 데이터 합치기
  • 날짜/시간 데이터, index 다루기
• 제 2유형(모델링 및 평가) : 1문항, 각 40점
• 제 3유형(가설검정/회귀) : 2문항, 각 15점

[ 작업형 제 1유형 ]

• 반올림(:round(), 자릿수)인지 소수점 버림(:int()) 인지 확인한다.
• loc[절대 index], iloc[상대 index]

# 사분위수 
df['컬럼'].quatile(0.25) # 0.25(1분위) 0.5(2분위) 0.75(3분위)
IQR = df['컬럼'].quatile(0.75) - df['컬럼'].quatile(0.25)

# 정렬
df.sort_values('칼럼', ascending=False)

# 결측치 삭제
df['칼럼'].dropna()
# 결측치 대체
df['칼럼'].fillna()

# 데이터표준화(z-score)
# z = x - m / std  
df['z-score'] = (df['hp']-df['hp'].mean())/df['hp'].std()

# 데이터정규화(min-max)
# minmax = x - min / max - min
df['mpg'] = (df['mpg']-df['mpg'].min()) / (df['mpg'].max() - df['mpg'].min())

# 이상치 확인
# upper = Q3 + 1.5*IQR
# lower = Q1 - 1.5*IQR
len(df[df['wt'] > upper]) + len(df[df['wt'] < lower])

# np 통해서 값 변환
df['hp'] = np.where(df['hp'] >= df_7th['hp'], df_7th['hp'], df['hp'])

# 문자열 추출
df[df['model'].str.contains("Merc")]['mpg'].mean()

# 날짜 변환함수
df['날짜'] = pd.to_datetime(df['날짜'])  # 예시 : df['날짜'].dt.month

# 인덱스로 세팅
df = df.set_index('time', drop = False)

[ 작업형 제 2유형 ]

• 다중분류의 경우 average=’macro’ 붙여야 한다.

import pandas as pd
import numpy as np

# 아래는 이미 주어짐
x_test.reset_index()
y_train.columns = ['target']
y_test.columns = ['target']

######## 실제 작업 ########'
# 라이브러리
# 데이터 분석
# 결측치,이상치 처리
# 데이터 전처리, 분리
# 모델링, 성능평가
# 예측값 제출

# 총 몇개가 있어야 하는지. 결측치 확인
x_train.info() 

# test데이터와 분포가 비슷한 train 데이터가 성능이 잘 나오므로, x_test와 x_train의 기초통계량을 비교한다.
print(x_test.describe())
print(x_train.describe())

# object, category 데이터도 추가 확인
print(x_train.describe(include='object'))
print(x_test.describe(include='object'))
print(x_train.describe(include='category'))
print(x_test.describe(include='category'))    

# 데이터 결측치, 이상치, 변수 처리하기
print(x_train.isnull().sum())
print(x_test.isnull().sum())
# x_train(712, 14) : age(133), embarked(2), deck(548), embarked_town(2)
# x_test(179, 14) : age(44), deck(140)

# 중복칼럼 제거
x_train = x_train.drop(columns = ['class', 'embark_town', 'alive', 'deck'])
x_test = x_test.drop(columns = ['class', 'embark_town', 'alive', 'deck'])

# 결측치 대체
med_age = x_train['age'].median()
x_train['age']=x_train['age'].fillna(med_age)
x_test['age']=x_test['age'].fillna(med_age)
# embarked - Object형
mode_et = x_train['embarked'].mode()
x_train['embarked'] = x_train['embarked'].fillna(mode_et[0]) # 최빈값[0] 주의!

# 변수처리(object, categories)
x_train = pd.get_dummies(x_train)
x_test = pd.get_dummies(x_test)
# 원핫 인코딩 이후 변수 수가 다른 경우
# x_train = x_train.reindex(columns = x_test.columns, fill_value=0) # test데이터 기준으로, 컬럼 추가하되 데이터는 0으로

# test 데이터 validation Set으로 나누고 점검
from sklearn.model_selection import train_test_split
x_train, x_val, y_train, y_val = train_test_split( x_train, y_train['target'], test_size=0.2, stratify=y_train['target'], random_state=2023)

from sklearn.ensemble import RandomForestClassifier  # 회귀: from sklearn.ensemble import RandomForestRegressor
model = RandomForestClassifier(random_state=2023)
model.fit(x_train, y_train)
y_pred = model.predict(x_val)

# 모델 성능평가 
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score, recall_score, precision_score # 회귀: from sklearn.metrics import mean_squared_error, r2_score
acc = accuracy_score(y_val, y_pred)
f1 = f1_score(y_val, y_pred)
auc = roc_auc_score(y_val, y_pred)
print(acc, f1, auc)

# 실제 결과 제출
# 특정 클래스로 분류하는 경우
y_class_result = model.predict(x_test)
# 특정 확률로 분류하는 경우
y_proba_result = model.predict_proba(x_test)

print(y_class_result, y_proba_result)
result = pd.DataFrame({'제출 양식에 맞춰': 지정 칼럼, 'target':y_class_result})

[ 작업형 제 3유형 ]

• pvalue 0.05보다 크면 귀무가설 채택.
  1. 모평균 검정 : 검정통계량, p-value, 귀무가설 판단
  • 모집단 1개 : 단일표본

# mtcars 데이터셋의 mpg 열 데이터의 평균이 20과 같다고 할 수 있는지 검정하시오

# 1. 가설검정
# H0: mpg열의 평균이 20과 같다
# H1: mpg열의 평균이 20과 같지 않다.
# 2. 유의수준 5%
# 3. 정규성 검정 - 단일은 필요없다.
# 귀무가설(H0) : 정규분포를 따른다.
# 대립가설(H1) : 정규분포를 따르지 않는다.

import scipy.stats as stats
from scipy.stats import shapiro
import pandas as pd
df = pd.read_csv("mtcars.csv")

# 통계량, pvalue
statistic, p_value = stats.shapiro(df['mpg'])
print(statistic, p_value)
# pvalue값이 유의수준 0.05보다 크므로 귀무가설을 선택한다.

# 정규성 만족하는 t-test
statistic, p_value = stats.ttest_1samp(df['mpg'], popmean=20, alternative='two-sided') # 대립가설 기준. 예를들어 대소비교(17보다 크다)가 오면 'greater', 반대는 'less' 
print(statistic, p_value)

# 정규성 만족안하면 wilcoxon
statistic, p_value = stats.wilcoxon(df['mpg']-20, alternative='two-sided')
print(statistic, p_value)

# pvalue값이 유의수준 0.05보다 크므로 귀무가설을 선택한다. 

• 모집단 2개 : 대응표본(쌍체), 독립표본

# mtcars 데이터셋의 mpg 열 데이터의 평균이 20과 같다고 할 수 있는지 검정하시오

# 대응표본(쌍체t검정) - 전,후 차이값에 대한 정규성
# 귀무가설 : before - after = 0 (대소가 중요하다면 ttest_rel-> alternative 함수가 바뀔것)
# 대립가설 : after - after != 0

import scipy.stats as stats
from scipy.stats import shapiro
import pandas as pd

statistic, p_value = stats.shapiro(df['after'] - df['before'])
print(statistic, p_value)

# 쌍체 t-test
statistic, p_value = stats.ttest_rel(df['after'] , df['before'],  alternative='two-sided') # 대립가설 기준. 예를들어 대소비교(17보다 크다)가 오면 'greater', 반대는 'less' 
print(statistic, p_value)

# pvalue값이 유의수준 0.05보다 크므로 귀무가설을 선택한다. 

# 독립표본 - 두 집단 모두 정규성을 따를 경우, 등분산 검정

# 귀무가설 : A그룹 == B그룹
# 대립가설 : A그룹 != B그룹

# 통계량, pvalue
statisticA, p_valueA = stats.shapiro(df['A'])
statisticB, p_valueB = stats.shapiro(df['B'])
print(statistic, p_value)

# 등분산인지 확인(귀무가 등분산)
statistic, p_value = stats.bartlett(df['A'], df['B'])

# 독립표본 tTest
statistic, p_value = stats.ttest_ind(df['A'] , df['B'], equal_var=True, alternative='two-sided') 

• 모집단 3개 : ANOVA(분산분석)
  1. 카이제곱검정 : 기댓값, 검정통계량, p-value, 귀무가설 판단

# 카이제곱 검정
from scipy.stats import chisquare
# 관측값, 기대값 구하기
f_obs = [30, 20, 15, 35]
f_exp = [25, 25, 25, 25] # 기대 비율이 있다면 해당 비율을 곱해준다

statisticschi, pvaluechi = chisquare(f_obs=f_obs, f_exp=f_exp)
# 적합도 검정 : 각 범주에 속할 확률이 같은지?
# 독립성 검정 : 두 개의 범주형 변수가 독립인지?
print(statisticschi, pvaluechi)

# 독립성 검정 : 두 개의 범주형 변수가 독립인지?
from scipy.stats import chi2_contingency
 
statistic, pvalue, dof, expected = chi2_contingency(df)

정리하며

여기까지가 빅데이터 분석기사 시험을 준비하며 공부한 내용들을 공유드렸습니다. 좋은 결과 있기를!👋