์ฝ๋๋ GitHub์, ๋
ผ๋ฌธ์ arXiv์์ ๋ณผ ์ ์๋ค.
๋ ๋ง์ ๊ธ์ radarlog.kr์์.
1ํธ์์ MemoryBank์ ์ํคํ
์ฒ์ ํ์ฉ๋ฒ์ ๋ค๋ค๋ค. ์ด๋ฒ ํธ์ ๊ทธ ์ฌ์ฅ๋ถ๋ฅผ ์ด์ด๋ณธ๋ค. ์์ ํ๋. R = e^(โt/S). ์ด ์์์ด ์ด๋ป๊ฒ ์๋ํ๋์ง, S๊ฐ์ด ๋ณํ๋ฉด ๊ณก์ ์ด ์ด๋ป๊ฒ ๋ฐ๋๋์ง, ์๊ณ๊ฐ์ ์ด๋์ ์ก์์ผ ํ๋์ง๋ฅผ ์ซ์๋ก ํ๊ณ ๋ ๋ค.
์์์ ๋ถํดํ๋ค
R = e^(โt/S)
๋ณ์๊ฐ ์ธ ๊ฐ๋ค. R์ ๊ธฐ์ต ๋ณด์ ์จ(0~1 ์ฌ์ด), t๋ ํ์ต ์ดํ ๊ฒฝ๊ณผ ์๊ฐ, S๋ ๊ธฐ์ต ๊ฐ๋. e๋ ์์ฐ์์ 2.71828์ด๋ค.
์ด ์์์ ์ง์ ๊ฐ์ (exponential decay) ๋ชจ๋ธ์ด๋ค. ๋ฌผ๋ฆฌํ์์ ๋ฐฉ์ฌ์ฑ ๋ถ๊ดด๋ฅผ ํํํ๋ ๊ณต์๊ณผ ๊ตฌ์กฐ๊ฐ ๊ฐ๋ค. ์๊ฐ์ด ์ง๋ ์๋ก ๊ฐ์ด ๊ธฐํ๊ธ์์ ์ผ๋ก ์ค์ด๋ ๋ค. ์ฒ์์ ๊ธ๊ฒฉํ ๋จ์ด์ง๊ณ , ๋์ค์๋ ์ฒ์ฒํ ๋จ์ด์ง๋ค.
๊ฒ์ ๊ฐ๋ฐ์๋ผ๋ฉด ์ต์ํ ํจํด์ด๋ค. ํํฐํด์ ์ํ๊ฐ ๊ฐ์ , ์ฌ์ด๋์ ํ์ด๋์์, ๋ฐ๋ฏธ์ง ์ค๋ฒ ํ์(DoT)์ ํฑ ๊ฐ์. ์ ๋ถ ์ง์ ๊ฐ์ ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ค. ๋ง๊ฐ ๊ณก์ ๋ ๊ฐ์ ์ํ์ด๋ค. ๋ค๋ง ๋์์ด ๋ฐ๋ฏธ์ง๊ฐ ์๋๋ผ ๊ธฐ์ต์ผ ๋ฟ์ด๋ค.
ํต์ฌ์ ์ง์. ์ด ์์์์ ์ง์ง ์ค์ํ ๊ฑด t/S ๋น์จ์ด๋ค. t์ S๊ฐ ๊ฐ๊ฐ ์ผ๋ง์ธ์ง๋ณด๋ค, ๋์ ๋น์จ์ด R์ ๊ฒฐ์ ํ๋ค. t/S๊ฐ 1์ด๋ฉด R์ ์ฝ 0.368(36.8%). t/S๊ฐ 2์ด๋ฉด R์ ์ฝ 0.135(13.5%). t/S๊ฐ 3์ด๋ฉด R์ ์ฝ 0.050(5.0%). ๋น์จ์ด 1 ์ฌ๋ผ๊ฐ ๋๋ง๋ค ๋ณด์ ์จ์ด ๋๋ต 1/e(์ฝ 36.8%)๋ก ์ค์ด๋ ๋ค.
import math
# t/S ๋น์จ์ ๋ฐ๋ฅธ ๋ณด์ ์จ
for ratio in [0, 0.5, 1, 2, 3, 5]:
R = math.exp(-ratio)
print(f"t/S = {ratio:.1f} โ R = {R:.4f} ({R*100:.1f}%)")
# t/S = 0.0 โ R = 1.0000 (100.0%)
# t/S = 0.5 โ R = 0.6065 (60.7%)
# t/S = 1.0 โ R = 0.3679 (36.8%)
# t/S = 2.0 โ R = 0.1353 (13.5%)
# t/S = 3.0 โ R = 0.0498 (5.0%)
# t/S = 5.0 โ R = 0.0067 (0.7%)
์ด๊ฒ ์๋ฏธํ๋ ๋ฐ๋ ๋ช ํํ๋ค. S๊ฐ ํด์๋ก ๊ฐ์ ์๊ฐ์ด ์ง๋๋ t/S ๋น์จ์ด ์์ผ๋๊น R์ด ๋๊ฒ ์ ์ง๋๋ค. S๋ ๊ณก์ ์ ๊ธฐ์ธ๊ธฐ๋ฅผ ์๋งํ๊ฒ ๋ง๋๋ ์ญํ ์ด๋ค.
S๊ฐ ์ฌ๋ผ๊ฐ๋ฉด ๊ณก์ ์ด ์ด๋ป๊ฒ ๋ณํ๋
MemoryBank์์ S๋ ์ ์๋ค. ์ฒ์ ์ธ๊ธ๋๋ฉด 1, ํ ๋ฒ ํ์๋๋ฉด 2, ๋ ํ์๋๋ฉด 3. ๋จ์ํ๋ค. ์ด ๋จ์ํ ๋ณํ๊ฐ ๊ณก์ ์ ์ด๋ค ์ํฅ์ ์ฃผ๋์ง ๊ตฌ์ฒด์ ์ผ๋ก ๋ณธ๋ค.
๊ฒฝ๊ณผ ์๊ฐ t๋ฅผ "์ผ(day)" ๋จ์๋ก ์ก๊ฒ ๋ค. S=1์ธ ๊ธฐ์ต์ด ํ๋ฃจ๊ฐ ์ง๋๋ฉด R์ ์ผ๋ง์ธ๊ฐ.
# S๊ฐ๋ณ, ๊ฒฝ๊ณผ์ผ๋ณ ๋ณด์ ์จ
for S in [1, 2, 3, 5]:
print(f"\n--- S = {S} ---")
for t_days in [0, 0.5, 1, 2, 3, 5, 7]:
R = math.exp(-t_days / S)
print(f" t={t_days}์ผ โ R = {R:.4f} ({R*100:.1f}%)")
๊ฒฐ๊ณผ๋ฅผ ์ ๋ฆฌํ๋ฉด ์ด๋ฐ ๊ทธ๋ฆผ์ด ๋์จ๋ค.
S=1์ผ ๋: 0์ผ 100% โ 1์ผ 36.8% โ 2์ผ 13.5% โ 3์ผ 5.0% โ 7์ผ 0.1%
S=2์ผ ๋: 0์ผ 100% โ 1์ผ 60.7% โ 2์ผ 36.8% โ 3์ผ 22.3% โ 7์ผ 3.0%
S=3์ผ ๋: 0์ผ 100% โ 1์ผ 71.7% โ 2์ผ 51.3% โ 3์ผ 36.8% โ 7์ผ 9.7%
S=5์ผ ๋: 0์ผ 100% โ 1์ผ 81.9% โ 2์ผ 67.0% โ 3์ผ 54.9% โ 7์ผ 24.7%
S=1์ธ ๊ธฐ์ต์ ํ๋ฃจ ๋ง์ 36.8%๋ก ์ถ๋ฝํ๋ค. ์ผ์ฃผ์ผ์ด๋ฉด 0.1%. ์ฌ์ค์ ์๋ฉธ์ด๋ค.
S=2์ด๋ฉด ๊ฐ์ ํ๋ฃจ๊ฐ ์ง๋๋ 60.7%๊ฐ ๋จ๋๋ค. S=5์ด๋ฉด ํ๋ฃจ ํ์๋ 81.9%. ์ผ์ฃผ์ผ์ด ์ง๋๋ 24.7%๊ฐ ์ด์์๋ค.
ํ ๋ฒ ํ์ํ ๋๋ง๋ค S๊ฐ 1์ฉ ์ค๋ฅด๋๊น, 3๋ฒ ํ์๋ ๊ธฐ์ต(S=4)์ ์ผ์ฃผ์ผ์ด ์ง๋๋ 17.4%๊ฐ ๋จ๋๋ค. 5๋ฒ ํ์๋ ๊ธฐ์ต(S=6)์ ์ผ์ฃผ์ผ ํ์๋ 31.1%. ๊ณก์ ์ด ํ์ฐํ ๋๋๋ค.
์ด๊ฑธ ๊ฒ์์ผ๋ก ๋น์ ํ๋ฉด "๊ฒฝํ์น ๋์ ์ ๋ฐ๋ฅธ ๋ฒํ ์ง์์๊ฐ ์ฆ๊ฐ"์ ๋น์ทํ๋ค. ๊ฐ์ ๋ฒํ๋ฅผ ์ฌ๋ฌ ๋ฒ ๊ฑธ๋ฉด ์ง์์๊ฐ์ด ์ ์ ๊ธธ์ด์ง๋ ๋ฉ์ปค๋์ฆ. ์คํ์ด ์์ผ์๋ก ํจ๊ณผ๊ฐ ์ค๋๊ฐ๋ค. MemoryBank์ S๋ ์ ํํ ๊ทธ๋ ๋ค.
t ๋ฆฌ์ ์ ์ํ์ ์๋ฏธ
S๊ฐ ์ฌ๋ผ๊ฐ๋ ๊ฒ๋ณด๋ค t๊ฐ 0์ผ๋ก ๋ฆฌ์ ๋๋ ๊ฒ์ด ์ฌ์ค ๋ ๊ทน์ ์ธ ํจ๊ณผ๋ฅผ ๋ง๋ ๋ค.
์๋๋ฆฌ์ค๋ฅผ ํ๋ ๊ทธ๋ ค๋ณด์. ์ด๋ค ๊ธฐ์ต์ด S=1 ์ํ๋ก 3์ผ์ด ์ง๋ฌ๋ค. R์ e^(โ3/1) = 0.050, ์ฆ 5.0%๋ค. ๊ฑฐ์ ์ฌ๋ผ์ง ๋ปํ ๊ธฐ์ต์ด๋ค.
์ด ์์ ์ ์ด ๊ธฐ์ต์ด ๋ํ ์ค ํ์๋๋ค. MemoryBank๋ S๋ฅผ 2๋ก ์ฌ๋ฆฌ๊ณ , t๋ฅผ 0์ผ๋ก ๋ฆฌ์
ํ๋ค. ์ด ์๊ฐ R์ e^(โ0/2) = 1.000, ์ฆ 100%๋ก ๋์๊ฐ๋ค.
ํ์ ์ : S=1, t=3์ผ โ R = 5.0% (๊ฑฐ์ ์๋ฉธ)
ํ์ ํ: S=2, t=0์ผ โ R = 100% (์์ ๋ถํ)
5%์์ 100%๋ก. ์ด ์ ํ๊ฐ ํต์ฌ์ด๋ค.
์ฌ๊ธฐ์ ํ ๊ฐ์ง ๋. ๋ถํํ ๊ธฐ์ต์ ์ด์ ๋ณด๋ค ๋ ๊ฐํ๋ค. S๊ฐ 1์์ 2๋ก ์ฌ๋์ผ๋๊น, ๋ค์์ ๊ฐ์ 3์ผ์ด ์ง๋๋ฉด R์ด 5.0%๊ฐ ์๋๋ผ 22.3%๊ฐ ๋๋ค. ์ฒซ ๋ฒ์งธ ์์ ์์๋ 3์ผ์ด๋ฉด ๊ฑฐ์ ์ฃฝ์๋๋ฐ, ๋ ๋ฒ์งธ ์์ ์์๋ 3์ผ์ด ์ง๋๋ ์์ง ์ด์์๋ค.
์ด๊ฑธ ๋ฐ๋ณตํ๋ฉด ์ด๋ฐ ํจํด์ด ๋๋ค.
# ํ์ ์๋๋ฆฌ์ค ์๋ฎฌ๋ ์ด์
# ๊ธฐ์ต์ด 3์ผ๋ง๋ค ํ์๋๋ ๊ฒฝ์ฐ
memory = {'S': 1, 't': 0}
for cycle in range(5):
# 3์ผ ๊ฒฝ๊ณผ
memory['t'] = 3
R_before = math.exp(-memory['t'] / memory['S'])
# ํ์ ๋ฐ์
memory['S'] += 1
memory['t'] = 0
R_after = math.exp(-memory['t'] / memory['S'])
print(f"์ฌ์ดํด {cycle+1}: ํ์ ์ R={R_before:.4f} ({R_before*100:.1f}%)"
f" โ ํ์ ํ S={memory['S']}, R=100%")
# ์ฌ์ดํด 1: ํ์ ์ R=0.0498 (5.0%) โ ํ์ ํ S=2, R=100%
# ์ฌ์ดํด 2: ํ์ ์ R=0.2231 (22.3%) โ ํ์ ํ S=3, R=100%
# ์ฌ์ดํด 3: ํ์ ์ R=0.3679 (36.8%) โ ํ์ ํ S=4, R=100%
# ์ฌ์ดํด 4: ํ์ ์ R=0.4724 (47.2%) โ ํ์ ํ S=5, R=100%
# ์ฌ์ดํด 5: ํ์ ์ R=0.5488 (54.9%) โ ํ์ ํ S=6, R=100%
3์ผ๋ง๋ค ํ์๋๋ ๊ธฐ์ต์ "ํ์ ์ง์ ๋ณด์ ์จ"์ด 5.0% โ 22.3% โ 36.8% โ 47.2% โ 54.9%๋ก ์ฌ๋ผ๊ฐ๋ค. ๊ฐ์ 3์ผ์ด ๊ฒฝ๊ณผํด๋, ํ์ ํ์๊ฐ ์์ผ์๋ก ๊ธฐ์ต์ด ์ ์ ๋ ์ ์ ์ง๋๋ค.
์๋นํ์ฐ์ค๊ฐ ๋ฐ๊ฒฌํ ๊ฐ๊ฒฉ ํจ๊ณผ(spacing effect)๊ฐ ์์ ์์ ์์ฐ์ค๋ฝ๊ฒ ๋ด์ฅ๋ ๊ฑฐ๋ค. ๋ฐ๋ณต ๋ณต์ตํ๋ฉด ๋ง๊ฐ ๊ณก์ ์ด ์ ์ ์๋งํด์ง๋ค๋ ๊ทธ ์๋ฆฌ.
์๊ณ๊ฐ์ ์ด๋์ ์ก์์ผ ํ๋
MemoryBank ๋ ผ๋ฌธ์์ ๊ตฌ์ฒด์ ์ธ ์๊ณ๊ฐ ์ซ์๋ฅผ ๋ช ์ํ์ง๋ ์์๋ค. ํ์ง๋ง ์ค์ ๋ก ๊ตฌํํ๋ ค๋ฉด "R์ด ์ผ๋ง ์๋๋ก ๋จ์ด์ง๋ฉด ๊ธฐ์ต์ ์ญ์ ํ ๊ฒ์ธ๊ฐ"๋ฅผ ๊ฒฐ์ ํด์ผ ํ๋ค.
์๊ณ๊ฐ์ ์ ํ๋ ค๋ฉด ๋จผ์ ์ง๋ฌธ์ ๋ฐ๊ฟ์ผ ํ๋ค. "๊ธฐ์ต์ด ๋ฉฐ์น ์ ๊บผ๋ด์ง๋ฉด ์ํ์ผ ํ๋๊ฐ?"
S=1์ธ ๊ธฐ์ต(ํ ๋ฒ๋ ํ์ ์ ๋ ๊ธฐ์ต)์ด ๊ธฐ์ค์ด๋ค. ์ด ๊ธฐ์ต์ด ์ํ์ง๊ธฐ๊น์ง ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์๊ณ๊ฐ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋ค.
# S=1์ผ ๋, ์๊ณ๊ฐ๋ณ "์ํ์ง๋ ์๊ฐ"
for threshold in [0.5, 0.3, 0.1, 0.05, 0.01]:
# R = e^(-t/S) โ t = -S * ln(R)
t_forget = -1 * math.log(threshold)
print(f"์๊ณ๊ฐ {threshold} โ S=1 ๊ธฐ์ต์ด {t_forget:.2f}์ผ ํ ์๋ฉธ")
# ์๊ณ๊ฐ 0.5 โ S=1 ๊ธฐ์ต์ด 0.69์ผ(์ฝ 17์๊ฐ) ํ ์๋ฉธ
# ์๊ณ๊ฐ 0.3 โ S=1 ๊ธฐ์ต์ด 1.20์ผ(์ฝ 29์๊ฐ) ํ ์๋ฉธ
# ์๊ณ๊ฐ 0.1 โ S=1 ๊ธฐ์ต์ด 2.30์ผ ํ ์๋ฉธ
# ์๊ณ๊ฐ 0.05 โ S=1 ๊ธฐ์ต์ด 3.00์ผ ํ ์๋ฉธ
# ์๊ณ๊ฐ 0.01 โ S=1 ๊ธฐ์ต์ด 4.61์ผ ํ ์๋ฉธ
์๊ณ๊ฐ 0.5์ด๋ฉด 17์๊ฐ ๋ง์ ๊ธฐ์ต์ด ์ฌ๋ผ์ง๋ค. ๋๋ฌด ๊ณต๊ฒฉ์ ์ด๋ค. ์ด์ ํ ๋ํ๊ฐ ์ค๋ ์ด๋ฏธ ์๋ค.
์๊ณ๊ฐ 0.01์ด๋ฉด 4.6์ผ๊น์ง ๋ฒํด๋ค. ์ข ๋์จํ๋ค. ์๋ฏธ ์๋ ๋ํ๊ฐ ๊ฑฐ์ 5์ผ์ด๋ ๋จ์ ์์ผ๋ฉด ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋นํจ์จ์ ์ด๋ค.
์๊ณ๊ฐ 0.05~0.1 ์ฌ์ด๊ฐ ์ค์ฉ์ ์ธ ๋ฒ์๋ค. S=1 ๊ธฐ์ต์ด 2~3์ผ ์์ ์์ฐ์ค๋ฝ๊ฒ ์ฌ๋ผ์ง๊ณ , S=3 ์ด์์ธ ๊ธฐ์ต(2๋ฒ ์ด์ ํ์)์ ์ผ์ฃผ์ผ ๋๊ฒ ์ด์๋จ๋๋ค.
์ด๊ฑธ ์ญ์ผ๋ก ์ธ ์๋ ์๋ค. "์ฐ๋ฆฌ ์๋น์ค์์ ์ค์ํ ๊ธฐ์ต์ ์ต์ 7์ผ์ ์ ์ง๋ผ์ผ ํ๋ค"๋ ์๊ตฌ์ฌํญ์ด ์๋ค๋ฉด, S์ ์๊ณ๊ฐ์ ์ญ์ฐํ ์ ์๋ค.
# "7์ผ ํ์๋ ์ด์๋จ์ผ๋ ค๋ฉด S๊ฐ ์ต์ ์ผ๋ง์ฌ์ผ ํ๋?"
target_days = 7
threshold = 0.1
# R = e^(-t/S) โฅ threshold
# -t/S โฅ ln(threshold)
# S โฅ -t / ln(threshold)
S_min = -target_days / math.log(threshold)
print(f"7์ผ ํ R โฅ 0.1 ์ด๋ ค๋ฉด S โฅ {S_min:.2f}")
# 7์ผ ํ R โฅ 0.1 ์ด๋ ค๋ฉด S โฅ 3.04
S๊ฐ ์ต์ 4(3๋ฒ ํ์)๋ ๋ผ์ผ 7์ผ ํ์๋ ์๊ณ๊ฐ 0.1 ์์ ๋จธ๋ฌธ๋ค. ์๋น์ค ํน์ฑ์ ๋ง์ถฐ์ ์ด๋ฐ ์์ผ๋ก ํ๋ผ๋ฏธํฐ๋ฅผ ํ๋ํ ์ ์๋ค.
๋ฐ๊ฐ๊ธฐ๋ก ๋ฐ๋ผ๋ณด๊ธฐ
์ง์ ๊ฐ์ ์์ ๊ฐ์ฅ ์ง๊ด์ ์ธ ์งํ๋ ๋ฐ๊ฐ๊ธฐ๋ค. ๋ณด์ ์จ์ด 50%๋ก ๋จ์ด์ง๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ.
# R = e^(-t/S) = 0.5
# -t/S = ln(0.5)
# t_half = S * ln(2) โ S * 0.693
for S in [1, 2, 3, 5, 10]:
t_half = S * math.log(2)
print(f"S={S:2d} โ ๋ฐ๊ฐ๊ธฐ = {t_half:.2f}์ผ")
# S= 1 โ ๋ฐ๊ฐ๊ธฐ = 0.69์ผ (์ฝ 17์๊ฐ)
# S= 2 โ ๋ฐ๊ฐ๊ธฐ = 1.39์ผ (์ฝ 33์๊ฐ)
# S= 3 โ ๋ฐ๊ฐ๊ธฐ = 2.08์ผ (์ฝ 50์๊ฐ)
# S= 5 โ ๋ฐ๊ฐ๊ธฐ = 3.47์ผ
# S=10 โ ๋ฐ๊ฐ๊ธฐ = 6.93์ผ (์ฝ 1์ฃผ์ผ)
๋ฐ๊ฐ๊ธฐ๊ฐ S์ ์ ๋น๋กํ๋ค. S๊ฐ 2๋ฐฐ๊ฐ ๋๋ฉด ๋ฐ๊ฐ๊ธฐ๋ 2๋ฐฐ. ์ ํ ๊ด๊ณ๋ค.
ํ ๋ฒ๋ ํ์ ์ ๋ ๊ธฐ์ต(S=1)์ ๋ฐ๊ฐ๊ธฐ๊ฐ 17์๊ฐ์ด๋ค. ํ๋ฃจ๋ ์ ๋ผ์ ์ ๋ฐ์ด ๋ ์๊ฐ๋ค. 2๋ฒ ํ์๋ ๊ธฐ์ต(S=3)์ ๋ฐ๊ฐ๊ธฐ๊ฐ 2์ผ. 9๋ฒ ํ์๋ ๊ธฐ์ต(S=10)์ ๋ฐ๊ฐ๊ธฐ๊ฐ ๊ฑฐ์ ์ผ์ฃผ์ผ์ด๋ค.
์ด ๋ฐ๊ฐ๊ธฐ ์ซ์๋ฅผ ๋ณด๋ฉด MemoryBank์ ์ค๊ณ ์๋๊ฐ ์ ๋ช ํด์ง๋ค. ์ต๊ทผ์ ์์ฃผ ๋์จ ํ์ ๋ ์ค๋ ๊ธฐ์ตํ๊ณ , ํ ๋ฒ ์ค์ณ ์ง๋๊ฐ ์๊ธฐ๋ ๋น ๋ฅด๊ฒ ์๋๋ค. ์ฌ๋์ ๊ธฐ์ต๊ณผ ๊ฐ์ ํจํด์ด๋ค.
๊ฒ์์์ ์ ์ฌํ ์์คํ ์ ์ฐพ์๋ฉด, ์ด๊ทธ๋ก(aggro) ๊ฐ์ ๊ฐ ์๋ค. ํ๋ ์ด์ด๊ฐ ๋ณด์คํํ ๋ฐ๋ฏธ์ง๋ฅผ ์ ๋ฃ์ผ๋ฉด ์ด๊ทธ๋ก๊ฐ ์๊ฐ์ ๋ฐ๋ผ ๊ฐ์ ํ๋ค. ๊พธ์คํ ๋ฐ๋ฏธ์ง๋ฅผ ๋ฃ์ผ๋ฉด ์ด๊ทธ๋ก๊ฐ ์ ์ง๋๊ณ ๊ฐํ๋๋ค. ๋ฐ๋ฏธ์ง ์ฃผ์ ์ด "ํ์"์ด๊ณ , ์ด๊ทธ๋ก ์์น๊ฐ "๊ธฐ์ต ๋ณด์ ์จ"์ธ ์ ์ด๋ค.
์๋ฎฌ๋ ์ด์ : 10์ผ๊ฐ 5๊ฐ ๊ธฐ์ต์ ์ด๋ช
์ค์ ์๋๋ฆฌ์ค๋ฅผ ๋๋ ค๋ณธ๋ค. 5๊ฐ์ ๊ธฐ์ต์ด ์๋ก ๋ค๋ฅธ ํจํด์ผ๋ก ํ์๋๋ 10์ผ๊ฐ์ ์๋ฎฌ๋ ์ด์
์ด๋ค.
import math
THRESHOLD = 0.1
memories = {
"์ด์ง ๊ณ ๋ฏผ": {"S": 1, "t": 0, "born": 0, "recalls": []},
"์ ์ฌ ๋ฉ๋ด": {"S": 1, "t": 0, "born": 0, "recalls": []},
"UE5 ๋ฒ๊ทธ": {"S": 1, "t": 0, "born": 1, "recalls": []},
"์ฃผ๋ง ์บ ํ": {"S": 1, "t": 0, "born": 2, "recalls": []},
"์ฐ๋ด ํ์": {"S": 1, "t": 0, "born": 3, "recalls": []},
}
# ํ์ ์ค์ผ์ค (์ผ ๋จ์)
recall_schedule = {
"์ด์ง ๊ณ ๋ฏผ": [1, 3, 5, 8], # ์์ฃผ ํ์
"์ ์ฌ ๋ฉ๋ด": [], # ํ ๋ฒ๋ ์ ๊บผ๋
"UE5 ๋ฒ๊ทธ": [2, 4], # ๊ฐ๋ ํ์
"์ฃผ๋ง ์บ ํ": [3], # ํ ๋ฒ๋ง ํ์
"์ฐ๋ด ํ์": [4, 6, 7, 8, 9], # ๋งค์ฐ ์์ฃผ ํ์
}
print("=== 10์ผ ์๋ฎฌ๋ ์ด์
===\n")
for day in range(11):
print(f"--- Day {day} ---")
for name, mem in memories.items():
if day < mem['born']:
continue
# ๊ฒฝ๊ณผ ์๊ฐ ๊ณ์ฐ
last_event = mem['recalls'][-1] if mem['recalls'] else mem['born']
mem['t'] = day - last_event
# ์ด ๋ ํ์๋๋๊ฐ?
if day in recall_schedule[name]:
mem['S'] += 1
mem['recalls'].append(day)
mem['t'] = 0
R = math.exp(-mem['t'] / mem['S']) if mem['S'] > 0 else 0
status = "ALIVE" if R >= THRESHOLD else "DEAD"
print(f" {name:8s}: S={mem['S']}, t={mem['t']}์ผ, "
f"R={R:.3f} ({R*100:.1f}%) [{status}]")
print()
๊ฒฐ๊ณผ์์ ํต์ฌ๋ง ๋ฝ์ผ๋ฉด ์ด๋ ๋ค.
"์ ์ฌ ๋ฉ๋ด"๋ ํ ๋ฒ๋ ํ์๋์ง ์์๋ค. S=1, Day 2์์ ์ด๋ฏธ R์ด 13.5%๋ก ๋จ์ด์ง๊ณ , Day 3์ด๋ฉด 5.0%. ์๊ณ๊ฐ 0.1 ๊ธฐ์ค์ผ๋ก Day 3์ ์๋ฉธํ๋ค.
"์ด์ง ๊ณ ๋ฏผ"์ Day 1, 3, 5, 8์ ํ์๋๋ค. Day 10์ด ๋๋ฉด S=5, ๋ง์ง๋ง ํ์์ผ๋ก๋ถํฐ 2์ผ ๊ฒฝ๊ณผ. R์ e^(โ2/5) = 67.0%. ์์ง ๊ฑด๊ฐํ๋ค.
"์ฐ๋ด ํ์"์ Day 4๋ถํฐ ๊ฑฐ์ ๋งค์ผ ํ์๋๋ค. Day 10์ด๋ฉด S=6, ๋ง์ง๋ง ํ์์ผ๋ก๋ถํฐ 1์ผ ๊ฒฝ๊ณผ. R์ e^(โ1/6) = 84.6%. ๊ฐ์ฅ ๊ฐํ ๊ธฐ์ต์ด๋ค.
"์ฃผ๋ง ์บ ํ"์ Day 3์ ๋ฑ ํ ๋ฒ ํ์๋๋ค. S=2๋ก ์ฌ๋์ง๋ง, ๊ทธ ํ 7์ผ ๋์ ์๋ฌด๋ ์ ๊บผ๋๋ค. Day 10์์ R์ e^(โ7/2) = 3.0%. ์๋ฉธ์ด๋ค.
๊ฐ์ 10์ผ์ด๋ผ๋ ํ์ ํจํด์ ๋ฐ๋ผ ์ด๋ช ์ด ์์ ํ ๊ฐ๋ฆฐ๋ค. ์ด๊ฒ MemoryBank์ ํต์ฌ ๋ฉ์ปค๋์ฆ์ด ๋ง๋ค์ด๋ด๋ ํจ๊ณผ๋ค.
MemoryBank ๋ชจ๋ธ์ ์ํ์ ํ๊ณ
์ด ์์์ด ๊น๋ํ ๋งํผ, ํ์ค๊ณผ์ ๊ดด๋ฆฌ๋ ๋ช ํํ๋ค.
S์ ์ ํ ์ฆ๊ฐ ๋ฌธ์ . ํ์ํ ๋๋ง๋ค S๊ฐ ๋จ์ํ 1์ฉ ์ค๋ฅธ๋ค. ํ์ง๋ง ์ค์ ์ธ๊ฐ์ ๊ธฐ์ต ๊ฐํ๋ ๋น์ ํ์ด๋ค. ์ฒซ ๋ฒ์งธ ๋ณต์ต์ ํจ๊ณผ๊ฐ ๊ฐ์ฅ ํฌ๊ณ , ์ดํ ๋ณต์ต์ ํจ๊ณผ๋ ์ ์ ์ค์ด๋ ๋ค(์ํ ์ฒด๊ฐ). S_new = S_old + 1๋ณด๋ค S_new = S_old + 1/log(S_old + 1) ๊ฐ์ ๊ฐ์ ์ฆ๊ฐ๊ฐ ๋ ํ์ค์ ์ด๋ค.
๊ฐ์ ๊ฐ์ค์น์ ๋ถ์ฌ. ์๋นํ์ฐ์ค ์๋ ์คํ์ ๋ฌด์๋ฏธํ ์์ (WID, ZOF ๊ฐ์)์ ๋์์ผ๋ก ํ๋ค. ์๋ฏธ ์๋ ์ ๋ณด๋ ๋ฌด์๋ฏธํ ์ ๋ณด๋ณด๋ค 10๋ฐฐ ๋๋ฆฌ๊ฒ ์ํ๋ค๊ณ ์๋นํ์ฐ์ค ์์ ๋ ์ธ์ ํ๋ค. MemoryBank๋ "์ด์ง ๊ณ ๋ฏผ"๊ณผ "์ ์ฌ ๋ฉ๋ด"์ ์ด๊ธฐ S๋ฅผ ๋๊ฐ์ด 1๋ก ๋๋๋ค. ๊ฐ์ ์ ์ค์๋๊ฐ ๋ฐ์๋์ง ์๋๋ค. ์๋ฏธ ๊ฐ์ค์น๋ฅผ S ์ด๊ธฐ๊ฐ์ ๋ฐ์ํ๋ ํ์ฅ์ด ๊ฐ๋ฅํ๋ค. LLM์ผ๋ก ๋ํ์ ๊ฐ์ ๊ฐ๋๋ฅผ ํ๋ณํด์ S_init์ 1~3์ผ๋ก ์ฐจ๋ฑ ๋ถ์ฌํ๋ ์.
์๊ฐ ๋จ์์ ๋ชจํธ์ฑ. ๋ ผ๋ฌธ์์ t์ ๋จ์๋ฅผ ๋ช ์ํ์ง ์๋๋ค. ์ผ? ์๊ฐ? ๋ถ? ๋ํ ์ธ์ ์? ๋จ์์ ๋ฐ๋ผ ๊ณก์ ์ ํํ๊ฐ ์์ ํ ๋ฌ๋ผ์ง๋ค. ์ค์๋น์ค์ ์ ์ฉํ ๋ ๊ฐ์ฅ ๋จผ์ ๊ฒฐ์ ํด์ผ ํ ํ๋ผ๋ฏธํฐ๋ค.
ํ์ ํ์ ๊ธฐ์ค. "์ด ๊ธฐ์ต์ด ๋ํ ์ค ํ์๋๋ค"์ ํ์ ์ด FAISS ๊ฒ์ ๊ฒฐ๊ณผ ๊ธฐ๋ฐ์ด๋ค. top-k์ ํฌํจ๋๋ฉด ํ์์ผ๋ก ์น๋ ๊ฑด์ง, ์ค์ ๋ก ์๋ต์ ๋ฐ์๋ผ์ผ ํ์์ธ์ง์ ๋ฐ๋ผ S ์ฆ๊ฐ ๋น๋๊ฐ ๋ฌ๋ผ์ง๋ค. ๊ฒ์๋์ง๋ง ์๋ต์ ์ ์ฐ์ธ ๊ธฐ์ต๋ S๊ฐ ์ฌ๋ผ๊ฐ๋ค๋ฉด, ๊ธฐ์ต ๊ฐ๋๊ฐ ๊ณผ๋ํ๊ฐ๋ ์ ์๋ค.
์ด ํ๊ณ๋ค์ MemoryBank๋ฅผ ํ์ฅํ ์ ์๋ ๋ฐฉํฅ์ด๊ธฐ๋ ํ๋ค. ๋ ผ๋ฌธ ์ ์๋ค์ด "ํ์์ ์ด๊ณ ๋จ์ํ๋ ๋ชจ๋ธ"์ด๋ผ๊ณ ๋ช ์ํ ๊ฑด, ์ด ์์์ด ์ต์ข ๋ต์ด ์๋๋ผ ์ถ๋ฐ์ ์ด๋ผ๋ ์๋ฏธ๋ค. ๊ธฐ๋ณธ ๊ณต์ ์์ ๊ฐ์ ๊ฐ์ค์น, ๋น์ ํ S ์ฆ๊ฐ, ๋งฅ๋ฝ ๊ธฐ๋ฐ ํ์ ํ์ ๊ฐ์ ๋ ์ด์ด๋ฅผ ์น์ผ๋ฉด ํจ์ฌ ์ ๊ตํ ๋ฉ๋ชจ๋ฆฌ ์์คํ ์ ๋ง๋ค ์ ์๋ค.
R = e^(โt/S). ์์ ํ๋๊ฐ ๊ธฐ์ต์ ํ์, ๊ฐํ, ์๋ฉธ์ ์ ๋ถ ์ค๋ช
ํ๋ค. ๋ณต์กํ ๋ฉ๋ชจ๋ฆฌ ์ํคํ
์ฒ๊ฐ ์๋๋ผ, ์ฌ๋ฆฌํ์์ 140๋
๊ฐ ๊ฒ์ฆ๋ ์๋ฆฌ๋ฅผ LLM์ ์ฌ๋ฆฐ ๊ฑฐ๋ค. ๋จ์ํ์ง๋ง ํจ๊ณผ์ ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ๋จ์ํ๊ธฐ ๋๋ฌธ์ ํ์ฅ ๊ฐ๋ฅํ๋ค.
"์์์ ๋จ์ํ ์๋ก ๊ฐํ๋ค. ๋ณต์กํ ๊ฑด ๊ตฌํํ๊ธฐ ์ฝ์ง๋ง, ๋จ์ํ ๊ฑด ํ์ฅํ๊ธฐ ์ฝ๋ค."









![Defluffer - reduce token usage ๐ by 45% using this one simple trick! [Earthday challenge]](https://media2.dev.to/dynamic/image/width=1000,height=420,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fiekbgepcutl4jse0sfs0.png)


