A A
[Data Analysis] 데이터 μ „μ²˜λ¦¬ (Data Pre-Processing)

Data Preprocessing (데이터 μ „μ²˜λ¦¬) κ°œμš”

데이터 μ „μ²˜λ¦¬λž€?

데이터 μ „μ²˜λ¦¬λŠ” μ›μ‹œ 데이터λ₯Ό 뢄석 및 λͺ¨λΈλ§μ— μ ν•©ν•˜κ²Œ λ³€ν™˜ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.
  • μ΄λŠ” λ°μ΄ν„°μ˜ μ •μ œ, λ³€ν™˜, 톡합 등을 ν¬ν•¨ν•˜λ©°, 데이터 ν’ˆμ§ˆμ„ λ†’μ—¬ μ‹ λ’°μ„± μžˆλŠ” 뢄석을 κ°€λŠ₯ν•˜κ²Œ ν•©λ‹ˆλ‹€.

 

데이터 μ „μ²˜λ¦¬μ˜ μ€‘μš”μ„± 및 ν•„μš”μ„±

데이터 μ „μ²˜λ¦¬λŠ” λ‹€μŒκ³Ό 같은 이유둜 맀우 μ€‘μš”ν•©λ‹ˆλ‹€.

  • 데이터 ν’ˆμ§ˆ ν–₯상: μ •ν™•ν•˜κ³  μΌκ΄€λœ 데이터λ₯Ό ν™•λ³΄ν•˜μ—¬ λΆ„μ„μ˜ 기초λ₯Ό 튼튼히 ν•©λ‹ˆλ‹€.
  • λͺ¨λΈ μ„±λŠ₯ μ΅œμ ν™”: 적절히 μ „μ²˜λ¦¬λœ λ°μ΄ν„°λŠ” λͺ¨λΈμ˜ μ„±λŠ₯을 ν–₯μƒμ‹œν‚€κ³ , 예츑 정확도λ₯Ό λ†’μž…λ‹ˆλ‹€.
  • λΆ„μ„μ˜ μ‹ λ’°μ„± ν–₯상: κΉ¨λ—ν•œ 데이터λ₯Ό μ‚¬μš©ν•¨μœΌλ‘œμ¨ 뢄석 결과의 신뒰성을 λ†’μž…λ‹ˆλ‹€.
  • 데이터 ν™œμš©μ˜ νš¨μœ¨μ„± ν–₯상: 데이터 μ „μ²˜λ¦¬λ₯Ό 톡해 뢄석 μž‘μ—…μ΄ 더 효율적으둜 μˆ˜ν–‰λ  수 μžˆμŠ΅λ‹ˆλ‹€.

 

데이터 μ „μ²˜λ¦¬μ˜ μ£Όμš” 단계

  • 데이터 μ •μ œ
    • κ²°μΈ‘κ°’ 처리: 데이터셋 λ‚΄ λˆ„λ½λœ 값을 μ²˜λ¦¬ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, ν‰κ· κ°’μœΌλ‘œ λŒ€μ²΄ν•˜κ±°λ‚˜ ν•΄λ‹Ή 데이터λ₯Ό μ œκ±°ν•©λ‹ˆλ‹€.
    • 이상값 탐지 및 μˆ˜μ •: λ°μ΄ν„°μ…‹μ—μ„œ λΉ„μ •μƒμ μœΌλ‘œ λ²—μ–΄λ‚œ 값을 μ°Ύμ•„λ‚΄κ³  μˆ˜μ •ν•©λ‹ˆλ‹€.
    • 쀑볡 데이터 제거: λ°μ΄ν„°μ…‹μ—μ„œ μ€‘λ³΅λœ 데이터λ₯Ό μ‹λ³„ν•˜κ³  μ œκ±°ν•©λ‹ˆλ‹€.
  • 데이터 λ³€ν™˜
    • 데이터 μŠ€μΌ€μΌλ§: λ°μ΄ν„°μ˜ λ²”μœ„λ₯Ό μ‘°μ •ν•˜μ—¬ λͺ¨λΈμ΄ 더 잘 ν•™μŠ΅ν•  수 μžˆλ„λ‘ ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, μ •κ·œν™”(normalization)λ‚˜ ν‘œμ€€ν™”(standardization)λ₯Ό μ μš©ν•©λ‹ˆλ‹€.
    • 데이터 인코딩: λ²”μ£Όν˜• 데이터λ₯Ό μˆ˜μΉ˜ν˜• λ°μ΄ν„°λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, 원-ν•« 인코딩(one-hot encoding)을 μ‚¬μš©ν•©λ‹ˆλ‹€.
  • 데이터 톡합 및 λ³€ν˜•
    • 데이터 병합: μ—¬λŸ¬ 데이터셋을 ν•˜λ‚˜λ‘œ κ²°ν•©ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, λ°μ΄ν„°λ² μ΄μŠ€ ν…Œμ΄λΈ”μ„ 쑰인(join)ν•©λ‹ˆλ‹€.
    • 데이터 집계 및 λ³€ν˜•: 데이터λ₯Ό μš”μ•½ν•˜κ³  λ³€ν˜•ν•˜μ—¬ 뢄석에 μ ν•©ν•œ ν˜•νƒœλ‘œ λ§Œλ“­λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, κ·Έλ£Ήν™”(grouping)ν•˜κ³  집계(aggregation) 연산을 μˆ˜ν–‰ν•©λ‹ˆλ‹€.

데이터 μˆ˜μ§‘ ν›„ μ „μ²˜λ¦¬ κ³Όμ •

데이터 μˆ˜μ§‘μ—μ„œ μ „μ²˜λ¦¬λ‘œμ˜ μ—°κ²°

데이터 λΆ„μ„μ˜ 첫 번째 λ‹¨κ³„λŠ” λ‹€μ–‘ν•œ μ†ŒμŠ€μ—μ„œ 데이터λ₯Ό μˆ˜μ§‘ν•˜λŠ” κ²ƒμž…λ‹ˆλ‹€.

 

데이터λ₯Ό μˆ˜μ§‘ν•˜λŠ” λ°©λ²•μ—λŠ” μ—¬λŸ¬ 가지가 있으며, λŒ€ν‘œμ μœΌλ‘œ OpenAPI, μ›Ή 크둀링 등이 μžˆμŠ΅λ‹ˆλ‹€.

  • OpenAPI: λˆ„κ΅¬λ‚˜ μ ‘κ·Όν•  수 μžˆλ„λ‘ 개방된 APIλ₯Ό 톡해 데이터λ₯Ό μˆ˜μ§‘ν•©λ‹ˆλ‹€.
  • μ›Ή 크둀링: μžλ™ν™”λœ 슀크립트λ₯Ό μ‚¬μš©ν•˜μ—¬ μ›Ή νŽ˜μ΄μ§€λ₯Ό νƒμƒ‰ν•˜κ³  데이터λ₯Ό μˆ˜μ§‘ν•©λ‹ˆλ‹€.

 

μˆ˜μ§‘λœ λ°μ΄ν„°μ˜ μ •μ œ ν•„μš”μ„±

μˆ˜μ§‘λœ λ°μ΄ν„°λŠ” λŒ€λΆ€λΆ„ μ •μ œκ°€ ν•„μš”ν•©λ‹ˆλ‹€. μ΄μœ λŠ” λ¬΄μ—‡μΌκΉŒμš”?
  • λ°μ΄ν„°λŠ” ν™œμš©μ„ λͺ©μ μœΌλ‘œ μˆ˜μ§‘ κ³„νšμ„ μ§  κ²½μš°κ°€ 거의 μ—†μŒ: λ°μ΄ν„°λŠ” μ’…μ’… λ‹€μ–‘ν•œ μΆœμ²˜μ—μ„œ μˆ˜μ§‘λ˜λ©°, 이 κ³Όμ •μ—μ„œ λ°μ΄ν„°μ˜ ν˜•μ‹, ꡬ쑰, ν’ˆμ§ˆμ΄ μΌκ΄€λ˜μ§€ μ•Šμ„ 수 μžˆμŠ΅λ‹ˆλ‹€.
  • 데이터 μˆ˜μ§‘μ΄ 먼저이고, μˆ˜μ§‘λœ 데이터λ₯Ό μ–΄λ–»κ²Œ ν•˜λ©΄ 잘 ν™œμš©ν•  수 μžˆμ„κΉŒλŠ” λ‚˜μ€‘μ— κ³ λ €: μˆ˜μ§‘λœ λ°μ΄ν„°λŠ” μ›μ‹œ μƒνƒœλ‘œ μ‘΄μž¬ν•˜λ©°, 이λ₯Ό 뢄석 및 λͺ¨λΈλ§μ— μ ν•©ν•˜κ²Œ λ³€ν™˜ν•˜λŠ” 과정이 ν•„μš”ν•©λ‹ˆλ‹€.

 

μˆ˜μ§‘λœ λ°μ΄ν„°μ˜ 초기 확인 및 뢄석

데이터λ₯Ό μˆ˜μ§‘ν•œ ν›„μ—λŠ” 이λ₯Ό 뢄석 및 λͺ¨λΈλ§μ— μ ν•©ν•˜κ²Œ λ§Œλ“€κΈ° μœ„ν•΄ 초기 확인 및 μ „μ²˜λ¦¬ 과정을 거쳐야 ν•©λ‹ˆλ‹€.
  • 데이터 뢈러였기
    • μˆ˜μ§‘λœ 데이터λ₯Ό 뢄석 ν™˜κ²½μœΌλ‘œ λΆˆλŸ¬μ˜΅λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, CSV 파일, λ°μ΄ν„°λ² μ΄μŠ€, API 응닡 등을 뢈러올 수 μžˆμŠ΅λ‹ˆλ‹€.
  • κΈ°λ³Έ 정보 확인
    • 데이터 ꡬ쑰: 데이터가 μ–΄λ–»κ²Œ κ΅¬μ„±λ˜μ–΄ μžˆλŠ”μ§€ ν™•μΈν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, λ°μ΄ν„°ν”„λ ˆμž„μ˜ ν–‰κ³Ό μ—΄ ꡬ쑰λ₯Ό νŒŒμ•…ν•©λ‹ˆλ‹€.
    • 데이터 크기: λ°μ΄ν„°μ…‹μ˜ 크기(ν–‰ μˆ˜μ™€ μ—΄ 수)λ₯Ό ν™•μΈν•©λ‹ˆλ‹€.
    • 데이터 νƒ€μž…: 각 μ—΄μ˜ 데이터 νƒ€μž…μ„ ν™•μΈν•˜μ—¬, μˆ«μžν˜•, λ¬Έμžμ—΄ν˜•, λ‚ μ§œν˜• λ“±μ˜ νƒ€μž…μ„ νŒŒμ•…ν•©λ‹ˆλ‹€.
  • 결츑치 및 μ΄μƒμΉ˜ 처리
    • 결츑치 처리: 데이터셋 λ‚΄ λˆ„λ½λœ 값을 ν™•μΈν•˜κ³  μ²˜λ¦¬ν•©λ‹ˆλ‹€. 결츑치λ₯Ό μ²˜λ¦¬ν•˜λŠ” λ°©λ²•μœΌλ‘œλŠ” ν‰κ· κ°’μœΌλ‘œ λŒ€μ²΄, μ‚­μ œ, λ˜λŠ” 예츑 λͺ¨λΈμ„ μ‚¬μš©ν•˜λŠ” 방법 등이 μžˆμŠ΅λ‹ˆλ‹€.
    • μ΄μƒμΉ˜ 처리: λΉ„μ •μƒμ μœΌλ‘œ λ²—μ–΄λ‚œ 값을 νƒμ§€ν•˜κ³  μ²˜λ¦¬ν•©λ‹ˆλ‹€. μ΄μƒμΉ˜λ₯Ό μ²˜λ¦¬ν•˜λŠ” λ°©λ²•μœΌλ‘œλŠ” ν•΄λ‹Ή 값을 μˆ˜μ •ν•˜κ±°λ‚˜ μ œκ±°ν•˜λŠ” 방법이 μžˆμŠ΅λ‹ˆλ‹€.

 


데이터 νƒ€μž…λ³„ μ „μ²˜λ¦¬ κ³Όμ •

μˆ«μžν˜• 데이터 μ „μ²˜λ¦¬

  1. κ²°μΈ‘κ°’ 및 이상값 처리
    • ν‰κ· κ°’μœΌλ‘œ λŒ€μ²΄: 결츑값을 ν•΄λ‹Ή μ—΄μ˜ ν‰κ· κ°’μœΌλ‘œ λŒ€μ²΄ν•©λ‹ˆλ‹€.
    • μ€‘μ•™κ°’μœΌλ‘œ λŒ€μ²΄: 결츑값을 ν•΄λ‹Ή μ—΄μ˜ μ€‘μ•™κ°’μœΌλ‘œ λŒ€μ²΄ν•©λ‹ˆλ‹€.
    • μ΄μ›ƒκ°’μœΌλ‘œ λŒ€μ²΄: 결츑값을 μΈμ ‘ν•œ κ°’μœΌλ‘œ λŒ€μ²΄ν•©λ‹ˆλ‹€.
    • 제거: 결츑값이 ν¬ν•¨λœ 행을 μ œκ±°ν•©λ‹ˆλ‹€.
  2. μŠ€μΌ€μΌλ§ 및 μ •κ·œν™”
    • μŠ€μΌ€μΌλ§: λ°μ΄ν„°μ˜ λ²”μœ„λ₯Ό μΌμ •ν•œ 크기둜 μ‘°μ •ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, Min-Max μŠ€μΌ€μΌλ§μ€ 데이터 값을 0κ³Ό 1 μ‚¬μ΄λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€.
    • μ •κ·œν™”: λ°μ΄ν„°μ˜ 뢄포λ₯Ό 평균이 0이고 ν‘œμ€€νŽΈμ°¨κ°€ 1인 μ •κ·œ λΆ„ν¬λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. μ΄λŠ” λͺ¨λΈμ˜ μ„±λŠ₯을 ν–₯μƒμ‹œν‚€λŠ” 데 μœ μš©ν•©λ‹ˆλ‹€.

 

λ²”μ£Όν˜• 데이터 μ „μ²˜λ¦¬

  1. κ²°μΈ‘κ°’ 및 이상값 처리
    • μ΅œλΉˆκ°’μœΌλ‘œ λŒ€μ²΄: 결츑값을 ν•΄λ‹Ή μ—΄μ—μ„œ κ°€μž₯ λΉˆλ²ˆν•˜κ²Œ λ‚˜νƒ€λ‚˜λŠ” κ°’μœΌλ‘œ λŒ€μ²΄ν•©λ‹ˆλ‹€.
  2. λ ˆμ΄λΈ” 인코딩
    • λ ˆμ΄λΈ” 인코딩: λ²”μ£Όν˜• 데이터λ₯Ό μˆ«μžν˜• λ°μ΄ν„°λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, 'A', 'B', 'C'와 같은 λ²”μ£Όλ₯Ό 각각 0, 1, 2둜 λ³€ν™˜ν•©λ‹ˆλ‹€.
    • 원-ν•« 인코딩: λ²”μ£Όν˜• 데이터λ₯Ό 이진 λ²‘ν„°λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, 'A', 'B', 'C'λŠ” [1, 0, 0], [0, 1, 0], [0, 0, 1]둜 λ³€ν™˜λ©λ‹ˆλ‹€.

 

λ‚ μ§œ 및 μ‹œκ°„ 데이터 μ „μ²˜λ¦¬

  • ν˜•μ‹ λ³€ν™˜ 및 μΆ”μΆœ
    • ν˜•μ‹ λ³€ν™˜: λ‚ μ§œ 및 μ‹œκ°„ 데이터λ₯Ό ν‘œμ€€ ν˜•μ‹μœΌλ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, λ¬Έμžμ—΄ ν˜•νƒœμ˜ λ‚ μ§œλ₯Ό datetime 객체둜 λ³€ν™˜ν•©λ‹ˆλ‹€.
    • μΆ”μΆœ: 연도, μ›”, 일, μ‹œκ°„, λΆ„, μ΄ˆμ™€ 같은 νŠΉμ • μš”μ†Œλ₯Ό μΆ”μΆœν•˜μ—¬ μƒˆλ‘œμš΄ λ³€μˆ˜λ‘œ μƒμ„±ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, '2023-07-12'μ—μ„œ 연도(2023), μ›”(7), 일(12)을 μΆ”μΆœν•©λ‹ˆλ‹€.

 

ν…μŠ€νŠΈ 데이터 μ „μ²˜λ¦¬

  • ν…μŠ€νŠΈ μ •μ œ 및 벑터화
    • ν…μŠ€νŠΈ μ •μ œ: λΆˆν•„μš”ν•œ 문자 제거, μ†Œλ¬Έμž λ³€ν™˜, 곡백 제거 λ“±μ˜ μ „μ²˜λ¦¬ 과정을 μˆ˜ν–‰ν•©λ‹ˆλ‹€.
    • 벑터화: ν…μŠ€νŠΈ 데이터λ₯Ό μˆ˜μΉ˜ν˜• λ°μ΄ν„°λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, 단어 λΉˆλ„ 벑터화(Bag-of-Words), TF-IDF, μ›Œλ“œ μž„λ² λ”©(Word Embedding) 등을 μ‚¬μš©ν•˜μ—¬ ν…μŠ€νŠΈλ₯Ό λ²‘ν„°λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€.

데이터 μ •μ œ - 결츑치의 μ’…λ₯˜

데이터 결츑치의 μ’…λ₯˜λŠ” μ•„λž˜μ™€ κ°™μŠ΅λ‹ˆλ‹€.

MCAR (Missing Completely at Random)

  • κ°œλ…: 데이터가 μ™„μ „νžˆ λ¬΄μž‘μœ„λ‘œ λˆ„λ½λœ 경우둜, λˆ„λ½λœ 데이터와 μ–΄λ–€ λ³€μˆ˜ 간에도 상관관계가 μ—†μŠ΅λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: μ„€λ¬Έ μ‘°μ‚¬μ—μ„œ λ¬΄μž‘μœ„λ‘œ μ§ˆλ¬Έμ„ κ±΄λ„ˆλ›΄ 경우. μ΄λŸ¬ν•œ λˆ„λ½μ€ νŠΉμ • νŒ¨ν„΄ 없이 λ°œμƒν•˜λ©°, 전체 데이터셋에 κ³ λ₯΄κ²Œ λΆ„ν¬λ©λ‹ˆλ‹€.

MAR (Missing at Random)

  • κ°œλ…: 데이터 λˆ„λ½μ΄ λ‹€λ₯Έ κ΄€μΈ‘ κ°€λŠ₯ν•œ λ³€μˆ˜μ™€ κ΄€λ ¨λœ 경우둜, λˆ„λ½λœ 데이터 μžμ²΄μ™€λŠ” 상관관계가 μ—†μŠ΅λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: λ‚˜μ΄κ°€ λ§Žμ€ μ‘λ‹΅μžλ“€μ΄ μ†Œλ“ 정보λ₯Ό μ œκ³΅ν•˜μ§€ μ•Šμ€ 경우. μ—¬κΈ°μ„œ λ‚˜μ΄λŠ” κ΄€μΈ‘ κ°€λŠ₯ν•œ λ³€μˆ˜λ‘œ, 이 λ³€μˆ˜μ™€ κ΄€λ ¨ν•˜μ—¬ μ†Œλ“ 정보가 λˆ„λ½λ©λ‹ˆλ‹€.

MNAR (Missing Not at Random)

  • κ°œλ…: 데이터 λˆ„λ½μ΄ 자체 λ³€μˆ˜μ™€ κ΄€λ ¨λœ 경우둜, λˆ„λ½λœ 데이터 μžμ²΄μ™€ 상관관계가 μžˆμŠ΅λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: 높은 μ†Œλ“μ„ 가진 μ‚¬λžŒλ“€μ΄ μ†Œλ“ 정보λ₯Ό μ œκ³΅ν•˜μ§€ μ•Šμ€ 경우. μ—¬κΈ°μ„œ μ†Œλ“ 정보 μžμ²΄κ°€ λˆ„λ½μ˜ 원인이 λ©λ‹ˆλ‹€.

 

데이터 μ •μ œ - κ²°μΈ‘κ°’μ˜ 원인

λ˜ν•œ κ²°μΈ‘κ°’μ˜ 원인은 3가지 원인이 μžˆμŠ΅λ‹ˆλ‹€.

데이터 μž…λ ₯ 였λ₯˜

  • κ°œλ…: μˆ˜λ™ μž…λ ₯ κ³Όμ •μ—μ„œ λ°œμƒν•˜λŠ” μ‹€μˆ˜λ‘œ 인해 데이터가 λˆ„λ½λ©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: 데이터 μž…λ ₯μžκ°€ μ‹€μˆ˜λ‘œ 값을 μž…λ ₯ν•˜μ§€ μ•Šκ±°λ‚˜, 잘λͺ»λœ 값을 μž…λ ₯ν•˜μ—¬ λˆ„λ½μ΄ λ°œμƒν•˜λŠ” 경우.

μ‘λ‹΅μžμ˜ 미응닡

  • κ°œλ…: μ„€λ¬Έ μ‘°μ‚¬λ‚˜ μΈν„°λ·°μ—μ„œ νŠΉμ • μ§ˆλ¬Έμ— λŒ€ν•œ 응닡이 λˆ„λ½λ˜λŠ” κ²½μš°μž…λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: μ‘λ‹΅μžκ°€ λ―Όκ°ν•œ μ§ˆλ¬Έμ— 닡변을 ν”Όν•˜κ±°λ‚˜, νŠΉμ • μ§ˆλ¬Έμ„ κ±΄λ„ˆλ›°λŠ” 경우.

데이터 μˆ˜μ§‘ κ³Όμ •μ˜ 문제

  • κ°œλ…: 데이터 μˆ˜μ§‘ κ³Όμ •μ—μ„œ λ°œμƒν•˜λŠ” 기술적 문제둜 인해 데이터가 λˆ„λ½λ©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: μ„Όμ„œ μ˜€μž‘λ™, 톡신 였λ₯˜, λ°μ΄ν„°λ² μ΄μŠ€ μ €μž₯ 문제 λ“±μœΌλ‘œ 인해 데이터가 μ œλŒ€λ‘œ μˆ˜μ§‘λ˜μ§€ μ•ŠλŠ” 경우.

데이터 μ •μ œ - μ΄μƒμΉ˜(Outlier)

Outlier(μ΄μƒμΉ˜)λŠ” 데이터 λΆ„ν¬μ—μ„œ λ²—μ–΄λ‚œ 극단적인 값을 μ˜λ―Έν•©λ‹ˆλ‹€.
μ΄λŠ” 데이터 μ„ΈνŠΈμ—μ„œ λ‹€λ₯Έ κ°’λ“€κ³Ό λΉ„κ΅ν–ˆμ„ λ•Œ ν˜„μ €νžˆ ν¬κ±°λ‚˜ μž‘μ€ 값을 κ°€λ¦¬ν‚΅λ‹ˆλ‹€.
  • Outlier(μ΄μƒμΉ˜)λŠ” 톡계적 뢄석과 λͺ¨λΈ μ„±λŠ₯에 큰 영ν–₯을 쀄 수 μžˆμŠ΅λ‹ˆλ‹€.
  • 예λ₯Ό λ“€μ–΄, 평균 값을 μ™œκ³‘ν•˜κ±°λ‚˜, νšŒκ·€ λΆ„μ„μ˜ κ²°κ³Όλ₯Ό λΆ€μ •ν™•ν•˜κ²Œ λ§Œλ“€ 수 μžˆμŠ΅λ‹ˆλ‹€.

 

Outlier(μ΄μƒμΉ˜)의 원인

데이터 μž…λ ₯ 였λ₯˜

  • κ°œλ…: μˆ˜λ™ 및 μžλ™ν™”λœ μ‹œμŠ€ν…œμ—μ„œ λ°œμƒν•  수 μžˆλŠ” 였λ₯˜λ‘œ 인해 μ΄μƒμΉ˜κ°€ λ°œμƒν•©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: μˆ˜λ™ 데이터 μž…λ ₯ μ‹œ μ‹€μˆ˜λ‘œ 잘λͺ»λœ 값을 μž…λ ₯ν•˜κ±°λ‚˜, μ„Όμ„œ μ˜€μž‘λ™μœΌλ‘œ 인해 비정상적인 데이터가 μˆ˜μ§‘λ˜λŠ” 경우.

데이터 μˆ˜μ§‘ 문제

  • κ°œλ…: 잘λͺ»λœ μˆ˜μ§‘ λ°©λ²•μ΄λ‚˜ 전솑 κ³Όμ •μ—μ„œμ˜ 였λ₯˜λ‘œ 인해 μ΄μƒμΉ˜κ°€ λ°œμƒν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: 데이터 전솑 쀑 λ„€νŠΈμ›Œν¬ 문제둜 μΈν•œ κ°’μ˜ 손상 λ˜λŠ” 데이터 μˆ˜μ§‘ μž₯λΉ„μ˜ μ˜€μž‘λ™μœΌλ‘œ μΈν•œ 였λ₯˜.

이질적인 데이터

  • κ°œλ…: μ„œλ‘œ λ‹€λ₯Έ νŠΉμ„±μ„ 가진 그룹의 ν˜Όν•©μ΄λ‚˜ λ“œλ¬Έ 이벀트둜 인해 λ°œμƒν•˜λŠ” μ΄μƒμΉ˜μž…λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: μ„œλ‘œ λ‹€λ₯Έ μ—°λ ΉλŒ€μ˜ 데이터가 ν•˜λ‚˜μ˜ 데이터셋에 ν¬ν•¨λ˜μ–΄ 평균 연령을 μ™œκ³‘μ‹œν‚€λŠ” 경우.

μžμ—°μ  변동성

  • κ°œλ…: λ°μ΄ν„°μ˜ μžμ—°μŠ€λŸ¬μš΄ λ³€λ™μ„±μœΌλ‘œ 인해 μ΄μƒμΉ˜κ°€ λ°œμƒν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: 일일 기온 λ°μ΄ν„°μ—μ„œ μžμ—°μŠ€λŸ½κ²Œ λ°œμƒν•˜λŠ” 극단적인 기온 λ³€ν™”.

νŠΉμ΄ν•œ 상황 λ˜λŠ” 쑰건

  • κ°œλ…: νŠΉμ • μƒν™©μ—μ„œλ§Œ λ°œμƒν•˜λŠ” μ˜ˆμ™Έμ μΈ κ°’μœΌλ‘œ 인해 μ΄μƒμΉ˜κ°€ λ°œμƒν•©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: νŠΉμ • λ‚ μ—λ§Œ λ°œμƒν•˜λŠ” 극단적인 νŒλ§€λŸ‰ 증가, 예λ₯Ό λ“€μ–΄ λΈ”λž™ 프라이데이 같은 이벀트.

데이터 λ³€ν™˜

Scaling (μŠ€μΌ€μΌλ§)

μŠ€μΌ€μΌλ§μ€ λ°μ΄ν„°μ˜ λ²”μœ„λ₯Ό μž„μ˜λ‘œ μ‘°μ •ν•΄μ£ΌλŠ” κ³Όμ •μž…λ‹ˆλ‹€.
  • μ΄λŠ” λͺ¨λΈ ν•™μŠ΅ μ‹œ λ‹€μ–‘ν•œ νŠΉμ„±μ˜ λ‹¨μœ„ 차이λ₯Ό μ—†μ• κ³ , λ™μΌν•œ μŠ€μΌ€μΌλ‘œ μ‘°μ •ν•˜μ—¬ ν•™μŠ΅μ„ 더 효과적으둜 ν•  수 μžˆλ„λ‘ λ•μŠ΅λ‹ˆλ‹€.

 

Standardization (ν‘œμ€€ν™”)

ν‘œμ€€ν™”λŠ” λ°μ΄ν„°μ˜ 평균을 0, ν‘œμ€€νŽΈμ°¨λ₯Ό 1둜 λ³€ν™˜ν•˜μ—¬ λ°μ΄ν„°μ˜ 뢄포λ₯Ό ν‘œμ€€μ •κ·œ λΆ„ν¬λ‘œ λ§Œλ“œλŠ” κ³Όμ •μž…λ‹ˆλ‹€.

ν‘œμ€€ν™” 곡식

  • 이λ₯Ό 톡해 λ°μ΄ν„°μ˜ 쀑심을 0으둜 λ§žμΆ”κ³ , 뢄포λ₯Ό μΌμ •ν•˜κ²Œ ν•©λ‹ˆλ‹€.
  • 예λ₯Ό λ“€μ–΄, 킀와 λͺΈλ¬΄κ²Œ 데이터λ₯Ό ν‘œμ€€ν™”ν•˜λ©΄, 각 데이터 ν¬μΈνŠΈλŠ” ν‰κ· μ—μ„œ μ–Όλ§ˆλ‚˜ λ–¨μ–΄μ Έ μžˆλŠ”μ§€, ν‘œμ€€νŽΈμ°¨ λ‹¨μœ„λ‘œ ν‘œν˜„λ©λ‹ˆλ‹€.

 

Normalization (μ •κ·œν™”)

μ •κ·œν™”λŠ” 데이터λ₯Ό νŠΉμ • λ²”μœ„λ‘œ λ³€ν™˜ν•˜λŠ” κ³Όμ •μž…λ‹ˆλ‹€.

μ •κ·œν™” 곡식

  • 주둜 0μ—μ„œ 1 μ‚¬μ΄μ˜ λ²”μœ„λ‘œ λ³€ν™˜ν•˜λ©°, μ΄λŠ” regularization(κ·œμ œν™”)μ™€λŠ” λ‹€λ¦…λ‹ˆλ‹€.
  • 예λ₯Ό λ“€μ–΄, 가격 데이터가 0μ—μ„œ 1 μ‚¬μ΄λ‘œ μ •κ·œν™”λ˜λ©΄, λͺ¨λ“  가격 값이 ν•΄λ‹Ή λ²”μœ„ 내에 μœ„μΉ˜ν•˜κ²Œ λ©λ‹ˆλ‹€.

 

데이터 λ³€ν™˜μ˜ 이유

그러면 μš°λ¦¬κ°€ 데이터 뢄석을 ν• λ•Œ 데이터 λ³€ν™˜μ„ ν•˜λŠ” μ΄μœ λŠ” λ¬΄μ—‡μΌκΉŒμš”?
  • λ‹¨μœ„ 차이 제거
    • λ‹€μ–‘ν•œ νŠΉμ„±μ˜ λ‹¨μœ„ 차이λ₯Ό μ—†μ• κ³ , λ™μΌν•œ μŠ€μΌ€μΌλ‘œ μ‘°μ •ν•˜μ—¬ λͺ¨λΈ ν•™μŠ΅μ— 도움을 μ€λ‹ˆλ‹€.
    • 예λ₯Ό λ“€μ–΄, ν‚€(cm)와 λͺΈλ¬΄κ²Œ(kg)의 λ‹¨μœ„ 차이λ₯Ό μ œκ±°ν•©λ‹ˆλ‹€.
  • κ³„μ‚°μ˜ μ•ˆμ •μ„±κ³Ό 속도 ν–₯상
    • 데이터λ₯Ό μΌμ •ν•œ λ²”μœ„λ‘œ μ‘°μ •ν•˜μ—¬ κ³„μ‚°μ˜ μ•ˆμ •μ„±κ³Ό 속도λ₯Ό ν–₯μƒμ‹œν‚΅λ‹ˆλ‹€.
    • μ΄λŠ” 특히 Gradient Descent(경사 ν•˜κ°•λ²•)κ³Ό 같은 μ΅œμ ν™” μ•Œκ³ λ¦¬μ¦˜μ—μ„œ μ€‘μš”ν•©λ‹ˆλ‹€.
  • λͺ¨λΈ μ„±λŠ₯ ν–₯상
    • μŠ€μΌ€μΌλ§λœ λ°μ΄ν„°λŠ” λͺ¨λΈμ΄ 더 λΉ λ₯΄κ³  μ •ν™•ν•˜κ²Œ μˆ˜λ ΄ν•˜λ„λ‘ λ„μ™€μ€λ‹ˆλ‹€.
    • μ΄λŠ” 특히 신경망과 같은 λ³΅μž‘ν•œ λͺ¨λΈμ—μ„œ μ€‘μš”ν•œ 역할을 ν•©λ‹ˆλ‹€.

Data Encoding (데이터 인코딩)

Label Encoding (λ ˆμ΄λΈ” 인코딩)

λ ˆμ΄λΈ” 인코딩은 λ²”μ£Όν˜• 데이터λ₯Ό 숫자둜 λ³€ν™˜ν•˜λŠ” κΈ°λ²•μž…λ‹ˆλ‹€. 각 λ²”μ£Όλ₯Ό κ³ μœ ν•œ μ •μˆ˜λ‘œ λ§€ν•‘ν•˜μ—¬ μˆ˜μΉ˜ν˜• λ°μ΄ν„°λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€.

 

  • λ³€ν™˜ 방식: 각 λ²”μ£Όλ₯Ό κ³ μœ ν•œ μ •μˆ˜ κ°’μœΌλ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, ['사과', 'λ°”λ‚˜λ‚˜', '체리']λ₯Ό [0, 1, 2]둜 λ³€ν™˜ν•©λ‹ˆλ‹€.
  • μž₯점: λ‹¨μˆœν•˜κ³ , λ©”λͺ¨λ¦¬ μ‚¬μš©λŸ‰μ΄ μ μŠ΅λ‹ˆλ‹€.
  • 단점: λ²”μ£Ό κ°„ μˆœμ„œκ°€ μ—†λŠ” 경우, λͺ¨λΈμ΄ 잘λͺ»λœ 관계λ₯Ό ν•™μŠ΅ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • 예λ₯Ό λ“€μ–΄, '사과', 'λ°”λ‚˜λ‚˜', '체리'κ°€ 0, 1, 2둜 λ³€ν™˜λ˜λ©΄, λͺ¨λΈμ΄ '사과'와 'λ°”λ‚˜λ‚˜' 사이에 μˆœμ„œ 관계가 μžˆλ‹€κ³  μ˜€μΈν•  수 μžˆμŠ΅λ‹ˆλ‹€.

Label Encoding Example

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
labels = ['사과', 'λ°”λ‚˜λ‚˜', '체리']
encoded_labels = le.fit_transform(labels)
print(encoded_labels)  # Output: [0, 1, 2]

 

One-Hot Encoding (원-ν•« 인코딩)

원-ν•« 인코딩은 λ²”μ£Όν˜• 데이터λ₯Ό 이진 λ²‘ν„°λ‘œ λ³€ν™˜ν•˜λŠ” κΈ°λ²•μž…λ‹ˆλ‹€. 각 λ²”μ£ΌλŠ” 이진 λ²‘ν„°μ˜ κ³ μœ ν•œ μœ„μΉ˜μ— 1둜 ν‘œμ‹œλ©λ‹ˆλ‹€.
이λ₯Ό 톡해 λ²”μ£Ό κ°„ μˆœμ„œκ°€ μ—†λŠ” 데이터λ₯Ό μ²˜λ¦¬ν•  λ•Œ μœ μš©ν•©λ‹ˆλ‹€.

 

  • λ³€ν™˜ 방식: 각 λ²”μ£Όλ₯Ό 이진 λ²‘ν„°λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, ['사과', 'λ°”λ‚˜λ‚˜', '체리']λ₯Ό [[1, 0, 0], [0, 1, 0], [0, 0, 1]]둜 λ³€ν™˜ν•©λ‹ˆλ‹€.
  • μž₯점: λ²”μ£Ό κ°„ μˆœμ„œ 관계가 μ—†μŒμ„ λͺ…ν™•νžˆ ν‘œν˜„ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • 단점: λ§Žμ€ λ²”μ£Όκ°€ μžˆλŠ” 경우, 고차원 λ°μ΄ν„°λ‘œ λ³€ν™˜λ˜μ–΄ λ©”λͺ¨λ¦¬ μ‚¬μš©λŸ‰μ΄ 증가할 수 μžˆμŠ΅λ‹ˆλ‹€.

One-Hot Encoding Example

from sklearn.preprocessing import OneHotEncoder
import numpy as np

ohe = OneHotEncoder(sparse=False)
labels = np.array(['사과', 'λ°”λ‚˜λ‚˜', '체리']).reshape(-1, 1)
encoded_labels = ohe.fit_transform(labels)
print(encoded_labels)

# Output: [[1. 0. 0.]
#          [0. 1. 0.]
#          [0. 0. 1.]]

 


날씨 & μ‹œκ°„ 데이터 λ³€ν™˜

ν˜•μ‹ λ³€ν™˜μ΄λž€?

ν˜•μ‹ λ³€ν™˜μ€ λ¬Έμžμ—΄ ν˜•μ‹μ˜ λ‚ μ§œ 데이터λ₯Ό 'datetime' ν˜•μ‹μœΌλ‘œ λ³€ν™˜ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€. 
  • λ‚ μ§œ μ—°μ‚° 및 비ꡐλ₯Ό μ‰½κ²Œ μˆ˜ν–‰ν•  수 μžˆλ„λ‘ ν•˜κΈ° μœ„ν•΄ μ§„ν–‰λ©λ‹ˆλ‹€.
  • ν•„μš”μ„±: λ‚ μ§œ 데이터λ₯Ό datetime ν˜•μ‹μœΌλ‘œ λ³€ν™˜ν•˜λ©΄, λ‚ μ§œ κ°„μ˜ 차이λ₯Ό κ³„μ‚°ν•˜κ±°λ‚˜ νŠΉμ • λ‚ μ§œλ₯Ό κΈ°μ€€μœΌλ‘œ 데이터λ₯Ό μ •λ ¬ν•˜λŠ” λ“±μ˜ μž‘μ—…μ΄ κ°„νŽΈν•΄μ§‘λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: "2023-07-12"와 같은 λ¬Έμžμ—΄ ν˜•μ‹μ˜ λ‚ μ§œλ₯Ό datetime 객체둜 λ³€ν™˜ν•˜μ—¬ λ‹€μ–‘ν•œ λ‚ μ§œ 연산을 μˆ˜ν–‰ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

ν˜•μ‹ λ³€ν™˜ Example

import pandas as pd

# λ¬Έμžμ—΄ ν˜•μ‹μ˜ λ‚ μ§œ 데이터
date_str = "2023-07-12"

# datetime ν˜•μ‹μœΌλ‘œ λ³€ν™˜
date_dt = pd.to_datetime(date_str)
print(date_dt) 

# Output: 2023-07-12 00:00:00

 

μΆ”μΆœ

μΆ”μΆœμ€ 'datetime' κ°μ²΄μ—μ„œ νŠΉμ • 정보(연도, μ›”, 일 λ“±)λ₯Ό μΆ”μΆœν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.
  • λ‚ μ§œ λ°μ΄ν„°μ—μ„œ νŠΉμ • 정보λ₯Ό μΆ”μΆœν•˜μ—¬ 뢄석에 ν™œμš©ν•˜κΈ° μœ„ν•΄ μ§„ν–‰λ©λ‹ˆλ‹€.
  • ν•„μš”μ„±: 뢄석 λͺ©μ μ— 따라 연도, μ›”, 일, μ‹œκ°„ λ“±μ˜ νŠΉμ • 정보λ₯Ό μΆ”μΆœν•˜μ—¬ μ‚¬μš©ν•΄μ•Ό ν•˜λŠ” κ²½μš°κ°€ λ§ŽμŠ΅λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, 월별 νŒλ§€λŸ‰μ„ λΆ„μ„ν•˜κ±°λ‚˜ νŠΉμ • κΈ°κ°„ λ™μ•ˆμ˜ λ³€ν™”λ₯Ό νŒŒμ•…ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: datetime κ°μ²΄μ—μ„œ 연도, μ›”, 일을 μΆ”μΆœν•˜μ—¬ μƒˆλ‘œμš΄ λ³€μˆ˜λ₯Ό 생성할 수 μžˆμŠ΅λ‹ˆλ‹€.

μΆ”μΆœ Example

import pandas as pd

# datetime ν˜•μ‹μ˜ λ‚ μ§œ 데이터
date_dt = pd.to_datetime("2023-07-12")

# 연도, μ›”, 일 μΆ”μΆœ
year = date_dt.year
month = date_dt.month
day = date_dt.day

print(f"Year: {year}, Month: {month}, Day: {day}")

# Output: Year: 2023, Month: 7, Day: 12

데이터 톡합 및 λ³€ν™˜

데이터 ν•©μΉ˜κΈ°

데이터 ν•©μΉ˜κΈ°λŠ” μ—¬λŸ¬ 데이터λ₯Ό ν•˜λ‚˜λ‘œ κ²°ν•©ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.
κ³΅ν†΅λœ ν‚€ λ˜λŠ” 인덱슀λ₯Ό μ‚¬μš©ν•˜μ—¬ 데이터 κ°„μ˜ 관계λ₯Ό λ°”νƒ•μœΌλ‘œ 데이터λ₯Ό κ²°ν•©ν•©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: 고객 정보 데이터와 거래 λ‚΄μ—­ 데이터λ₯Ό κ²°ν•©ν•˜μ—¬ 고객 행동을 뢄석할 수 μžˆμŠ΅λ‹ˆλ‹€.
import pandas as pd

# μ˜ˆμ‹œ λ°μ΄ν„°ν”„λ ˆμž„
customer_data = pd.DataFrame({
    'customer_id': [1, 2, 3],
    'name': ['Alice', 'Bob', 'Charlie']
})

transaction_data = pd.DataFrame({
    'customer_id': [1, 2, 1, 3],
    'purchase_amount': [100, 150, 200, 50]
})

# 데이터 ν•©μΉ˜κΈ°
merged_data = pd.merge(customer_data, transaction_data, on='customer_id')
print(merged_data)
   customer_id     name  purchase_amount
0            1    Alice              100
1            1    Alice              200
2            2      Bob              150
3            3  Charlie               50

 

데이터 집계

데이터 μ§‘κ³„λŠ” λ°μ΄ν„°μ˜ νŠΉμ • 열을 κΈ°μ€€μœΌλ‘œ 합계, 평균 λ“±μ˜ μš”μ•½ 톡계λ₯Ό κ³„μ‚°ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€. κ·Έλ£Ήλ³„λ‘œ 데이터λ₯Ό μš”μ•½ν•©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: 월별 맀좜 λ°μ΄ν„°μ—μ„œ 각 μ›”μ˜ 총 λ§€μΆœμ„ 계산할 수 μžˆμŠ΅λ‹ˆλ‹€.
import pandas as pd

# μ˜ˆμ‹œ λ°μ΄ν„°ν”„λ ˆμž„
sales_data = pd.DataFrame({
    'month': ['Jan', 'Feb', 'Jan', 'Feb', 'Mar'],
    'sales': [200, 150, 300, 200, 250]
})

# 월별 총 맀좜 계산
monthly_sales = sales_data.groupby('month').sum()
print(monthly_sales)
       sales
month       
Feb      350
Jan      500
Mar      250

 

 

데이터 κ·Έλ£Ήν™”

데이터 κ·Έλ£Ήν™”λŠ” νŠΉμ • 열을 κΈ°μ€€μœΌλ‘œ 데이터λ₯Ό κ·Έλ£Ήν™”ν•˜μ—¬ μ§‘κ³„ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: 각 μ œν’ˆκ΅°λ³„ 평균 νŒλ§€λŸ‰μ„ 계산할 수 μžˆμŠ΅λ‹ˆλ‹€.
import pandas as pd

# μ˜ˆμ‹œ λ°μ΄ν„°ν”„λ ˆμž„
product_data = pd.DataFrame({
    'product': ['A', 'B', 'A', 'B', 'C'],
    'sales': [100, 200, 150, 250, 300]
})

# μ œν’ˆκ΅°λ³„ 평균 νŒλ§€λŸ‰ 계산
product_sales = product_data.groupby('product').mean()
print(product_sales)
         sales
product       
A        125.0
B        225.0
C        300.0

 

 

데이터 λ³€κ²½ (μž¬κ΅¬μ‘°ν™”)

데이터 λ³€ν˜•μ€ λ°μ΄ν„°ν”„λ ˆμž„μ˜ ν˜•νƒœλ₯Ό λ³€κ²½ν•˜λŠ” λ‹€μ–‘ν•œ 기법을 μ˜λ―Έν•©λ‹ˆλ‹€. 데이터λ₯Ό μš”μ•½ν•˜κ±°λ‚˜ 뢄석 λͺ©μ μ— 맞게 μž¬κ΅¬μ„±ν•©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: κΈ΄ ν˜•μ‹μ˜ 데이터λ₯Ό 넓은 ν˜•μ‹μœΌλ‘œ λ³€ν™˜ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
import pandas as pd

# μ˜ˆμ‹œ λ°μ΄ν„°ν”„λ ˆμž„
long_data = pd.DataFrame({
    'date': ['2023-07-01', '2023-07-01', '2023-07-02'],
    'variable': ['A', 'B', 'A'],
    'value': [10, 20, 15]
})

# 넓은 ν˜•μ‹μœΌλ‘œ λ³€ν™˜
wide_data = long_data.pivot(index='date', columns='variable', values='value')
print(wide_data)
ariable       A     B
date                  
2023-07-01  10.0  20.0
2023-07-02  15.0   NaN

 

 

데이터 ν”Όλ²—

데이터 피벗은 λ°μ΄ν„°ν”„λ ˆμž„μ˜ ν–‰κ³Ό 열을 λ³€ν™˜ν•˜μ—¬ 데이터λ₯Ό μš”μ•½ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.
νŠΉμ • 열을 인덱슀둜 μ‚¬μš©ν•˜κ³ , λ‹€λ₯Έ 열을 μƒˆλ‘œμš΄ μ—΄λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€.
  • μ˜ˆμ‹œ: 월별 μ œν’ˆ 판맀 데이터λ₯Ό ν”Όλ²—ν•˜μ—¬ 각 μ œν’ˆμ˜ 월별 νŒλ§€λŸ‰μ„ μ—΄λ‘œ λ³€ν™˜ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
import pandas as pd

# μ˜ˆμ‹œ λ°μ΄ν„°ν”„λ ˆμž„
sales_data = pd.DataFrame({
    'month': ['Jan', 'Jan', 'Feb', 'Feb', 'Mar'],
    'product': ['A', 'B', 'A', 'B', 'A'],
    'sales': [100, 150, 200, 250, 300]
})

# 데이터 ν”Όλ²—
pivot_data = sales_data.pivot(index='month', columns='product', values='sales')
print(pivot_data)
product      A      B
month                
Feb      200.0  250.0
Jan      100.0  150.0
Mar      300.0    NaN

데이터 μ „μ²˜λ¦¬ Advanced

νŒŒμƒλ³€μˆ˜ 생성

νŒŒμƒ λ³€μˆ˜ 생성은 κΈ°μ‘΄ λ°μ΄ν„°μ—μ„œ μƒˆλ‘œμš΄ λ³€μˆ˜λ₯Ό μƒμ„±ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.
  • μ΄λŠ” κΈ°μ‘΄ λ³€μˆ˜ κ°„μ˜ μƒν˜Έμž‘μš©, 계산 λ˜λŠ” λ³€ν™˜μ„ 톡해 μƒˆλ‘œμš΄ 정보λ₯Ό μΆ”μΆœν•˜μ—¬ λ°μ΄ν„°μ˜ μ •λ³΄λŸ‰μ„ μ¦κ°€μ‹œν‚΅λ‹ˆλ‹€.
  • λ˜ν•œ 뢄석 및 λͺ¨λΈλ§ μ„±λŠ₯을 ν–₯μƒμ‹œν‚΅λ‹ˆλ‹€.

 

  • λ‚ μ§œ λ°μ΄ν„°μ—μ„œ νŒŒμƒ λ³€μˆ˜ μΆ”μΆœ
    • μ˜ˆμ‹œ: 연도, μ›”, 일, μš”μΌ 등을 μΆ”μΆœν•˜μ—¬ λΆ„μ„μ˜ 깊이λ₯Ό 더할 수 μžˆμŠ΅λ‹ˆλ‹€.
import pandas as pd

# λ‚ μ§œ 데이터
df = pd.DataFrame({'date': pd.to_datetime(['2023-07-12', '2023-07-13'])})
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['weekday'] = df['date'].dt.weekday
print(df)

 

  • ν…μŠ€νŠΈ λ°μ΄ν„°μ—μ„œ νŒŒμƒ λ³€μˆ˜ 생성
    • μ˜ˆμ‹œ: ν…μŠ€νŠΈ 길이, 단어 수 등을 νŒŒμƒ λ³€μˆ˜λ‘œ 생성할 수 μžˆμŠ΅λ‹ˆλ‹€.
df = pd.DataFrame({'text': ['This is a sentence.', 'Another sentence here.']})
df['text_length'] = df['text'].apply(len)
df['word_count'] = df['text'].apply(lambda x: len(x.split()))
print(df)

 

  • 킀와 λͺΈλ¬΄κ²Œλ₯Ό μ΄μš©ν•œ BMI 데이터 생성
    • μ˜ˆμ‹œ: BMI = λͺΈλ¬΄κ²Œ / (ν‚€/100)^2
df = pd.DataFrame({'height': [170, 180], 'weight': [70, 80]})
df['BMI'] = df['weight'] / (df['height'] / 100) ** 2
print(df)

 

 

Data Sampling (데이터 μƒ˜ν”Œλ§)

데이터 μƒ˜ν”Œλ§μ€ 전체 λ°μ΄ν„°μ…‹μ—μ„œ 일뢀 데이터λ₯Ό μ„ νƒν•˜μ—¬ λΆ„μ„μ΄λ‚˜ λͺ¨λΈλ§μ— μ‚¬μš©ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.
μ΄λŠ” λͺ¨μ§‘λ‹¨μ˜ νŠΉμ„±μ„ λŒ€ν‘œν•˜λŠ” μƒ˜ν”Œμ„ μΆ”μΆœν•˜μ—¬ λΆ„μ„μ˜ 신속성을 높이고, λŒ€μš©λŸ‰ 데이터 처리 μ‹œκ°„κ³Ό λΉ„μš©μ„ μ ˆκ°ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

 

  • 랜덀 μƒ˜ν”Œλ§: λ°μ΄ν„°μ…‹μ—μ„œ λ¬΄μž‘μœ„λ‘œ μƒ˜ν”Œμ„ μΆ”μΆœν•©λ‹ˆλ‹€.
df = pd.DataFrame({'data': range(100)})
sample = df.sample(n=10)
print(sample)
  • μΈ΅ν™” μƒ˜ν”Œλ§: λͺ¨μ§‘단을 μ—¬λŸ¬ 측으둜 λ‚˜λˆ„κ³  각 μΈ΅μ—μ„œ μƒ˜ν”Œμ„ μΆ”μΆœν•©λ‹ˆλ‹€.
from sklearn.model_selection import train_test_split

df = pd.DataFrame({'data': range(100), 'group': [0, 1] * 50})
train, test = train_test_split(df, test_size=0.2, stratify=df['group'])
print(train['group'].value_counts())
print(test['group'].value_counts())

 

PCA (차원 μΆ•μ†Œ 기법)

차원 μΆ•μ†Œ 기법은 고차원 데이터λ₯Ό μ €μ°¨μ›μœΌλ‘œ λ³€ν™˜ν•˜μ—¬ λ°μ΄ν„°μ˜ λ³΅μž‘μ„±μ„ μ€„μ΄λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.

  • μ΄λŠ” λ°μ΄ν„°μ˜ 변동성을 μ΅œλŒ€ν•œ λ³΄μ‘΄ν•˜λ©΄μ„œ μ£Όμš” νŠΉμ„±μ„ μΆ”μΆœν•˜μ—¬ λ°μ΄ν„°μ˜ μ‹œκ°ν™”μ™€ 이해λ₯Ό μš©μ΄ν•˜κ²Œ ν•˜κ³ , λͺ¨λΈμ˜ 과적합을 λ°©μ§€ν•˜λ©° 계산 νš¨μœ¨μ„±μ„ ν–₯μƒμ‹œν‚΅λ‹ˆλ‹€.
  • PCA (Principal Component Analysis): λ°μ΄ν„°μ˜ 뢄산을 μ΅œλŒ€ν•œ λ³΄μ‘΄ν•˜λŠ” μƒˆλ‘œμš΄ 좕을 μ°Ύμ•„ 데이터λ₯Ό λ³€ν™˜ν•©λ‹ˆλ‹€.
from sklearn.decomposition import PCA
import numpy as np

# μ˜ˆμ‹œ 데이터
data = np.random.rand(100, 5)
pca = PCA(n_components=2)
reduced_data = pca.fit_transform(data)
print(reduced_data)

 

  • t-SNE (t-distributed Stochastic Neighbor Embedding): 고차원 데이터λ₯Ό μ €μ°¨μ›μœΌλ‘œ λ³€ν™˜ν•˜μ—¬ λ°μ΄ν„°μ˜ ꡬ쑰λ₯Ό μ‹œκ°ν™”ν•˜λŠ” 데 μœ μš©ν•œ κΈ°λ²•μž…λ‹ˆλ‹€.
from sklearn.manifold import TSNE

# μ˜ˆμ‹œ 데이터
data = np.random.rand(100, 5)
tsne = TSNE(n_components=2)
reduced_data = tsne.fit_transform(data)
print(reduced_data)

데이터 μ „μ²˜λ¦¬ μ΅œμ ν™”

μ „μ²˜λ¦¬ μž‘μ—…μ˜ μžλ™ν™”

μ „μ²˜λ¦¬ μž‘μ—…μ˜ μžλ™ν™”λŠ” 반볡적이고 μΌκ΄€λœ μ „μ²˜λ¦¬ μž‘μ—…μ„ μžλ™μœΌλ‘œ μˆ˜ν–‰ν•˜μ—¬ νš¨μœ¨μ„±μ„ λ†’μ΄λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.

 

μ΄λŠ” 슀크립트 및 νŒŒμ΄ν”„λΌμΈμ„ μ‚¬μš©ν•˜μ—¬ μ „μ²˜λ¦¬ μž‘μ—…μ„ μžλ™μœΌλ‘œ μ‹€ν–‰ν•©λ‹ˆλ‹€.

  • νš¨μœ¨μ„±: μˆ˜λ™ μž‘μ—…μ˜ 였λ₯˜λ₯Ό 쀄이고, μž‘μ—… μ‹œκ°„μ„ λ‹¨μΆ•ν•˜λ©°, 일관성을 μœ μ§€ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • μžλ™ν™” 도ꡬ: μŠ€ν¬λ¦½νŠΈμ™€ νŒŒμ΄ν”„λΌμΈμ„ ν™œμš©ν•˜μ—¬ μ „μ²˜λ¦¬ μž‘μ—…μ„ μžλ™ν™”ν•©λ‹ˆλ‹€.

 

νŒŒμ΄ν”„λΌμΈ ꡬ좕

νŒŒμ΄ν”„λΌμΈ ꡬ좕은 일련의 μ „μ²˜λ¦¬ 단계λ₯Ό 순차적으둜 μžλ™μœΌλ‘œ μ‹€ν–‰ν•˜λŠ” 과정을 μ˜λ―Έν•©λ‹ˆλ‹€.
각 λ‹¨κ³„λ³„λ‘œ μ „μ²˜λ¦¬ μž‘μ—…μ„ μ •μ˜ν•˜κ³  이λ₯Ό νŒŒμ΄ν”„λΌμΈμœΌλ‘œ μ—°κ²°ν•˜μ—¬ μ „μ²˜λ¦¬ μž‘μ—…μ˜ 일관성과 μž¬ν˜„μ„±μ„ 보μž₯ν•©λ‹ˆλ‹€.

 

  • μ‹€μ œ μ½”λ“œμƒμ˜ νŒŒμ΄ν”„λΌμΈ: 코딩을 톡해 μ „μ²˜λ¦¬ νŒŒμ΄ν”„λΌμΈμ„ μž‘μ„±ν•˜μ—¬ μžλ™ν™”λ₯Ό κ΅¬ν˜„ν•©λ‹ˆλ‹€.
  • 의미/κ΅¬μ‘°μƒμ˜ νŒŒμ΄ν”„λΌμΈ: μ „μ²˜λ¦¬ μž‘μ—…μ˜ μˆœμ„œλ₯Ό 의미적으둜 μ •μ˜ν•˜μ—¬ ꡬ쑰적으둜 μ—°κ²°ν•©λ‹ˆλ‹€.

 

μ˜ˆμ‹œ μ½”λ“œ

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer

# μˆ˜μΉ˜ν˜• 및 λ²”μ£Όν˜• λ³€μˆ˜μ˜ μ „μ²˜λ¦¬ νŒŒμ΄ν”„λΌμΈ ꡬ성
numeric_features = ['age', 'salary']
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_features = ['gender', 'department']
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

# 전체 데이터 μ „μ²˜λ¦¬ νŒŒμ΄ν”„λΌμΈ ꡬ성
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ]
)

 

 

λŒ€μš©λŸ‰ 데이터 처리

λŒ€μš©λŸ‰ 데이터λ₯Ό 효율적으둜 μ²˜λ¦¬ν•˜κΈ° μœ„ν•œ μ „λž΅κ³Ό 기법을 μ˜λ―Έν•©λ‹ˆλ‹€.

 

μ΄λŠ” λΆ„μ‚° 처리, 병렬 처리, λ©”λͺ¨λ¦¬ 관리 λ“±μ˜ 기법을 μ‚¬μš©ν•˜μ—¬ 데이터 처리의 νš¨μœ¨μ„±μ„ λ†’μž…λ‹ˆλ‹€.

  • λΆ„μ‚° 처리: 데이터λ₯Ό μ—¬λŸ¬ λ…Έλ“œμ— λΆ„μ‚°ν•˜μ—¬ λ™μ‹œμ— μ²˜λ¦¬ν•©λ‹ˆλ‹€. Hadoop, Spark λ“±μ˜ λΆ„μ‚° 처리 ν”„λ ˆμž„μ›Œν¬λ₯Ό μ‚¬μš©ν•©λ‹ˆλ‹€.
  • 병렬 처리: 데이터λ₯Ό μ—¬λŸ¬ ν”„λ‘œμ„ΈμŠ€μ—μ„œ λ™μ‹œμ— μ²˜λ¦¬ν•©λ‹ˆλ‹€. multiprocessing, Dask λ“±μ˜ 병렬 처리 라이브러리λ₯Ό μ‚¬μš©ν•©λ‹ˆλ‹€.
  • λ©”λͺ¨λ¦¬ 관리: λ©”λͺ¨λ¦¬ μ‚¬μš©μ„ μ΅œμ ν™”ν•˜μ—¬ λŒ€μš©λŸ‰ 데이터λ₯Ό 효율적으둜 μ²˜λ¦¬ν•©λ‹ˆλ‹€. 데이터 νƒ€μž… μ΅œμ ν™”, 청크(chunk) λ‹¨μœ„ 처리λ₯Ό 톡해 λ©”λͺ¨λ¦¬ μ‚¬μš©μ„ μ€„μž…λ‹ˆλ‹€.
# Daskλ₯Ό μ‚¬μš©ν•œ 병렬 처리 μ˜ˆμ‹œ
import dask.dataframe as dd

# CSV νŒŒμΌμ„ Dask DataFrame으둜 λ‘œλ“œ
df = dd.read_csv('large_dataset.csv')

# 데이터 처리
df = df[df['value'] > 0]
result = df.groupby('category').mean().compute()
print(result)

 

 

μ „μ²˜λ¦¬ κ³Όμ •μ˜ νš¨μœ¨μ„± ν–₯상?

μ „μ²˜λ¦¬ κ³Όμ •μ˜ 속도와 νš¨μœ¨μ„±μ„ 높이기 μœ„ν•œ λ‹€μ–‘ν•œ 기법을 μ˜λ―Έν•©λ‹ˆλ‹€.

 

μ΅œμ ν™”λœ μ•Œκ³ λ¦¬μ¦˜, μ½”λ”© μŠ€νƒ€μΌ κ°œμ„ , μ μ ˆν•œ 데이터 ꡬ쑰 μ‚¬μš© 등을 톡해 데이터 μ „μ²˜λ¦¬ μ‹œκ°„μ„ λ‹¨μΆ•ν•˜κ³ , λ¦¬μ†ŒμŠ€ μ‚¬μš©μ„ μ΅œμ ν™”ν•©λ‹ˆλ‹€.

  • μ΅œμ ν™”λœ μ•Œκ³ λ¦¬μ¦˜: μ•Œκ³ λ¦¬μ¦˜μ„ μ΅œμ ν™”ν•˜μ—¬ 데이터 처리 속도λ₯Ό λ†’μž…λ‹ˆλ‹€.
  • μ½”λ”© μŠ€νƒ€μΌ κ°œμ„ : 효율적인 μ½”λ”© μŠ€νƒ€μΌμ„ 톡해 μ „μ²˜λ¦¬ μž‘μ—…μ˜ 속도와 가독성을 λ†’μž…λ‹ˆλ‹€.
  • μ μ ˆν•œ 데이터 ꡬ쑰 μ‚¬μš©: μž‘μ—…μ— μ ν•©ν•œ 데이터 ꡬ쑰λ₯Ό μ‚¬μš©ν•˜μ—¬ νš¨μœ¨μ„±μ„ λ†’μž…λ‹ˆλ‹€. pandas, NumPy, Dask λ“±μ˜ 라이브러리λ₯Ό 적절히 ν™œμš©ν•©λ‹ˆλ‹€.
import pandas as pd
import numpy as np

# pandasλ₯Ό μ‚¬μš©ν•œ 효율적인 데이터 처리
df = pd.DataFrame({'A': range(1, 100001), 'B': range(100001, 200001)})

# 벑터화 연산을 μ‚¬μš©ν•œ 효율적인 계산
df['C'] = df['A'] + df['B']