[Computer Architecture] Assignment 3 - Float

"Floating-Point Numbers"

[Objective]

Half-Precision Floating-Point 형식의 Sign, Exponent, Fraction Bit를 직접 조작하여 사칙 연산을 구현하고 IEEE Floating-Point 동작 원리를 이해하기

[Background]

▣ Infinity
· Exponent : 11111 & Fraction = 0

▣ NaN(Not a Number)
· Exponent : 11111 & Fraction ≠ 0

▣ Zero
· Exponent = 00000 & Fraction = 0

▣ Normalized Number
· Exponent : 00001 ~ 11110
→ 1.Fraction
→ (-1)Sign x 2(Exponent - 15) x (1 + Fraction)

▣ Denormalized Number
· Exponent = 00000 & Fraction ≠ 0
→ 0.Fraction
→ (-1)Sign x 2(Exponent - 15) x (Fraction)

[Implementation]

▣ Add Operation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
_float_ _float_::operator+(const _float_ &y) {
    _float_ r;
 
    bool x_sign = data >> 15;                           // Sign of x Value
    uint16_t x_exp = (data >> 10) & 0x1f;               // Exponent of x Value
    uint16_t x_frac = data & 0x3ff;                     // Fraction of x Value
 
    bool y_sign = y.data >> 15;                         // Sign of y Value
    uint16_t y_exp = (y.data >> 10) & 0x1f;             // Exponent of y Value
    uint16_t y_frac = y.data & 0x3ff;                   // Fraction of y Value
 
    bool r_sign = 0;                                    // Sign of Result Value
    uint16_t r_exp = 0;                                 // Exponent of Result Value
    uint16_t r_frac = 0;                                // Fraction of Result Value
 
    // NaN (Exponent == 11111, Fraction != 0)
    if ((x_exp == 0x1f && x_frac !=0) || (y_exp == 0x1f && y_frac != 0)) {
        r.data = 0x7e00;                                // NaN
        return r;
    }
 
    // Infinity + Infinity (Exponent == 11111, Fraction == 0)
    if (x_exp == 0x1f && y_exp == 0x1f) {
        if (x_sign != y_sign) {                         // (+/- Infinity) + (-/+ Infinity)
            r.data = 0x7e00;                            // NaN
        } else {                                        // (+/- Infinity) + (+/- Infinity)
            r.data = (x_sign << 15) | (0x1f << 10);     // +/- Infinity
        }
        return r;
    }
 
    // x = Infinity
    if (x_exp == 0x1f && x_frac == 0) {                 // x = Infinity
        r.data = data;                                  // Result = x = Infinity
        return r;
    }
 
    // y = Infinity
    if (y_exp == 0x1f && y_frac == 0) {                 // y = Infinity
        r.data = y.data;                                // Result = y = Infinity
        return r;
    }
 
    // x = 0
    if (x_exp == 0 && x_frac == 0) {                    // x = 0
        r.data = y.data;                                // Result = 0 + y = y
        return r;
    }
 
    // y = 0
    if (y_exp == 0 && y_frac == 0) {                    // y = 0
        r.data = data;                                  // Result = x + 0 = x
        return r;
    }
 
    // Consider Hidden Bit
    uint16_t x_val;
    uint16_t y_val;
    uint16_t r_val;
 
    if (x_exp == 0) {                                   // Denormalize
        x_val = x_frac;                                 // 0.xxxx
    } else {                                            // Normalize
        x_val = (1 << 10) | x_frac;                     // 1.xxxx
    }
 
    if (y_exp == 0) {                                   // Denormalize
        y_val = y_frac;                                 // 0.xxxx
    } else {                                            // Normalize
        y_val = (1 << 10) | y_frac;                     // 1.xxxx
    }
 
    // Shift To Add Guard-Bit & Round Bit
    x_val <<= 2;
    y_val <<= 2;
 
    // Denormalize -> Exponent = 1
    x_exp = (x_exp == 0) ? 1 : x_exp;
    y_exp = (y_exp == 0) ? 1 : y_exp;
 
    // Match Exponent Equally to Calculate
    if (x_exp > y_exp) {
        y_val >>= x_exp - y_exp;                        // y_exp Change Same As x_exp
        r_exp = x_exp;                                  // Result Exponent = x_exp
    } else if (y_exp > x_exp) {
        x_val >>= y_exp - x_exp;                        // x_exp Change Same As y_exp
        r_exp = y_exp;                                  // Result Exponent = y_exp
    } else {                                            // x_exp == y_exp
        r_exp = x_exp;                                  // Either x_exp or y_exp OK
    }
 
    if (x_sign == y_sign) {                             // Same Sign Bit
        r_val = x_val + y_val;                          // Same Exponent By Above
        r_sign = x_sign;                                // Either x_sign or y_sign OK
 
        if (r_val & (1 << 13)) {                        // 1x.xxxx
            r_val >>= 1;                                // 1.xxxxx Format
            r_exp++;                                    // Exponent + 1
        }
    } else {                                            // Different Sign Bit
        if (x_val > y_val) {                            // |x| > |y|
            r_val = x_val - y_val;                      // x - y
            r_sign = x_sign;                            // |x| Sign Bit
        } else if (y_val > x_val) {                     // |y| > |x|
            r_val = y_val - x_val;                      // y - x
            r_sign = y_sign;                            // |y| Sign Bit
        } else {                                        // |x| = |y|
            r.data = 0;                                 // Result = 0
            return r;
        }
    }
 
    // Normalize
    while ((r_val & (1 << 12)) == 0 && r_exp > 1) {     // Until 0.01xxx -> 1.xxx
        r_val <<= 1;                                    // 0.1xxx
        r_exp--;                                        // Exponent - 1
    }
    if ((r_val & (1 << 12)) == 0) {                     // 1.xxxx
        r_exp = 0;                                      // Exponent = 0
    }
 
    // Rounding
    uint16_t guard_round = r_val & 0x3;                 // {LSB - 1, LSB}
    r_val >>= 2;                                        // Remove Guard Bit & Round Bit
    if (guard_round > 0x2 || (guard_round == 0x2 && (r_val & 1))) {
        r_val++;                                        // Round Up
        if (r_exp > 0 && (r_val & (1 << 11))) {         // 10.xxxx
            r_val >>= 1;                                // 1.0xxxx
            r_exp++;                                    // Exponent + 1
        } else if (r_exp == 0 && (r_val & (1 << 10))) {
            r_exp = 1;                                  // Exponent = 1
        }
    }
 
    // Overflow -> Infinity
    if (r_exp >= 31) {                                  // Overflow
        r.data = (r_sign << 15) | (0x1f << 10);         // Infinity
        return r;
    }
 
    // Combine Result Value
    if (r_exp > 0) {                                            // Normalize
        r_frac = r_val & 0x3ff;                                 // Leave 10-Bit For Fraction
        r.data = (r_sign << 15) | (r_exp << 10) | r_frac;       // Combine
    } else {                                                    // Denormalize
        r.data = (r_sign << 15) | (r_val & 0x3ff);              // Exponent = 0
    }
    return r;
}
cs

① x, y의 Sign / Exponent / Fraction 분리 후, Special Case 처리
    · NaN : Result = NaN
    · Infinity + Infinity : 부호 동일 O → Result = Infinity / 부호 동일 X → Result = NaN
    · Infinity + y : Result = Infinity
    · x + Infinity : Result = Infinity
    · x = 0 : Result = y
    · y = 0 : Result = x
② Exponent = 00000 : 0.Fraction → Hidden Bit = 0 / Exponent ≠ 00000 : 1.Fraction → Hidden Bit = 1
③ Guard Bit, Round Bit를 사용하기 위해 Fraction을 왼쪽으로 2-bit Shift
④ Denormalized Number는 저장된 Exponent가 0이지만, 실제 Exponent 계산에서는 (1 - Bias) → 0이 아닌 1로 취급
⑤ 덧셈 연산을 위해 두 수의 Exponent를 일치시킴
⑥ Sign이 같으면 덧셈, 다르면 뺄셈
⑦ Normalized 형태(1.xxxx)가 될 때까지 Shift & Exponent-- (더 이상 Exponent를 줄일 수 없으면 Denormalized)
⑧ Rounding (Guard + Round < 10 : 버림 / Guard + Round > 10 : 올림 / Guard + Round == 10 : Tie)
    → Tie : LSB = 1 ▶ 올림 / LSB = 0 ▶ 유지
⑨ Rounding 후 다시 Normalized 형태(1.xxxx)로 변환
⑩ Overflow → Infinity / Normalized → {Sign, Exponent, Fraction} / Denormalized → {Sign, Exponent = 00000, Fraction}

▣ Subtract Operation
1
2
3
4
5
6
7
8
_float_ _float_::operator-(const _float_ &y) {
    _float_ neg_y = y;                                          // Copy y Value
    neg_y.data ^= 0x8000;                                       // Change Sign Bit By Using XOR
 
    _float_ r;
    r = *this + neg_y;                                          // x - y == x + (-y)
    return r;
}
cs

① y 값을 복사 후, Sign Bit를 반전시켜 부호 전환
② 덧셈 연산자로 계산

▣ Multiply Operation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
_float_ _float_::operator*(const _float_ &y) {
    bool x_sign = data >> 15;                                   // Sign of x Value
    uint16_t x_exp = (data >> 10) & 0x1f;                       // Exponent of x Value
    uint16_t x_frac = data & 0x3ff;                             // Fraction of x Value
 
    bool y_sign = y.data >> 15;                                 // Sign of y Value
    uint16_t y_exp = (y.data >> 10) & 0x1f;                     // Exponent of y Value
    uint16_t y_frac = y.data & 0x3ff;                           // Fraction of y Value
 
    _float_ r;
    bool r_sign = x_sign ^ y_sign;                              // Sign of Result Value
 
    // NaN (Exponent == 11111, Fraction != 0)
    if ((x_exp == 0x1f && x_frac != 0) || (y_exp == 0x1f && y_frac != 0)) {
        r.data = 0x7e00;                                        // NaN
        return r;
    }
 
    // Infinity x 0
    if (((x_exp == 0x1f && x_frac == 0) && (y_exp == 0 && y_frac == 0)) ||      // Infinity x 0
        ((x_exp == 0 && x_frac == 0) && (y_exp == 0x1f && y_frac == 0))) {      // 0 x Infinity
        r.data = 0x7e00;                                        // NaN
        return r;
    }
 
    // Infinity (Exponent == 11111, Fraction == 0)
    if ((x_exp == 0x1f && x_frac == 0) || (y_exp == 0x1f && y_frac == 0)) {
        r.data = (r_sign << 15) | (0x1f << 10);                 // Infinity
        return r;
    }
 
    // 0
    if ((x_exp == 0 && x_frac == 0) || (y_exp == 0 && y_frac == 0)) {
        r.data = (r_sign << 15);                                // +/- 0
        return r;
    }
 
    // Consider Hidden Bit
    uint16_t x_val = (x_exp == 0) ? x_frac : ((1 << 10) | x_frac);
    uint16_t y_val = (y_exp == 0) ? y_frac : ((1 << 10) | y_frac);
    uint32_t r_val = x_val * y_val;                             // 11-bit x 11-bit = 22-bit
 
    // Denormalize -> Exponent = 1
    x_exp = (x_exp == 0) ? 1 : x_exp;
    y_exp = (y_exp == 0) ? 1 : y_exp;
    int r_exp = x_exp + y_exp - 15;                             // Subtract Exponent Bias
 
    if (r_val & (1 << 21)) {                                    // x_val * y_val = 10.xxxx
        r_val >>= 9;                                            // 1.0xxxx (Guard & Round Bit -> 12-bit)
        r_exp++;                                                // Exponent + 1
    } else {                                                    // x_hidden * y_hidden = 1.xxxx
        r_val >>= 8;                                            // 1.xxxx (Guard & Round Bit -> 12-bit)
    }
 
    // Denormalize
    if (r_exp < 1) {
        r_val >>= 1 - r_exp;                                    // Shift Fraction
        r_exp = 0;                                              // Exponent = 0
    }
 
    // Rounding
    uint16_t guard_round = r_val & 0x3;                         // {LSB - 1, LSB}
    r_val >>= 2;                                                // Remove Guard Bit & Round Bit
    if (guard_round > 0x2 || (guard_round == 0x2 && (r_val & 1))) {
        r_val++;                                                // Round Up
        if (r_exp > 0 && (r_val & (1 << 11))) {                 // 10.xxxx
            r_val >>= 1;                                        // 1.0xxxx
            r_exp++;                                            // Exponent + 1
        } else if (r_exp == 0 && (r_val & (1 << 10))) {
            r_exp = 1;                                          // Exponent = 1
        }
    }
 
    // Overflow -> Infinity
    if (r_exp >= 31) {                                          // Overflow
        r.data = (r_sign << 15) | (0x1f << 10);                 // Infinity
        return r;
    }
 
    // Denormalize / Underflow
    if (r_exp == 0) {
        r.data = (r_sign << 15) | (r_val & 0x3ff);              // Exponent == 0
        return r;
    }
 
    uint16_t r_frac = r_val & 0x3ff;                            // Leave 10-Bit For Fraction
    r.data = (r_sign << 15) | (r_exp << 10) | (r_frac);         // Combine
    return r;
}
cs

① x, y의 Sign / Exponent / Fraction 분리 & Result Sign 계산 후, Special Case 처리
    · NaN : Result = NaN
    · Infinity x 0 : Result = NaN
    · Infinity : Result = Infinity
    · 0 : Result = 0
② Exponent = 00000 : 0.Fraction → Hidden Bit = 0 / Exponent ≠ 00000 : 1.Fraction → Hidden Bit = 1
    → Result Value는 32-bit로 선언 (x_val x y_val = 11-bit x 11-bit = 22-bit)
③ Denormalized Number는 저장된 Exponent가 0이지만, 실제 Exponent 계산에서는 (1 - Bias) → 0이 아닌 1로 취급
④ (x_exp + y_exp)는 Bias를 2번 더하므로 Result Exponent는 (- Bias) 필요
⑤ x_val x y_val = 1x.xxxx : 오른쪽으로 Shift & Exponent++ / x_val x y_val = 1.xxxx : 오른쪽으로 Shift & Exponent 유지
    → Guard & Round Bit를 포함해야 하므로 Fraction이 12-bit가 남도록 Shift
⑥ Denormalized인 경우 (1 - r_exp)만큼 오른쪽으로 Shift하고, r_exp는 최솟값인 0으로 할당
⑦ Rounding (Guard + Round < 10 : 버림 / Guard + Round > 10 : 올림 / Guard + Round == 10 : Tie)
    → Tie : LSB = 1 ▶ 올림 / LSB = 0 ▶ 유지
⑧ Rounding 후 다시 Normalized 형태(1.xxxx)로 변환
⑨ Overflow → Infinity / Normalized → {Sign, Exponent, Fraction} / Denormalized → {Sign, Exponent = 00000, Fraction}

** 덧셈 : Exponent 일치시킬 때 하위 Bit들이 버려져서 정확도 감소 → Guard & Round Bit를 위해 Shift
** 곱셈 : 결과 자체가 Bit를 많이 생성하여 하위 Bit를 사용 Guard & Round Bit로 바로 사용 가능

▣ Divide Operation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
_float_ _float_::operator/(const _float_ &y) {
    bool x_sign = data >> 15;                                   // Sign of x Value
    uint16_t x_exp = (data >> 10) & 0x1f;                       // Exponent of x Value
    uint16_t x_frac = data & 0x3ff;                             // Fraction of x Value
 
    bool y_sign = y.data >> 15;                                 // Sign of y Value
    uint16_t y_exp = (y.data >> 10) & 0x1f;                     // Exponent of y Value
    uint16_t y_frac = y.data & 0x3ff;                           // Fraction of y Value
 
    _float_ r;
    bool r_sign = x_sign ^ y_sign;                              // Sign of Result Value
 
    // NaN (Exponent == 11111, Fraction != 0)
    if ((x_exp == 0x1f && x_frac != 0) || (y_exp == 0x1f && y_frac != 0)) {
        r.data = 0x7e00;                                        // NaN
        return r;
    }
 
    // 0/0
    if ((x_exp == 0 && x_frac == 0) && (y_exp == 0 && y_frac == 0)) {
        r.data = 0x7e00;                                        // NaN
        return r;
    }
 
    // Infinity / Infinity
    if ((x_exp == 0x1f && x_frac == 0) && (y_exp == 0x1f && y_frac == 0)) {
        r.data = 0x7e00;                                        // NaN
        return r;
    }
 
    // x/0 (y == 0)
    if (y_exp == 0 && y_frac == 0) {
        r.data = (r_sign << 15) | (0x1f << 10);                 // Infinity
        return r;
    }
 
    // 0/y (x == 0)
    if (x_exp == 0 && x_frac == 0) {
        r.data = (r_sign << 15);                                // +/- 0
        return r;
    }
 
    // Infinity / Finite
    if (x_exp == 0x1f && x_frac == 0) {
        r.data = (r_sign << 15) | (0x1f << 10);                 // Infinity
        return r;
    }
 
    // Finite / Infinity
    if (y_exp == 0x1f) {
        r.data = (r_sign << 15);                                // +/- 0
        return r;
    }
 
    // Consider Hidden Bit
    uint16_t x_val = (x_exp == 0) ? x_frac : ((1 << 10) | x_frac);
    uint16_t y_val = (y_exp == 0) ? y_frac : ((1 << 10) | y_frac);
    uint32_t r_val = (x_val << 12) / y_val;                     // Shift To Maintain 12-Bit
 
    // Denormalize -> Exponent = 1
    x_exp = (x_exp == 0) ? 1 : x_exp;
    y_exp = (y_exp == 0) ? 1 : y_exp;
    int r_exp = x_exp - y_exp + 15;                             // Add Bias
 
    // Denormalize
    if (r_exp < 1) {
        r_val >>= 1 - r_exp;                                    // Shift Fraction
        r_exp = 0;                                              // Exponent = 0
    }
 
    // Normalize (10.xxxx)
    if (r_val & (1 << 13)) {                                    // 10.xxxx
        r_val >>= 1;                                            // 1.0xxxx
        r_exp++;                                                // Exponent + 1
    }
 
    // Normalize (0.1xxx)
    while ((r_val & (1 << 12)) == 0 && r_exp > 1 && r_val != 0) {       // Until 0.01xxx -> 1.xxx
        r_val <<= 1;                                            // 0.1xxx
        r_exp--;                                                // Exponent - 1
    }
    if ((r_val & (1 << 12)) == 0) {                             // 1.xxxx
        r_exp = 0;                                              // Exponent = 0
    }
 
    // Rounding
    uint16_t guard_round = r_val & 0x3;                         // {LSB - 1, LSB}
    r_val >>= 2;                                                // Remove Guard Bit & Round Bit
 
    if (guard_round > 0x2 || (guard_round == 0x2 && (r_val & 1))) {
        r_val++;                                                // Round Up
        if (r_exp > 0 && (r_val & (1 << 11))) {                 // 10.xxxx
            r_val >>= 1;                                        // 1.0xxxx
            r_exp++;                                            // Exponent + 1
        } else if (r_exp == 0 && (r_val & (1 << 10))) {
            r_exp = 1;                                          // Exponent = 1
        }
    }
 
    // Overflow -> Infinity
    if (r_exp >= 31) {                                          // Overflow
        r.data = (r_sign << 15) | (0x1f << 10);                 // Infinity
        return r;
    }
 
    // Denormalize / Underflow
    if (r_exp == 0) {
        r.data = (r_sign << 15) | (r_val & 0x3ff);              // Exponent == 0
        return r;
    }
 
    uint16_t r_frac = r_val & 0x3ff;                            // Leave 10-Bit For Fraction
    r.data = (r_sign << 15) | (r_exp << 10) | r_frac;           // Combine
    return r;
}
cs

① x, y의 Sign / Exponent / Fraction 분리 & Result Sign 계산 후, Special Case 처리
    · NaN : Result = NaN
    · 0 / 0 : Result = NaN
    · Infinity / Infinity : Result = NaN
    · x / 0 : Result = Infinity
    · 0 / y : Result = 0
    · Infinity / Finite : Result = Infinity
    · Finite / Infinity : Result = 0
② Exponent = 00000 : 0.Fraction → Hidden Bit = 0 / Exponent ≠ 00000 : 1.Fraction → Hidden Bit = 1
    → Result Value는 정수 나눗셈이라 소수 부분이 사라지므로 x_val을 왼쪽으로 Shift하여 나눗셈 결과 Fraction 부분을 보존
③ Denormalized Number는 저장된 Exponent가 0이지만, 실제 Exponent 계산에서는 (1 - Bias) → 0이 아닌 1로 취급
④ (x_exp - y_exp)는 Bias가 서로 상쇄되므로 Result Exponent는 (+ Bias) 필요
⑤ Denormalized인 경우 (1 - r_exp)만큼 오른쪽으로 Shift하고, r_exp는 최솟값인 0으로 할당
⑥ x_val / y_val = 1x.xxxx : 오른쪽으로 Shift & Exponent++ / x_val / y_val = 0.01xxxx : 왼쪽으로 Shift & Exponent--
    → 더 이상 Exponent를 줄일 수 없으면 Denormalized
⑦ Rounding (Guard + Round < 10 : 버림 / Guard + Round > 10 : 올림 / Guard + Round == 10 : Tie)
    → Tie : LSB = 1 ▶ 올림 / LSB = 0 ▶ 유지
⑧ Rounding 후 다시 Normalized 형태(1.xxxx)로 변환
⑨ Overflow → Infinity / Normalized → {Sign, Exponent, Fraction} / Denormalized → {Sign, Exponent = 00000, Fraction}

[Result]

· main.cc에서 "_float_ x, y;"를 "_Float16 x, y;"로 변경하면 결과 비교 가능

[Reference]

· float (Computer Architecture) - William J. Song

댓글

댓글 쓰기

이 블로그의 인기 게시물

[Mini-NPU RTL] NN Reference Model

이미지
"NN Reference Model" 1. Neuron 단 1개의 Neuron만 존재하며 해당 Neuron이 가중합을 잘 구하고 활성화 함수를 제대로 통과시키는지 확인 → 28x28=784개의 입력 데이터와 784개의 가중치를 각각 곱한 후 ∑, 이후 활성화 함수를 통과시킨 뒤, 1개의 값 출력 → "test_data.txt"에서 데이터를 읽어 Neuron에 직접 넣음 → 가중치와 편향이 "w_1_0.mif", "b_1_0.mif"로부터 정적으로 고정되어 Load neuron_tb.sv) include.v) 공통 상수를 미리 정해두는 파일로, 숫자를 고치면 Network 깊이, Neuron 개수 등을 조절 ReLU.v) 공통 활성화 함수인 ReLU를 하드웨어로 구현한 코드 Sig_ROM.v) 공통 Sigmoid 함수 연산을 실시간으로 계산하지 않고  미리 계산된 결과값 을 메모리에서 꺼내 쓰는  LookUp Table  방식의 구현 Weight_Memory.v) 공통 가중치를 저장하는 메모리 장치로 가중치를 읽고 쓴다. Neuron.v) 공통 입력 데이터를 받아 가중치와 곱하고, 누적 한 후, 편향을 더하고, 활성화 함수를 거쳐 출력하는 연산 Unit 2. Network 수많은 Neuron이 합쳐진 전체 시스템의 데이터 흐름과 제어 Logic이 제대로 작동하는지 확인 → 28x28=784개의 입력 데이터가 30개의 Neuron에게 동시에 전달되면 784x30개의 가중치를 곱해 30개의 결과 출력     (첫 번째 입력이 1 Cycle에 서로 다른 30개의 가중치와 병렬 연산으로 곱해진다. ∴ 784 Cycle) → 30개의 입력이 다음 Layer의 20개 Neuron에 전달되어 30x20개의 가중치를 곱해 20개의 결과 출력 → 20개의 입력이 다음 Layer의 10개 Neuron에 전달되어 20x10개의 가중치를 곱해 10개의 결과 출력 → 10개의 출력은 입력 이미지 0~9의 점수를 나...
자세한 내용 보기

[Mini-NPU RTL] TPU (Study Paper)

이미지
"In-Datacenter Performance Analysis of a Tensor Processing Unit" 1. Introduction to Neural Networks   NN은 입력 값들의 가중 합에 비선형 함수(ex. max(0, value))를 적용하는 단순한 인공 뉴런에 기초한다.   ※ 가중합 : 입력 데이터에 중요도인 가중치 를 곱해서 더한다.   ※ 비선형 함수 : 계산된 합을 그대로 쓰지 않고 변형하는 함수(활성화 함수)   ※ max(0, value) : ReLU(Rectified Linear Unit) 함수이며, 음수면 0, 양수면 해당 값을 그대로 내보낸다.   NN은 계층(Layer) 으로 모이며, 한 계층의 출력은 다음 계층의 입력이 된다.   DNN(Deep Neural Networks) 은 NN에서 계층의 수가 많은 것 을 의미한다.   NN은 개발 단계인 Training(학습) 단계와 실전 단계인 Inference(추론) 단계가 있다.   개발자는 계층의 수 와 NN의 유형 을 선택하고, 학습 과정을 통해 가중치 를 결정한다.   학습이 끝난 후, 추론 단계에서는 소수점 아래 긴 자리까지 필요 없는 경우가 많다.   ∴ Quantization(양자화) 단계에서 단순한 정수( 8-bit )로 바꿔 용량↓ & 속도↑         → 8-bit 정수 곱셈 : 16-bit 부동소수점 곱셈보다 에너지 소모 6배↓ & 칩 면적 6배↓         → 8-bit 정수 덧셈 : 16-bit 부동소수점 덧셈보다 에너지 소모 13배↓ & 칩 면적 38배↓   NN의 유형은 3가지로 볼 수 있다.   ·  MLP(Multi-Layer Perceptrons) : 각 계층은 이전 계층의 모든 출력 값(Fully Conn...
자세한 내용 보기