Numpy
- Numeriacal Python
- ํ์ด์ฌ ๋จธ์ ๋ฌ๋ ํจํค์ง์ธ scikit-learn์์ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ก ์ฌ์ฉ๋์ด Numpy ๋ฐฐ์ด ํํ์ ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉ
- ํ์ด์ฌ ๊ธฐ๋ฐ ๋ฐ์ดํฐ ๋ถ์ ํ๊ฒฝ์์ ํ๋ ฌ ๋ฐ ๋ฒกํฐ ์ฐ์ฐ์ ํ์ํ ๋ค์ํ ํจ์๋ฅผ ์ ๊ณต
- ๋ฉ๋ชจ๋ฆฌ ์๋ชจ๊ฐ ๋ง์ ๋ฐ๋ณต๋ฌธ ์์ด ์ ์ฒด ๋ฐ์ดํฐ ๋ฐฐ์ด์ ๋น ๋ฅธ ์ฐ์ฐ์ ์ฒ๋ฆฌํ ์ ์๋ ํ์ค ์ํ ํจ์
๋ฐฐ์ด : ๋์ผํ ํน์ฑ(๋ฐ์ดํฐ ํ์ ) ๋ฐ ์ผ์ ํ ๊ท์น์ ๊ฐ์ง๋ ์ฌ๋ฌ ๊ฐ์ ์์๊ฐ ๋์ด๋์ด ์๋ ๋ฐ์ดํฐ ์งํฉ
- ํ์ด์ฌ list ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ๋ ๋ณด๋ค Numpy์ ndarray ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ฉด ์ฐ์ฐ ์๋๊ฐ ๊ฐ์ ๋์ด ๋ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ๋ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌ
๐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ์ ธ์ค๊ธฐ : numpy
as ๋ณ์นญ ์ ์ธ ์ดํ์๋ ๋ณ์นญ์ผ๋ก ํด๋น ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๊ธฐ๋ฅ์ ํธ์ถํ ์ ์๋ค.
import ๋ผ์ด๋ธ๋ฌ๋ฆฌ as ๋ณ์นญ
๐ import numpy as np
Numpy ๋ฐฐ์ด : numpy.ndarray
- ๋ค์ฐจ์ ๋ฐฐ์ด(1์ฐจ์, 2์ฐจ์, 3์ฐจ์)์ผ๋ก ์ ์ฒด์ ์ธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ๊ตฌ์ฑํ๊ณ ์ฌ๋ฌ ๊ฐ์ ๋ฐ์ดํฐ ๋ฐฉํฅ์ ๊ฐ์ง๋ค.
- ๋ฐฐ์ด ์์ฑ : shape, ndim, dtype ๋ฑ
- ๋ฐ์ดํฐ ๋ฐฉํฅ : axis = 0(ํ/๋์ด), 1(์ด/ํญ), 2(์ฑ๋/๊น์ด) ์ฌ์ง์ ์ง์ด๋ฃ์๋๋ imgํ๊ทธ ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
1. ๋ฐฐ์ด ์์ฑ
- np.array(data)
- ํ์ด์ฌ list๊ฐ์ฒด๋ฅผ ์ ๋ฌ๋ฐ์ numpy list๋ก ๊ตํํด์ฃผ๋ ๋ช ๋ น์ด
- ๋ฐฐ์ด ์์ฑ
- shape : ๊ตฌ์กฐ (ํ, ์ด, ์ฐจ์)
- ndim : ์ฐจ์
- dtype : ๋ฐ์ดํฐ ํ์
- size : ์์ ๊ฐ์ = ํ * ์ด * ์ฐจ์
- ๋ฐฐ์ด ๋ฉ์๋
- astype() : ๋ฐ์ดํฐ ํ์ ๋ณํ(๋ฌธ์๋ฅผ ์ซ์๋ก ๋ผ๋์ง...)
- ํ์ด์ฌ ๋ด์ฅํจ์๋ฅผ ์ฌ์ฉํ ์์ฑ๊ฐ
- type() : ๊ฐ์ฒด์ ์๋ฃํ ํ์ธ
- len() : ์์ ๋ด๋ถ์ ์๋ฃ ๊ธธ์ด.
- Numpy ํจ์๋ฅผ ์ฌ์ฉํ ์์ฑ
- reshape(row, column) : ๋ฐฐ์ด ์ฌ๋ฐฐ์น(1 * 12๋ฅผ 3 * 4 ํํ๋ก ๋ฐ๊พผ๋ค๋์ง...)
- kind : ๋ฐ์ดํฐ ์ข
๋ฅ์ ๋ํ ๊ตฌ๋ถ ๊ธฐํธ
- b boolean
- i ์ ์(int)
- u ๋ถํธ์๋ ์ ์(unsigned int, +- ๊ฐ๋ ์์ด ์ ๋๊ฐ๋ง ์กด์ฌ)
- f ์ค์
- c ๋ณต์ ๋ถ๋์์์
- O ๊ฐ์ฒด
- S ๋ฐ์ดํธ ๋ฌธ์์ด(ascii ์ฝ๋, ์๋ฌธ์, ์ผ๋ถํน๋ฌธ, ์ซ์)
- U ์ ๋์ฝ๋ ๋ฌธ์์ด(ํ๊ธ, ์ค๊ตญ์ด, ํ๊ตญ์ด, ์๋์ด ๋ฑ ์์ด์ ๋ค๋ฅธ ๋ฌธ์)
- ๋ฐฐ์ด ๊ตฌ์กฐ ๋ณํ
๊ธฐ๋ณธ ๋ฐฐ์ด์ ์์ ์ด ๊ฐ์(6๊ฐ)์ ๋ณํํ๋ ค๋ ๊ตฌ์กฐ์ ์ด ๊ฐ์(6๊ฐ)๋ ์ผ์นํด์ผ ํ๋ค.
arr.reshape(2,3) # (2 * 3์ด 6์ด๋ฏ๋ก), reshape(ํ,์ด)
array([[1, 2, 3],
[4, 5, 6]])
- ํ์ด์ฌ 2์ฐจ์ ๋ฆฌ์คํธ๋ก Numpy ๋ฐฐ์ด ์์ฑ ๐" [ ] 1์ฐจ์, [[ ]] 2์ฐจ์, [[[ ]]] 3์ฐจ์" ๐
2์ฐจ์ ๋ฐฐ์ด์ shape ์์ฑ์(ํ(row,์ธ๋ก์ถ๊ฐ์), ์ด(colum,๊ฐ๋ก์ถ๊ฐ์))๋ง ๋ณํ
tmp = [[1,2,3,4],
[5,6,7,8]]
arr = np.array(tmp)
np_print(arr)
์์ฑ ๋ฐ ์ด๊ธฐํ ๐ฉ arr = np."zeros,ones,full,eye,empty((_,_))
np_print(arr)
- ์ด๊ธฐ๊ฐ์ ์ง์ ํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์๋์ผ๋ก ๊ฐ์ง๋ ๋ฐฐ์ด์ ์์ฑ
- np.zeros()
- np.ones()
- np.full()
- np.eye()
- np.empty()
1-1 np.zeros(shape(๋ชจ์), dtype = float)
- ์ง์ ๋ ๊ตฌ์กฐ์ ๋ฐฐ์ด์ ์์ฑํ๊ณ ๋ชจ๋ ์์๋ฅผ 0์ผ๋ก ์ด๊ธฐํ(zeros)
- shape : tupleํํ๋ก ํ, ์ด์ ์ง์
- dtype : ๋ฐฐ์ด์์ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ ํ์ ์ ์ง์ ,๊ธฐ๋ณธ๊ฐ์ numpy.float64
1-2. np.ones(shape(ํ,์ด),dtype = float)
- ์ง์ ๋ ๊ตฌ์กฐ์ ๋ฐฐ์ด์ ์์ฑํ๊ณ ๋ชจ๋ ์์๋ฅผ 1๋ก(ones) ์ด๊ธฐํ.
- shape : tuple ์๋ฃ๋ก ํ, ์ด ๊ตฌ์กฐ๋ฅผ ์ง์
- dtype : ๋ฐฐ์ด์ ๋ฐ์ดํฐ ํ์ ์ ์ง์ , ๊ธฐ๋ณธ๊ฐ = numpy.float64
1-3. np.full(shape, fill_value,dtype)
- ์ง์ ๋ ๊ตฌ์กฐ์ ๋ฐฐ์ด์ ์์ฑํ๊ณ ๋ชจ๋ ์์๋ฅผ fill_value ๊ฐ์ผ๋ก ์ด๊ธฐํ
- shape : tuple ์๋ฃํ์ผ๋ก ํ,์ด ๊ตฌ์กฐ๋ฅผ ์ง์
- dtype = ๋ฐฐ์ด์ ๋ฐ์ดํฐ ํ์ ์ ์ง์ ,๊ธฐ๋ณธ๊ฐ = ๋ค์ด์ค๋ ๋ฐ์ดํฐ์ ์๋ฃํ
1-4. np.eye(N, M= None,dtype=float)
- (N,M) ๊ตฌ์กฐ์ ๋จ์ ํ๋ ฌ์ ์์ฑ
- M : ์ด ๊ฐ์๋ฅผ ์ง์ , ๊ธฐ๋ณธ๊ฐ = N
- dtype : ๋ฐฐ์ด์ ๋ฐ์ดํฐ ํ์ ์ ์ง์ , ๊ธฐ๋ณธ๊ฐ = numpy.float64
1-4. np.eye(N, M= None,dtype=float)
- (N,M) ๊ตฌ์กฐ์ ๋จ์ ํ๋ ฌ์ ์์ฑ
- M : ์ด ๊ฐ์๋ฅผ ์ง์ , ๊ธฐ๋ณธ๊ฐ = N
- dtype : ๋ฐฐ์ด์ ๋ฐ์ดํฐ ํ์ ์ ์ง์ , ๊ธฐ๋ณธ๊ฐ = numpy.float64
like ํจ์
- ์ ๋ฌ๋ฐ์ ๋ฐฐ์ด๊ณผ ๋์ผํ shape์ผ๋ก ์ด๊ธฐ๊ฐ์ ์ค์ ํ์ฌ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑ
- np.zeous_like() : ์ด๊ธฐ๊ฐ์ 0์ผ๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ์์ฑ
- np.ones_like() : ์ด๊ธฐ๊ฐ์ 1๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ์์ฑ
- np.full_like() : ์ด๊ธฐ๊ฐ์ fill_value ๊ฐ์ผ๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ์์ฑ
โ ก. ๋ฐฐ์ด ์์ฑ ๋ฐ ์ด๊ธฐํ
- ๋ฒ์์ ์กฐ๊ฑด์ด ์๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๋ 1์ฐจ์ ๋ฐฐ์ด ์์ฑ
- np.linspace()
- np.arange()
- np.logspace()
2-1. np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
- ์์๊ฐ(start)๋ถํฐ ๋ง์ง๋ง๊ฐ(stop) ์ฌ์ด์ ๋ฒ์์์ ๊ท ๋ฑํ ๊ฐ๊ฒฉ์ผ๋ก ์ผ์ ๊ฐ์(num)๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๋ ๋ฐฐ์ด ์์ฑ
- num : ๋ฐ์ดํฐ ๊ฐ์, ๊ธฐ๋ณธ๊ฐ = 50
- endpoint : ๋ง์ง๋ง๊ฐ์ stop์ ํฌํจ/์ ์ธํ๋ ์กฐ๊ฑด ์ง์ , ๊ธฐ๋ณธ๊ฐ = True(ํฌํจ)
- retstep : True๋ก ์ ๋ฌํ๋ฉด (๋ฐฐ์ด, ๋ฐ์ดํฐ ์ฌ์ด์ ๊ฐ๊ฒฉ)์ ๋ฐ์ดํฐ๋ฅผ ๋ด์ tuple์ ๋ฐํ
- dtype : ๋ฐฐ์ด์ ๋ฐ์ดํฐ ํ์ ์ ์ง์ , ๊ธฐ๋ณธ๊ฐ = None
์์
- ๊ธฐ๋ณธ๊ฐ
0์ด์ 1์ดํ์ ๋ฒ์์์ ๋ฐ์ํ ์ซ์ 5๊ฐ๋ฅผ ํฌํจํ๋ ๋ฐฐ์ด
arr= np.linspace(0, 1, num=5)
np_print(arr)
type : <class 'numpy.ndarray'>
shape : (5,)
ndim : 1
dtype : float64
array data :
[0. 0.25 0.5 0.75 1. ]
- endpoint๋ฅผ False๋ก ๋ณํ
arr = np.linspace(0, 1, num=5, endpoint=False)
np_print(arr)
type : <class 'numpy.ndarray'>
shape : (5,)
ndim : 1
dtype : float64
array data :
[0. 0.2 0.4 0.6 0.8]
endpoint ๋ฅผ False๋ก ๋ณํํ๊ธฐ ๋๋ฌธ์ 1์ ๋บ ๋๋จธ์ง ๊ฐ์ผ๋ก ๋ํ๋๊ธฐ๋๋ฌธ์
๋ฐ์ดํฐ ๊ฐ์ด ๋ค๋ฅธ๊ฒ์ ๋ณผ ์ ์๋ค.
2-1. np.arange(start=0, stop, step=1, dtype=None)
- ์์๊ฐ(start)๋ถํฐ ๋ง์ง๋ง๊ฐ(stop) ์ฌ์ด์ ๋ฒ์์์ ์ง์ ํ ๊ฐ๊ฒฉ(step)์ผ๋ก ์ผ์ ๊ฐ์(num)๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๋ ๋ฐฐ์ด ์์ฑ
- ํ์ด์ฌ ๋ด์ฅํจ์ range()์ ์ ์ฌ
- start : ์์๊ฐ, ๊ธฐ๋ณธ๊ฐ = 0
- stop : ๋ง์ง๋ง๊ฐ์ผ๋ก ๋ฒ์์ ํฌํจ๋์ง ์์
- step : ๋ฐ์ดํฐ ์ฌ์ด์ ๊ฐ๊ฒฉ, ๊ธฐ๋ณธ๊ฐ = 1
- dtype : ๋ฐฐ์ด์ ๋ฐ์ดํฐ ํ์ ์ ์ง์ , ๊ธฐ๋ณธ๊ฐ = None
arange() ๋ฉ์๋๋ก ์์ฑ๋ ๋ฐฐ์ด๊ณผ shape(1, 5)์ธ ๋ฐฐ์ด์ ๋์ผํด ๋ณด์ด์ง๋ง
โ shape ์ dimetion์ด ์๋ก ๋ค๋ฅด๋ค โ
์์
shape : (4,)
ndim : 1
shape : (1, 4)
ndim : 2
โ ก. ๋ฐฐ์ด ์์ฑ ๋ฐ ์ด๊ธฐํ
- ๋์(ํน์ ํ ์์๋ ๊ท์น์ ๊ฐ์ง์ง ์๋ ๋ฌด์์์ ์)๋ฅผ ๋ฐ์ดํฐ๋ก ๊ฐ์ง๋ ๋ฐฐ์ด์ ์์ฑ
- np.random.normal()
- np.random.rand()
- np.random.randn()
- np.random.randint()
- np.random.random()
3-1. np.random.normal(loc=0.0, scale=1.0, size=None)
- ์ ๊ท ๋ถํฌ ํ๋ฅ ๋ฐ๋์์ ํ๋ณธ์ ์ถ์ถํ์ฌ ๋ฐ์ดํฐ๋ก ๊ฐ์ง๋ ๋ฐฐ์ด์ ์์ฑ
- loc : ์ ๊ท๋ถํฌ์ ํ๊ท , ๊ธฐ๋ณธ๊ฐ = 0.0
- scale : ์ ๊ท๋ถํฌ์ ํ์คํธ์ฐจ, ๊ธฐ๋ณธ๊ฐ = 1.0
- size : (ํ,์ด,์ฐจ์)์ ๋ฐฐ์ด ๊ตฌ์กฐ, ๊ธฐ๋ณธ๊ฐ = single value(๋ฐฐ์ด์ด ์๋ ํ๋์ ๊ฐ์ ๋ฐํ)
3-2. np.random.rand(d0, d1, ..., dn)
- ์ง์ ํ shape(d0, d1...)์ ๋ฐ๋ผ ๋ฐฐ์ด์ ์์ฑํ ํ ๋์๋ก ์ด๊ธฐํ
- ์ฌ์ฉ๋๋ ๋์๋ 0 ์ด์ 1๋ฏธ๋ง์ ๋ฒ์์์ ๊ท ๋ฑ ๋ถํฌ๋ก ์ถ์ถ
3-3. np.random.randn(d0, d1,....dn)
- ์ง์ ํ shape(d0,d1...)์ ๋ฐ๋ผ ๋ฐฐ์ด์ ์์ฑํ ํ ๋์๋ก ์ด๊ธฐํ
- ์ฌ์ฉ๋๋ ๋์๋ ํ์ค์ ๊ท๋ถํฌ์์ ์ถ์ถ๋ ๋ฐ์ดํฐ
3-4. np.random.randint(low, high=None, size=None, dtype = ' ')
- low ์ด์ high ๋ฏธ๋ง์ ๋ฒ์์์ ์์๋ก ๊ตฌ์ฑ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ ์ง์ ํ size์ ๋ฐฐ์ด์ ์์ฑ
- low : high ๊ฐ์ด ์ง์ ๋์ง ์์ผ๋ฉด low ๊ฐ์ด ์ต๋๊ฐ(ํฌํจํ์ง ์์)์ผ๋ก ์ค์
- high : ์ต๋๊ฐ(ํฌํจํ์ง ์์), ๊ธฐ๋ณธ๊ฐ = None
- size : ๋ฐฐ์ด์ ๊ตฌ์กฐ, ๊ธฐ๋ณธ๊ฐ = None(๋ฐฐ์ด์ด ์๋ ํ๋์ ๊ฐ์ผ๋ก ๋ณํ)
โป ๋์ = ๋ฌด์์์ ์ซ์
- ํ๋ก๊ทธ๋๋ฐ์์ ์ถ์ถ๋๋ ๋์๋ ๋ฌด์์๋ก ๋ง๋ค์ด์ง ๊ฒ ์ฒ๋ผ ๋ณด์ด์ง๋ง ์ค์ ๋ก๋ ๊ณ ์ ๋ ๊ธฐ์ค(์์์ )์ ๊ฐ์ง๊ณ ๊ท์น์ ์ผ๋ก ์์ฑ
- ์์์ ์ ์ค์ ํ๋ค๋ฉด ๋์ผํ ๋์๋ฅผ ๋๊ฐ์ด ์์ฑ ๊ฐ๋ฅ
- ๋์์ ์์์ ์ค์ : np.random.seed()
๐คข์ค๋์ ๊ณ ๋(difficulty)๐คข ๋ถ์ฐ๊ณผ ํ์คํธ์ฐจ
์ด๋ค ์ง๋จ๊ฐ ํ๊ท ์ด ๊ฐ๋ค๊ณ ํด์ ๋ฐ๋์ ๋ถํฌ๊ฐ ๊ฐ์ง๋ ์์ต๋๋ค.
ํ๊ท ์์ ์ด๋ค ์์๊ฐ ์ผ๋ง๋ ๋ฉ๋ฆฌ ๋จ์ด์ ธ์๋์ง๋ฅผ ๋ํ๋ด๋ ๋ถ์ฐ๊ฐ์ ๊ตฌํ ๋ค์
๋ถ์ฐ์ ์ ๊ณฑ๊ทผ์ ์์ ํ์คํธ์ฐจํ ์์ผ์ผ ๋น๋ก์ ๋ถํฌ๊ฐ ๋์ ๋ณด์ ๋๋ค.
์ ๊ณฑ๊ทผ ์์๋ณด๊ธฐ


๋ถ์ฐ์ ๊ด์ธก๊ฐ์์ ํ๊ท ์ ๋บ ๊ฐ์ ์ ๊ณฑํ๊ณ , ๊ทธ๊ฒ์ ๋ชจ๋ ๋ํ ํ ์ ์ฒด ๊ฐ์๋ก ๋๋ ์ ๊ตฌํ๋ค.
์ฆ, ์ฐจ์ด๊ฐ์ ์ ๊ณฑ์ ํ๊ท ์ด๋ค. ๊ด์ธก๊ฐ์์ ํ๊ท ์ ๋บ ๊ฐ์ธ ํธ์ฐจ๋ฅผ ๋ชจ๋ ๋ํ๋ฉด 0์ด ๋์ค๋ฏ๋ก ์ ๊ณฑํด์
๋ํ๋ค.
ํ์ค ํธ์ฐจ๋ ๋ถ์ฐ์ ์ ๊ณฑ๊ทผํ ๊ฒ์ด๋ค. ํธ์ฐจ๋ค์ ์ ๊ณฑํฉ์์ ์ป์ด์ง ๊ฐ์ ํ๊ท ์น์ธ ๋ถ์ฐ์ ์ฑ์ง๋ก๋ถํฐ ๋ค์
์ ๊ณฑ๊ทผํด์ ์๋ ๋จ์๋ก ๋ง๋ค์ด์ค์ผ๋ก์จ ์ป๊ฒ๋๋ค.
-๊ธฐ๋ณธ๊ฐ
v = np.random.normal(ํ๊ท ๊ฐ_,ํ์คํธ์ฐจ_) ํ๊ท _, ํ์คํธ์ฐจ _๋ก ์ค์ ํ๊ณ ๋์ ๋ฝ๊ธฐ
- ์ ๊ท๋ถํฌ ๋ฐ์ดํฐ๋ก ์ด๋ฃจ์ด์ง ๋ฐฐ์ด์ ๋ํ ์๊ฐํ
โ
ํ๊ท 10, ํ์คํธ์ 2์ธ ์ ๊ท๋ถํฌ์์ ์ถ์ถํ 10000๊ฐ์ ๋ฐ์ดํฐ
โ
data = np.random.normal(10, 2, size = 10000)
data
8 ~ 12 = ์ฝ 70%
6.08 ~ 13.92 = 95%(2 * 1.96)
'ํ๋ฃจ๊ณต๋ถ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ 12์ฅ ๐๋ฐ์ดํฐ ๋ถ์_pandas(Series ์๋ฃํ)๐ (0) | 2022.10.21 |
---|---|
์ 11์ฅ ๐๋ฐ์ดํฐ ๋ถ์_Numpy-2(์ฐ์ฐ)๐ (0) | 2022.10.20 |
์ 9์ฅ ๐ํ์ด์ฌ(python) ๊ตฌ์กฐ์ฒด์ ํด๋์ค๐ (0) | 2022.10.17 |
์ 8์ฅ ๐ํฌ๋กค๋ง(crawling) ๊ณผ ๋คํธ์ํฌ์ ๊ธฐ๋ณธ ์๋ฆฌ๐ (0) | 2022.10.14 |
์ 7์ฅ ๐ํฌ๋กค๋ง_ํฌ๋กค๋ง๊ธฐ์ด, ์คํ๋ฐฉ๋ฒ๐ (0) | 2022.10.13 |