์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |
- ๊นํธ์ฐ์๊ฐ
- ์ ์ฃผ๋์ฌํ
- R
- PRML
- ์ฑ ๋ฆฌ๋ทฐ
- GenAI
- ์์ด๋ฐ์ฐํธ
- ์ค๋ธ์
- ๋ณด์กฐ์ธ๋ฑ์ค
- ์คํ ์ด๋ ํ๋ก์์
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- RStudio
- PRIMARY KEY
- ์ ์ฃผ๋
- ํผ๊ณตS
- ๋ ํ๊ฐ
- SQL
- ์ ๋ฝ์ฌํ
- Linux
- ๋ฐ๋
- digital marketing
- ์๊ตญ์ฌํ
- ํผ์๊ณต๋ถํ๋SQL
- ์คํ๋ผ์ธ
- Jupyter notebook
- ๋์งํธ๋ง์ผํ
- ํด๋ฌ์คํฐํ์ธ๋ฑ์ค
- Github
- ๋ง์ง
- ์ ์ฃผ2์ฃผ์ด์ด
- Today
- Total
๋ชฉ๋กGenAI (3)
Soy Library
LLaMA7B(70์ต ๊ฐ)์์ 65B(650์ต)๊น์ง์ ํ๋ผ๋ฏธํฐ๋ฅผ ๊ฐ์ง ๊ธฐ์ด ์ธ์ด ๋ชจ๋ธ๋ค๋ก ๊ตฌ์ฑ์์กฐ ๊ฐ์ ํ ํฐ์ ๋ํด ํ์ต์ํด. ๊ณต๊ฐ์ ์ผ๋ก ์ด์ฉ ๊ฐ๋ฅํ ๋ฐ์ดํฐ์ ๋ง์ ์ฌ์ฉํ์ฌ๋ ์ต์ฒจ๋จ ๋ชจ๋ธ์ ํ๋ จ์ํฌ ์ ์๋ค๋ ๊ฒIntroduction๊ฐ์ฅ ํฐ ๋ชจ๋ธ์ด ์๋๋ผ ๋ ๋ง์ ๋ฐ์ดํฐ๋ก ํ๋ จ๋ ์์ ๋ชจ๋ธPretraining๊ณต๊ฐ์ ์ผ๋ก ์คํ๋ ๋ฐ์ดํฐ๋ง์ ์ฌ์ฉCCNet ํ์ดํ๋ผ์ธ, Ngram, Linear classifier, fastText ๋ฑ์ ์ด์ฉํ์ฌ data cleansingTokeniner : BPE(Byte Piece Encoding)Architecture: TransformerAdamW OptimizerBPE(Byte-Pair Encoding) ์๊ณ ๋ฆฌ์ฆ๋ฌธ์ ๋จ์ ๊ตฌ์ฑ๋จ์ด ๋จ์ ๊ตฌ์ฑ: ๋ฐ์ดํฐ ํจ์จ์ฑ ์ธก๋ฉด์์๋ ๋จ์ด..

VectorDB๋๋ฒกํฐDB๋?์ ๋ณด๋ฅผ ๋ฒกํฐ๋ก ์ ์ฅํ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋น์ ํ ๋ฐ์ดํฐ์ ๋ฐ์ ํ ๋ฐ์ดํฐ๋ก ๊ตฌ์ฑ๋ ๋๊ท๋ชจ ๋ฐ์ดํฐ ์ ์ ์์ธํ๊ณ ๊ฒ์๋ฒกํฐ ์๋ฒ ๋ฉ์ ์ฃผ์ , ๋จ์ด, ์ด๋ฏธ์ง ๋๋ ๊ธฐํ ๋ฐ์ดํฐ๋ฅผ ์ซ์๋ก ํํ์๋ฒ ๋ฉ ์ฌ์ด์ ๊ฑฐ๋ฆฌ ๋๋ ์ ์ฌ๋๋ฅผ ํตํด ๋ฒกํฐ ๊ฒ์ ์์ง์ด ๋ฒกํฐ ๊ฒ์์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ ๋ฒกํฐ ์๋ฒ ๋ฉ์ ์์ธํ๊ณ ์ฟผ๋ฆฌ์ต๊ทผ์ ์ ์ฌ ํญ๋ชฉ ๊ฒ์(ANN) - ํด์ฑ, ์์ํ, ๊ทธ๋ํ ๊ธฐ๋ฐ ๊ฒ์๋ฒกํฐDB์ ๋ฑ์ฅOracle, MySQL๊ณผ ๊ฐ์ ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ ๋ง์ ๊ธฐ์ ๋ฐ ์๋น์ค์์ ๋ง์ด ์ฌ์ฉ๋๊ณ ์๋ ๋ฐ์ดํฐ ์ ์ฅ ๋ฐฉ์์ผ๋ก, ๊ตฌ์กฐํ๋ ์ ํ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ ํจ๊ณผ์ ๊ทธ๋ฌ๋ RDBMS(๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค)๋ ๋น์ ํ ๋ฐ์ดํฐ ๋๋ ๋ค์ฐจ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ๊ด๋ฆฌํ๋ ๋ฐ ํ๊ณ๊ฐ ์์ํ ์คํธ, ์ด๋ฏธ์ง, ์ค๋์ค ๋ฑ์ ํ ์ด๋ธ์ ์ ์ฅํ..

ํน์ง ๋ฒกํฐ์ ์ ์ฌ๋ & ๊ฑฐ๋ฆฌ๋ฒกํฐ์ ๊ด๊ณ๋ฅผ ์ซ์๋ก ์์นํํ์ฌ ๋น๊ตL1 distancea = np.array([2, 5])b = np.array([4, 6])c = np.array([6, 2])# numpy๋ฅผ ์ด์ฉํ ๊ณ์ฐdistance = np.sum(np.abs(a - b))distance = np.linalg.norm(a - b, 1)# torch๋ฅผ ์ด์ฉํ ๊ณ์ฐtensor_a = torch.from_numpy(a).float()tensor_b = torch.from_numpy(b).float()distance = torch.norm(tensor_a - tensor_b, 1)L2 distance# numpy๋ฅผ ์ด์ฉํ ๊ณ์ฐdistance = np.sqrt(np.sum(np.square(a - b)))dist..