4 Thu

[AI ์Šค์ฟจ 1๊ธฐ] 9์ฃผ์ฐจ DAY 4

Big Data : Spark MLib ์†Œ๊ฐœ

Spark MLib

  • ๋จธ์‹ ๋Ÿฌ๋‹ ๊ด€๋ จ ๋‹ค์–‘ํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜, ์œ ํ‹ธ๋ฆฌํ‹ฐ๋กœ ๊ตฌ์„ฑ๋œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ

    • Classfication, Regression, Clustering, Collaborative Filtering, Dimensionality, Reduction

    • ์•„์ง ๋”ฅ๋Ÿฌ๋‹ ์ง€์›์€ ๋ฏธ์•ฝ

  • RDD ๊ธฐ๋ฐ˜๊ณผ ๋ฐ์ดํ„ฐ ํ”„๋ ˆ์ž„ ๊ธฐ๋ฐ˜์˜ ๋‘ ๋ฒ„์ „์ด ์กด์žฌ

    • spark.mllib vs spark.ml

      • mllib๊ฐ€ RDD ๊ธฐ๋ฐ˜์ด๊ณ  ml์€ ๋ฐ์ดํ„ฐ ํ”„๋ ˆ์ž„ ๊ธฐ๋ฐ˜

      • mllib๋Š” ์ด์ „ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋กœ ๋” ์ด์ƒ ์—…๋ฐ์ดํŠธ๊ฐ€ ์•ˆ๋จ

      • ๋”ฐ๋ผ์„œ ํ•ญ์ƒ spark.ml์„ ์‚ฌ์šฉํ•  ๊ฒƒ!

  • ์žฅ์ 

    • ์›์Šคํ†ฑ ML ํ”„๋ ˆ์ž„์›Œํฌ

      • ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„๊ณผ SparkSQL๋“ฑ์„ ์ด์šฉํ•ด ์ „์ฒ˜๋ฆฌ

      • Spark MLlib๋ฅผ ์ด์šฉํ•ด ๋ชจ๋ธ ๋นŒ๋”ฉ

      • ML Pipeline์„ ํ†ตํ•ด ๋ชจ๋ธ ๋นŒ๋”ฉ ์ž๋™ํ™”

      • ML flow๋กœ ๋ชจ๋ธ ๊ด€๋ฆฌํ•˜๊ณ  ์„œ๋น™

    • ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ๋„ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ

    • ๋ฐ์ดํ„ฐ๊ฐ€ ์ž‘์€ ๊ฒฝ์šฐ๋Š” ๊ตณ์ด ์‚ฌ์šฉํ•  ํ•„์š”๋Š” ์—†์Œ

MLflow

  • ๋ชจ๋ธ ๊ฐœ๋ฐœ๊ณผ ํ…Œ์ŠคํŠธ์™€ ๊ด€๋ฆฌ์™€ ์„œ๋น™๊นŒ์ง€ ์ œ๊ณตํ•ด์ฃผ๋Š” ์—”๋“œํˆฌ์—”๋“œ ํ”„๋ ˆ์ž„ ์›Œํฌ

  • ํŒŒ์ด์ฌ, ์ž๋ฐ”, R, API๋ฅผ ์ง€์›

  • ํŠธ๋ž˜ํ‚น, ๋ชจ๋ธ, ํ”„๋กœ์ ํŠธ๋ฅผ ์ง€์›

Spark MLlib ์ œ๊ณต ์•Œ๊ณ ๋ฆฌ์ฆ˜

Spark MLlib ๊ธฐ๋ฐ˜ ๋ชจ๋ธ ๋นŒ๋”ฉ์˜ ๊ธฐ๋ณธ ๊ตฌ์กฐ

  • ๋ชจ๋ธ ๋นŒ๋”ฉ

    • ํŠธ๋ ˆ์ด๋‹์…‹ ์ „์ฒ˜๋ฆฌ

    • ๋ชจ๋ธ ๋นŒ๋”ฉ

    • ๋ชจ๋ธ ๊ฒ€์ฆ

  • Scikit-Learn๊ณผ ๋น„๊ตํ–ˆ์„ ๋•Œ ์žฅ์ 

    • ์ฐจ์ด์ ์€ ๋ฐ์ดํ„ฐ์˜ ํฌ๊ธฐ

    • ํŠธ๋ ˆ์ด๋‹์…‹์˜ ํฌ๊ธฐ๊ฐ€ ํฌ๋ฉด ์ „์ฒ˜๋ฆฌ์™€ ๋ชจ๋ธ ๋นŒ๋”ฉ์— ์žˆ์–ด Spark๊ฐ€ ํฐ ์žฅ์ ์„ ๊ฐ€์ง

    • Spark๋Š” ML ํŒŒ์ดํ”„๋ผ์ธ์„ ํ†ตํ•ด ๋ชจ๋ธ ๊ฐœ๋ฐœ์˜ ๋ฐ˜๋ณต์„ ์‰ฝ๊ฒŒ ํ•ด์คŒ

Big Data : Spark MLib ํ”ผ์ณ ๋ณ€ํ™˜

ํ”ผ์ณ ์ถ”์ถœ๊ณผ ๋ณ€ํ™˜

  • ํ”ผ์ฒ˜ ๊ฐ’๋“ค์„ ๋ชจ๋ธ ํ›ˆ๋ จ์— ์ ํ•ฉํ•œ ํ˜•ํƒœ๋กœ ๋ฐ”๊พธ๋Š” ๊ฒƒ์„ ์ง€์นญ

  • ํฌ๊ฒŒ Feature Extractor์™€ Feature Transformer๊ฐ€ ์กด์žฌ

  • Feature Transformer

    • ํ”ผ์ฒ˜ ๊ฐ’๋“ค์€ ์ˆซ์ž ํ•„๋“œ(์—ฌ์•ผํ•จ)

    • ์ˆซ์ž ํ•„๋“œ ๊ฐ’์˜ ๋ฒ”์œ„ ํ‘œ์ค€ํ™”

    • ๋น„์–ด์žˆ๋Š” ํ•„๋“œ๋“ค์˜ ๊ฐ’์„ ์–ด๋–ป๊ฒŒ ์ฑ„์šธ์ง€ ๊ฒฐ์ •

  • Feature Extractor

    • ๊ธฐ์กด ํ”ผ์ณ์—์„œ ์ƒˆ๋กœ์šด ํ”ผ์ณ๋ฅผ ์ถ”์ถœ

    • ex) TF-IDF, Word2Vec

ํ”ผ์ณ ๋ณ€ํ™˜ String Indexer

ํ”ผ์ณ ๋ณ€ํ™˜ Scaler : ์ˆซ์ž ํ•„๋“œ๊ฐ’์˜ ๋ฒ”์œ„ ํ‘œ์ค€ํ™”

  • ์ˆซ์ž ํ•„๋“œ ๊ฐ’์˜ ๋ฒ”์œ„๋ฅผ ํŠน์ • ๋ฒ”์œ„๋กœ ๋ณ€ํ™˜

  • ํ”ผ์ณ ์Šค์ผ€์ผ๋ง ํ˜น์€ ์ •๊ทœํ™”๋ผ๊ณ  ๋ถ€๋ฆ„

ํ”ผ์ณ ๋ณ€ํ™˜ Imputer : ๊ฐ’์ด ์—†๋Š” ํ•„๋“œ ์ฑ„์šฐ๊ธฐ

  • ๊ฐ’์ด ์กด์žฌํ•˜์ง€ ์•Š๋Š” ๋ ˆ์ฝ”๋“œ๋“ค์ด ์กด์žฌํ•˜์ง€ ์•Š๋Š” ํ•„๋“œ๋“ค์˜ ๊ฒฝ์šฐ ๊ธฐ๋ณธ๊ฐ’์„ ์ •ํ•ด์„œ ์ฑ„์šฐ๋Š” ๊ฒƒ

๋ชจ๋ธ ๋นŒ๋”ฉ๊ณผ ๊ด€๋ จ๋œ ํ”ํ•œ ๋ฌธ์ œ๋“ค

  1. ํŠธ๋ ˆ์ด๋‹ ์…‹์˜ ๊ด€๋ฆฌ๊ฐ€ ์•ˆ๋จ

  2. ๋ชจ๋ธ ํ›ˆ๋ จ ๋ฐฉ๋ฒ•์ด ๊ธฐ๋ก์ด ์•ˆ ๋จ

  3. ๋ชจ๋ธ ํ›ˆ๋ จ์— ๋งŽ์€ ์‹œ๊ฐ„ ์†Œ์š”

ML Pipeline์˜ ๋“ฑ์žฅ

  • ์•ž์„œ ์–ธ๊ธ‰ํ•œ ๋ฌธ์ œ๋“ค ์ค‘ 2, 3๋ฒˆ์„ ํ•ด๊ฒฐ

  • ์ž๋™ํ™”๋ฅผ ํ†ตํ•ด ์—๋Ÿฌ ์†Œ์ง€๋ฅผ ์ค„์ด๊ณ  ๋ฐ˜๋ณต์„ ๋น ๋ฅด๊ฒŒ ๊ฐ€๋Šฅํ•˜๊ฒŒ ํ•ด์คŒ

Spark MLlib ๊ด€๋ จ ๊ฐœ๋… ์ •๋ฆฌ

  • ML ํŒŒ์ดํ”„๋ผ์ธ์ด๋ž€?

    • ๋ฐ์ดํ„ฐ ๊ณผํ•™์ž๊ฐ€ ๋จธ์‹ ๋Ÿฌ๋‹ ๊ฐœ๋ฐœ๊ณผ ํ…Œ์ŠคํŠธ๋ฅผ ์‰ฝ๊ฒŒ ํ•ด์ฃผ๋Š” ๊ธฐ๋Šฅ (๋ฐ์ดํ„ฐ ํ”„๋ ˆ์ž„ ๊ธฐ๋ฐ˜)

    • ๋จธ์‹ ๋Ÿฌ๋‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜์— ๊ด€๊ณ„์—†์ด ์ผ๊ด€๋œ ํ˜•ํƒœ์˜ API๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ชจ๋ธ๋ฆฌ์ด ๊ฐ€๋Šฅ

    • ML ๋ชจ๋ธ๊ฐœ๋ฐœ๊ณผ ํ…Œ์ŠคํŠธ๋ฅผ ๋ฐ˜๋ณต๊ฐ€๋Šฅํ•ด์คŒ

  • 4๊ฐœ์˜ ์š”์†Œ๋กœ ๊ตฌ์„ฑ

    • DataFrame

    • Transformer

    • Estimator

    • Parameter

  • DataFrame

    • ML ํŒŒ์ดํ”„๋ผ์ธ์—์„œ๋Š” ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„์ด ๊ธฐ๋ณธ ๋ฐ์ดํ„ฐ ํฌ๋งท

    • ๊ธฐ๋ณธ์ ์œผ๋กœ CSV, JSON, Parguet, JDBC๋ฅผ ์ง€์›

    • ๋‹ค์Œ 2๊ฐ€์ง€์˜ ์ƒˆ๋กœ์šด ๋ฐ์ดํ„ฐ์†Œ์Šค๋ฅผ ์ง€์›

      • ์ด๋ฏธ์ง€ ๋ฐ์ดํ„ฐ์†Œ์Šค

      • LIBSVM ๋ฐ์ดํ„ฐ์†Œ์Šค

  • Transformer

    • ์ž…๋ ฅ ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„์„ ๋‹ค๋ฅธ ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„์œผ๋กœ ๋ณ€ํ™˜

    • 2์ข…๋ฅ˜์˜ Transformer๊ฐ€ ์กด์žฌํ•˜๋ฉฐ transform์ด ๋ฉ”์ธ ํ•จ์ˆ˜

    • Feature Transformer

      • ์ž…๋ ฅ ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„์˜ ์ปฌ๋Ÿผ์œผ๋กœ๋ถ€ํ„ฐ ์ƒˆ๋กœ์šด ์ปฌ๋Ÿผ์„ ๋งŒ๋“ค์–ด๋‚ด ์ด๋ฅผ ์ถ”๊ฐ€ํ•œ ์ƒˆ๋กœ์šด ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„์„ ์ถœ๋ ฅ์œผ๋กœ ๋‚ด์คŒ. ๋ณดํ†ต ํ”ผ์ณ ์—”์ง€๋‹ˆ์–ด๋ง์„ ํ•˜๋Š”๋ฐ ์‚ฌ์šฉ

    • Learning Model

      • ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ์— ํ•ด๋‹น

  • Estimator

    • ๋จธ์‹ ๋Ÿฌ๋‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜์— ํ•ด๋‹น. fit์ด ๋ฉ”์ธ ํ•จ์ˆ˜

      • ํŠธ๋ ˆ์ด๋‹์…‹ ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„์„ ์ž…๋ ฅ์œผ๋กœ ๋ฐ›์•„์„œ ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ์„ ๋งŒ๋“ค์–ด๋ƒ„

      • ์˜ˆ๋ฅผ ๋“ค์–ด LogisticRegression์€ Estimator์ด๊ณ  LogistricRegression.fit()์„ ํ˜ธ์ถœํ•˜๋ฉด ๋จธ์‹  ๋Ÿฌ๋‹ ๋ชจ๋ธ์„ ๋งŒ๋“ค์–ด๋ƒ„

    • ML ํŒŒ์ดํ”„๋ผ์ธ๋„ Estimator

    • Estimator๋Š” ์ €์žฅ๊ณผ ์ฝ๊ธฐ ํ•จ์ˆ˜ ์ œ๊ณต

  • Parameter

    • Transformer์™€ Estimator์˜ ๊ณตํ†ต API๋กœ ๋‹ค์–‘ํ•œ ์ธ์ž๋ฅผ ์ ์šฉํ•ด์คŒ

    • ๋‘ ์ข…๋ฅ˜์˜ ํŒŒ๋ผ๋ฏธํ„ฐ๊ฐ€ ์กด์žฌ

      • Param : ํ•˜๋‚˜์˜ ์ด๋ฆ„๊ณผ ๊ฐ’

      • ParamMap : Param ๋ฆฌ์ŠคํŠธ

    • ํŒŒ๋ผ๋ฏธํ„ฐ์˜ ์˜ˆ

      • ํ›ˆ๋ จ ๋ฐ˜๋ณต์ˆ˜ ์ง€์ •์„ ์œ„ํ•ด setMaxIter()๋ฅผ ์‚ฌ์šฉ

      • ParamMap(Ir.maxIter -> 10)

    • ํŒŒ๋ผ๋ฏธํ„ฐ๋Š” fit ํ˜น์€ transform์— ์ธ์ž๋กœ ์ง€์ • ๊ฐ€๋Šฅ

  • ML Pipeline

    • ํ•˜๋‚˜ ์ด์ƒ์˜ ํŠธ๋žœ์Šคํฌ๋จธ์™€ ์—์Šคํ‹ฐ๋ฉ”์ดํ„ฐ๊ฐ€ ์—ฐ๊ฒฐ๋œ ๋ชจ๋ธ๋ง ์›ํ”Œ๋กœ์šฐ

      • ์ž…๋ ฅ์€ ๋ฐ์ดํ„ฐํ”„๋ ˆ์ž„

      • ์ถœ๋ ฅ์€ ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ

    • ML Pipeline ๊ทธ ์ž์ฒด๋„ Estimator

[ํŒŒ์ด์ฌ ๋”ฅ๋Ÿฌ๋‹ ํŒŒ์ดํ† ์น˜] PART 01 ํŒŒ์ดํ† ์น˜ ๊ธฐ์ดˆ

01 ํŒŒ์ด์ฌ ๋˜๋Š” ์•„๋‚˜์ฝ˜ํƒ€ ์„ค์น˜ํ•˜๊ธฐ

ํŒŒ์ด์ฌ VS ์•„๋‚˜์ฝ˜๋‹ค

  • ์ปดํ“จํ„ฐ ๊ณตํ•™์„ ์ „๊ณตํ–ˆ๊ฑฐ๋‚˜ ์†Œํ”„ํŠธ์›จ์–ด ํˆด์„ ๋Šฅ์ˆ™ํ•˜๊ฒŒ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ๋Š” ์‚ฌ์šฉ์ž๋Š” ํŒŒ์ด์ฌ ์„ค์น˜๋ฅผ ๊ถŒ์žฅ

  • ์†Œํ”„ํŠธ์›จ์–ด ํˆด์„ ๋‹ค๋ฃจ๋Š” ๋ฐ ๋ฏธ์ˆ™ํ•œ ์‚ฌ์šฉ์ž๋Š” ์•„๋‚˜์ฝ˜๋‹ค ์„ค์น˜๋ฅผ ๊ถŒ์žฅ. ๋ฐ์ดํ„ฐ ๋ถ„์„์— ํ•„์š”ํ•œ ๋ชจ๋“ˆ์ด ์ž๋™์œผ๋กœ ์„ค์น˜๋˜๊ธฐ ๋•Œ๋ฌธ

02 CUDA, CuDNN ์„ค์น˜ํ•˜๊ธฐ

G-FLOPs

  • GPU FLoating Operations Per Second์˜ ์•ฝ์ž

  • ์ดˆ๋‹น ๋ถ€๋™์†Œ์ˆ˜์  ์—ฐ์‚ฐ์„ ์˜๋ฏธํ•˜๋ฉฐ GPU์˜ ์„ฑ๋Šฅ์„ ์ธก์ •ํ•˜๋Š” ์š”์†Œ

CUDA

  • GPU๋ฅผ ์žฅ์ฐฉํ•˜๋”๋ผ๋„ ํŒŒ์ด์ฌ์—์„œ ์ด๋ฅผ ์ธ์‹ํ•  ์ˆ˜ ์žˆ์–ด์•ผ ํ•œ๋‹ค.

  • ํ…์„œํ”Œ๋กœ์šฐ๋‚˜ ํŒŒ์ดํ† ์น˜ ๋“ฑ์˜ ๋”ฅ๋Ÿฌ๋‹ ํ”„๋ ˆ์ž„์›Œํฌ๋ฅผ ์‚ฌ์šฉํ•˜๋ ค๋ฉด CUDA๋ฅผ ์„ค์น˜ํ•ด์•ผ ํ•œ๋‹ค.

  • GPU์—์„œ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ๋ฅผ ์ˆ˜ํ–‰ํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๊ฐ์ข… ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์— ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•ด์ฃผ๋Š” GPGPU(General-Purpose computing on Graphics Processing Units) ๊ธฐ์ˆ 

CuDNN

  • nvidia CUDA Deep Nerual Network Library์˜ ์•ฝ์ž

  • ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์„ ์œ„ํ•œ GPU ๊ฐ€์†ํ™” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์˜ ๊ธฐ์ดˆ ์š”์†Œ์™€ ๊ฐ™์€ ์ผ๋ฐ˜์ ์ธ ๋ฃจํ‹ด์„ ๋น ๋ฅด๊ฒŒ ์ดํ–‰ํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•ด์ฃผ๋Š” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ

03 ํŒŒ์ดํ† ์น˜ ์„ค์น˜ํ•˜๊ธฐ

nothing

04 ๋ฐ˜๋“œ์‹œ ์•Œ์•„์•ผ ํ•˜๋Š” ํŒŒ์ดํ† ์น˜ ์Šคํ‚ฌ

์Šค์นผ๋ผ, ๋ฒกํ„ฐ, ๋งคํŠธ๋ฆญ์Šค, ํ…์„œ

  • torch.tensor ๋ฅผ ์ด์šฉํ•˜์—ฌ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•  ์ˆ˜ ์žˆ๋‹ค.

  • +, -, *, / ๋ฅผ ์ด์šฉํ•ด์„œ ์ง์ ‘์ ์ธ ์‚ฌ์น™์—ฐ์‚ฐ์ด ๊ฐ€๋Šฅํ•˜๋ฉฐ torch.(add/sub/mul/div)๋ฅผ ์ด์šฉํ•œ ์‚ฌ์น™์—ฐ์‚ฐ๋„ ๊ฐ€๋Šฅํ•˜๋‹ค

  • ํ–‰๋ ฌ ์š”์†Œ๊ฐ„ ๊ณฑ์ด ์•„๋‹Œ ํ–‰๋ ฌ ๊ณฑ์€ torch.matmul๋กœ ๊ฐ€๋Šฅํ•˜๋‹ค.

Autograd

  • Autograd ๋ฐฉ์‹์„ ์ด์šฉํ•ด Back Propagation์œผ๋กœ ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ์—…๋ฐ์ดํŠธ ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์‰ฝ๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.

import torch

if torch.cuda.is_available():
    DEVICE = torch.device('cuda')
else:
    DEVICE = torch.device('cpu')
  • cuda.is_available()

    • ํ˜„์žฌ ํŒŒ์ด์ฌ์ด ์‹คํ–‰๋˜๊ณ  ์žˆ๋Š” ํ™˜๊ฒฝ์—์„œ torch moudle์„ ์ด์šฉํ•  ๋•Œ GPU๋ฅผ ์ด์šฉํ•ด ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ๋Š”์ง€๋ฅผ ํŒŒ์•…ํ•˜๋Š” ๋ฉ”์„œ๋“œ

    • ์ฐธ์ด๋ฉด cuda ์žฅ๋น„๋ฅผ, ๊ฑฐ์ง“์ด๋ฉด cpu ์žฅ๋น„๋ฅผ ์ด์šฉํ•ด ๊ณ„์‚ฐํ•œ๋‹ค.

BATCH_SIZE = 64
INPUT_SIZE = 10000
HIDDEN_SIZE = 100
OUTPUT_SIZE = 10
  • BATCH_SIZE

    • ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์—์„œ ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ์—…๋ฐ์ดํŠธํ•  ๋•Œ ๊ณ„์‚ฐ๋˜๋Š” ๋ฐ์ดํ„ฐ์˜ ๊ฐœ์ˆ˜

    • Input์œผ๋กœ ์ด์šฉ๋˜๋Š” ๋ฐ์ดํ„ฐ๊ฐ€ 64๊ฐœ์ด๋‹ค.

  • INPUT_SIZE

    • ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์—์„œ์˜ Input์˜ ํฌ๊ธฐ์ด์ž ์ž…๋ ฅ์ธต์˜ ๋…ธ๋“œ ์ˆ˜๋ฅผ ์˜๋ฏธ.

    • BATCH_SIZE์™€ ํ˜ผ๋™ํ•˜๋ฉด ์•ˆ๋จ. BATCH๋Š” ๊ฐฏ์ˆ˜๋ฅผ, INPUT์€ ํฌ๊ธฐ๋ฅผ ์˜๋ฏธ

    • (64, 1000)์˜ ํ…์„œ๊ฐ€ ์ž…๋ ฅ๋˜๊ณ  ์ด ๋•Œ ๋งˆ๋‹ค ๊ฐ€์ค‘์น˜ ๊ฐฑ์‹ ์ด ์ผ์–ด๋‚จ

  • HIDDEN_SIZE

    • ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์—์„œ Input์„ ๋‹ค์ˆ˜์˜ ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ์ด์šฉํ•ด ๊ณ„์‚ฐํ•œ ๊ฒฐ๊ณผ์— ํ•œ ๋ฒˆ ๋” ๊ณ„์‚ฐ๋˜๋Š” ํŒŒ๋ผ๋ฏธํ„ฐ ์ˆ˜๋ฅผ ์˜๋ฏธ

    • ์ž…๋ ฅ์ธต์—์„œ ์€๋‹‰์ธต์œผ๋กœ ์ „๋‹ฌ๋์„ ๋•Œ ์€๋‹‰์ธต์˜ ๋…ธ๋“œ ์ˆ˜๋ฅผ ์˜๋ฏธ

  • OUTPUT_SIZE

    • ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์—์„œ ์ตœ์ข…์œผ๋กœ ์ถœ๋ ฅ๋˜๋Š” ๊ฐ’์˜ ๋ฒกํ„ฐ์˜ ํฌ๊ธฐ๋ฅผ ์˜๋ฏธ

x = torch.randn(BATCH_SIZE, 
                INPUT_SIZE, 
                device = DEVICE, 
                dtype = torch.float, 
                requires_grad = False)
y = torch.randn(BATCH_SIZE, 
                OUTPUT_SIZE, 
                device = DEVICE, 
                dtype = torch.float, 
                requires_grad = False)
w1 = torch.randn(INPUT_SIZE, 
                HIDDEN_SIZE, 
                device = DEVICE, 
                dtype = torch.float, 
                requires_grad = True)
w2 = torch.randn(HIDDEN_SIZE, 
                OUTPUT_SIZE, 
                device = DEVICE, 
                dtype = torch.float, 
                requires_grad = True)
  • randn

    • ํ‰๊ท ์ด 0, ํ‘œ์ฅฐํŽธ์ฐจ๊ฐ€ 1์ธ ์ •๊ทœ๋ถ„ํฌ์—์„œ ์ƒ˜ํ”Œ๋งํ•œ ๊ฐ’์œผ๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ๋งŒ๋“ ๋‹ค๋Š” ๊ฒƒ์„ ์˜๋ฏธ

  • reguires_grad

    • ํŒŒ๋ผ๋ฏธํ„ฐ์— ๋Œ€ํ•ด์„œ๋งŒ Gradient๋ฅผ ๊ณ„์‚ฐํ•˜๋ฉด ๋˜๋ฏ€๋กœ ๊ฐ€์ค‘์น˜์— ๋Œ€ํ•ด์„œ๋งŒ True๋กœ ์„ค์ •

learning_rate = 1e-6
for t in range(1, 501):
    y_pred = x.mm(w1).clamp(min = 0).mm(w2)
    
    loss = (y_pred - y).pow(2).sum()
    if t % 100 == 0:
        print("Iteration: ", t, "\t", "Loss: ", loss.item())
    loss.backward()
    
    with torch.no_grad():
        w1 -= learning_rate * w1.grad
        w2 -= learning_rate * w2.grad
        
        w1.grad.zero_()
        w2.grad.zero_()
  • learning_rate

    • ํ•™์Šต๋ฅ ์„ ์–ด๋–ป๊ฒŒ ์„ค์ •ํ•˜๋А๋ƒ์— ๋”ฐ๋ผ Gradient ๊ฐ’์— ๋”ฐ๋ฅธ ํ•™์Šต ์ •๋„๊ฐ€ ๊ฒฐ์ •๋œ๋‹ค. ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์—์„œ ํŒŒ๋ผ๋ฏธํ„ฐ ๊ฐ’์„ ์—…๋ฐ์ดํŠธํ•  ๋•Œ ๊ฐ€์žฅ ์ค‘์š”ํ•œ ํ•˜์ดํผ ํŒŒ๋ผ๋ฏธํ„ฐ์ด๊ธฐ๋„ ํ•˜๋‹ค.

  • y_pred

    • ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์˜ ๊ฒฐ๊ด๊ฐ’์„ ๋ณดํ†ต ์˜ˆ์ธก๊ฐ’์ด๋ผ๊ณ  ํ‘œํ˜„ํ•œ๋‹ค.

    • x์™€ w1๊ณผ์˜ ํ–‰๋ ฌ ๊ณฑ ์—ฐ์‚ฐ์— ๋Œ€ํ•ด clamp ํ•จ์ˆ˜๋ฅผ ์ ์šฉํ•˜๊ณ  ๋‹ค์‹œ w2์™€์˜ ํ–‰๋ ฌ ๊ณฑ ์—ฐ์‚ฐ์„ ํ•œ๋‹ค.

  • clamp

    • ์—ฌ๊ธฐ์„œ๋Š” min๋งŒ ์ •์˜ ๋˜์—ˆ์œผ๋ฏ€๋กœ ReLU์™€ ๋™์ผํ•œ ์—ญํ• ์„ ํ•œ๋‹ค.

  • loss

    • ์˜ˆ์ธก๊ฐ’๊ณผ ์‹ค์ œ ๋ ˆ์ด๋ธ” ๊ฐ’์„ ๋น„๊ตํ•ด ์˜ค์ฐจ๋ฅผ ๊ณ„์‚ฐํ•œ ๊ฐ’์„ loss๋ผ๊ณ  ํ•œ๋‹ค. ์—ฌ๊ธฐ์„œ๋Š” ์ œ๊ณฑ๊ฐ’์˜ ์ฐจ๋ฅผ ๋น„๊ตํ–ˆ๋‹ค.

  • loss.backward()

    • loss๊ฐ’์— ๋Œ€ํ•ด backward() ๋ฉ”์„œ๋“œ๋ฅผ ์ด์šฉํ•˜๋ฉด ๊ฐ ํŒŒ๋ฆฌ๋ฏธํ„ฐ ๊ฐ’์— ๋Œ€ํ•ด Gradient๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ  ์ด๋ฅผ ํ†ตํ•ด Back Propagation์„ ์ง„ํ–‰ํ•œ๋‹ค๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•œ๋‹ค.

  • with_torch.no_gard()

    • ๊ฐ ํŒŒ๋ผ๋ฏธํ„ฐ ๊ฐ’์— ๋Œ€ํ•ด Gradient๋ฅผ ๊ณ„์‚ฐํ•œ ๊ฒฐ๊ณผ๋ฅผ ์ด์šฉํ•ด ํŒŒ๋ผ๋ฏธํ„ฐ ๊ฐ’์„ ์—…๋ฐ์ดํŠธํ•  ๋•Œ๋Š” ํ•ด๋‹น ์‹œ์ ์˜ Gradient ๊ฐ’์„ ๊ณ ์ •ํ•œ ํ›„ ์—…๋ฐ์ดํŠธ๋ฅผ ์ง„ํ–‰ํ•ด์•ผ ํ•œ๋‹ค.

  • w.grad.zero_()

    • ๊ฐ ํŒŒ๋ผ๋ฏธํ„ฐ ๊ฐ’์„ ์—…๋ฐ์ดํŠธ ํ–ˆ๋‹ค๋ฉด Gradient๋ฅผ ์ดˆ๊ธฐํ™” ํ•ด์„œ ๋‹ค์Œ ๋ฐ˜๋ณต๋ฌธ์„ ์ง„ํ–‰ํ•  ์ˆ˜ ์žˆ๋„๋ก Gradient๋ฅผ 0์œผ๋กœ ์„ค์ •ํ•œ๋‹ค.

Last updated

Was this helpful?