#파이썬 기초 10일차_1

numpy 이어서 진행

arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

arr3d

array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

arr3d[0]

array([[1, 2, 3],
       [4, 5, 6]])

arr3d[0][0]

array([1, 2, 3])

arr3d[0][0][1]

2

 

별다른 설정을 하지 않는이상 원소대 원소로 적용된다.

스칼라를 넣으면 각 원소대로 동일하게 적용된다.

 

old_values = arr3d[0].copy()

arr3d[0] = 42

arr3d

array([[[42, 42, 42],
        [42, 42, 42]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

arr3d[0] = old_values

arr3d

array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

 

콤마를 이용한 접근

arr3d[1, 0]

array([7, 8, 9])

x = arr3d[1]

x

array([[ 7,  8,  9],
       [10, 11, 12]])

x[0]

array([7, 8, 9])

 

• 슬라이스를 이용한 인덱싱

arr = np.array([0,1,2,3,4,64,64,64,8,9])

arr[1:6]

array([ 1,  2,  3,  4, 64])

 

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

arr2d

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

arr2d[:2]

array([[1, 2, 3],
       [4, 5, 6]])

arr2d[:2, 1:]

array([[2, 3],
       [5, 6]])

arr2d[1, :2]

array([4, 5])

arr2d[:2, 2]

array([3, 6])

arr2d[:, :1] # 영역을 줘서 각각의 배열로 가져옴

array([[1],
       [4],
       [7]])

arr2d[:2, 1:] = 0 # 해당하는 영역을 0으로 바꾼다는 의미

arr2d

array([[1, 0, 0],
       [4, 0, 0],
       [7, 8, 9]])

• 불린 인덱싱

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])

data = np.random.randn(7, 4)

names

array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='<U4')

data

array([[ 0.31418733,  0.14202765,  0.11819096, -0.20852206],
       [-0.93224175, -0.82938926, -0.14524378,  1.46134767],
       [ 2.93379231,  0.49556681, -1.92467859, -1.01128291],
       [-0.90621418, -0.23677077,  0.22141414,  0.85750657],
       [-0.54026319,  0.63043219,  1.72885665, -0.02455902],
       [ 1.20207865, -1.44712328,  1.64159005, -0.29737174],
       [-0.33611151,  0.13768536,  0.53848796,  0.41348996]])

 

특정 조건식 이용

names == 'Bob'

array([ True, False, False,  True, False, False, False])

data[names == 'Bob']

array([[ 0.31418733,  0.14202765,  0.11819096, -0.20852206],
       [-0.90621418, -0.23677077,  0.22141414,  0.85750657]])

data[names == 'Bob', 2:]

array([[ 0.11819096, -0.20852206],
       [ 0.22141414,  0.85750657]])

data[names == 'Bob', 3]

array([-0.20852206,  0.85750657])

 

조건식 바꿔도 다른형태로 가져올 수 있을까?

data[(names != 'Bob')]

array([[-0.93224175, -0.82938926, -0.14524378,  1.46134767],
       [ 2.93379231,  0.49556681, -1.92467859, -1.01128291],
       [-0.54026319,  0.63043219,  1.72885665, -0.02455902],
       [ 1.20207865, -1.44712328,  1.64159005, -0.29737174],
       [-0.33611151,  0.13768536,  0.53848796,  0.41348996]])

data[~(names == 'Bob')] 

array([[-0.93224175, -0.82938926, -0.14524378,  1.46134767],
       [ 2.93379231,  0.49556681, -1.92467859, -1.01128291],
       [-0.54026319,  0.63043219,  1.72885665, -0.02455902],
       [ 1.20207865, -1.44712328,  1.64159005, -0.29737174],
       [-0.33611151,  0.13768536,  0.53848796,  0.41348996]])

cond = names == 'Bob'

data[~cond]

array([[-0.93224175, -0.82938926, -0.14524378,  1.46134767],
       [ 2.93379231,  0.49556681, -1.92467859, -1.01128291],
       [-0.54026319,  0.63043219,  1.72885665, -0.02455902],
       [ 1.20207865, -1.44712328,  1.64159005, -0.29737174],
       [-0.33611151,  0.13768536,  0.53848796,  0.41348996]])

 

조건식 조합을 통해 사용 (마스킹, 마스킹 작업 / 해당하는 부분은 걸러 내겠다)

mask = (names == 'Bob') | (names == 'Will')

print(mask)

data[mask]

[ True False  True  True  True False False]
array([[ 0.31418733,  0.14202765,  0.11819096, -0.20852206],
       [ 2.93379231,  0.49556681, -1.92467859, -1.01128291],
       [-0.90621418, -0.23677077,  0.22141414,  0.85750657],
       [-0.54026319,  0.63043219,  1.72885665, -0.02455902]])

 

크기 조건을 통해서 사용

data[data < 0] = 0

data

array([[0.31418733, 0.14202765, 0.11819096, 0.        ],
          [0.        , 0.        , 0.        , 1.46134767],
          [2.93379231, 0.49556681, 0.        , 0.        ],
          [0.        , 0.        , 0.22141414, 0.85750657],
          [0.        , 0.63043219, 1.72885665, 0.        ],
          [1.20207865, 0.        , 1.64159005, 0.        ],
          [0.        , 0.13768536, 0.53848796, 0.41348996]])

 

data[names != 'Joe'] = 7

data

array([[7.        , 7.        , 7.        , 7.        ],
       [0.        , 0.        , 0.        , 1.46134767],
       [7.        , 7.        , 7.        , 7.        ],
       [7.        , 7.        , 7.        , 7.        ],
       [7.        , 7.        , 7.        , 7.        ],
       [1.20207865, 0.        , 1.64159005, 0.        ],
       [0.        , 0.13768536, 0.53848796, 0.41348996]])

• 팬시 인덱싱

arr = np.empty((8, 4))

arr

array([[1.  , 0.  , 0.16, 1.  ],
       [1.  , 0.  , 0.  , 1.  ],
       [1.  , 1.  , 0.  , 1.  ],
       [0.  , 1.  , 0.  , 1.  ],
       [0.  , 1.  , 1.  , 1.  ],
       [0.  , 0.  , 1.  , 1.  ],
       [1.  , 0.  , 1.  , 1.  ],
       [1.  , 0.  , 0.75, 1.  ]])

for i in range(8):

    arr[i] = i

arr

array([[0., 0., 0., 0.],
       [1., 1., 1., 1.],
       [2., 2., 2., 2.],
       [3., 3., 3., 3.],
       [4., 4., 4., 4.],
       [5., 5., 5., 5.],
       [6., 6., 6., 6.],
       [7., 7., 7., 7.]])

arr[[4, 3, 0, 6]] # 지정한 순서대로 행을 가져와라는 뜻

array([[4., 4., 4., 4.],
       [3., 3., 3., 3.],
       [0., 0., 0., 0.],
       [6., 6., 6., 6.]])

arr[[-3, -5, -7]] # -를 이용해 뒤에부터 실행

array([[5., 5., 5., 5.],
       [3., 3., 3., 3.],
       [1., 1., 1., 1.]])

 

arr = np.arange(32)

arr

array([ 0,  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])

 

속성을 바꿔주는 reshape

arr = arr.reshape((8, 4))

arr

array([[ 0,  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]])

arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]

array([[ 4,  7,  5,  6],
       [20, 23, 21, 22],
       [28, 31, 29, 30],
       [ 8, 11,  9, 10]])

2-3. 전치행렬과 축 교환

데이터를 행렬 연산할 때 데이터 방향을 바꾸거나 하는 경우에 사용

arr = np.arange(15).reshape((3, 5))

arr

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

 

전치 행렬 (대각선을 기준으로 돌리는것)

arr.T # 행렬 이 바뀜

array([[ 0,  5, 10],
       [ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13],
       [ 4,  9, 14]])

arr = np.random.randn(6, 3)

arr

array([[ 0.38837876, -1.53383263, -0.70905096],
       [ 0.39830945,  1.01735593, -0.53527625],
       [-0.87479425, -1.85106408, -0.71978754],
       [ 1.24467637, -0.93007816, -0.20992612],
       [-0.47212238, -0.35539639, -0.76731272],
       [ 0.57663902, -0.24281578, -1.49965593]])

 

dot 연산자 : 행렬곱을 하기 위한 연산자

np.dot(arr.T, arr)

array([[ 3.17938483,  0.2989419 , -0.62270462],
       [ 0.2989419 ,  7.86440533,  2.7074599 ],
       [-0.62270462,  2.7074599 ,  4.18917373]])

 

 

arr = np.arange(16).reshape((2, 2, 4))

arr

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

 

축교환 두가지 방법( transpose, seapaxes)

• transpose 메서드는 다차원 배열의 축 순서를 재배열하는 데 사용. 기본적으로 2차원 배열에서는 행과 열을 교환하는 역할을 하며, 다차원 배열에서는 원하는 축 순서로 재배열할 수 있다.
• swapaxes 메서드는 배열의 두 축을 교환하는 데 사용. 이 방법은 특정 두 축만 교환하고 싶을 때 유용함

arr.transpose((1, 0, 2)) # 면 행 열에서 면과 행을 변경함

array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

arr

arr.swapaxes(1, 2) # 2행 1열을 1행 2열로 바꾸는것

array([[[ 0,  4],
        [ 1,  5],
        [ 2,  6],
        [ 3,  7]],

       [[ 8, 12],
        [ 9, 13],
        [10, 14],
        [11, 15]]])

2-4. 유니버설 함수

• ndarray 안에 있는 데이터 원소별로 연산을 수행하는 함수

arr = np.arange(10)

arr

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.sqrt(arr) # 각각의 제곱근 계산

array([0.        , 1.        , 1.41421356, 1.73205081, 2.        ,
       2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.        ])

np.exp(arr) # 각각의 지수함수 계산

array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,
       5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,
       2.98095799e+03, 8.10308393e+03])

x = np.random.randn(8)

y = np.random.randn(8)

x

y

np.maximum(x, y) # x값과 y값중 큰것을 골라오는것

array([-0.01098015, -0.63540319,  0.51363782,  0.82891089,  1.79008276,
        0.00271256,  0.46864156,  0.86479942])

arr = np.random.randn(7) * 5

print(arr)

remainder, whole_part = np.modf(arr)

print(remainder) # 소수부

print(whole_part) # 정수부

[-5.13297704 -4.51889828 -1.04951801  7.74404083 -3.71578438 -9.68176313
  3.04555507]
[-0.13297704 -0.51889828 -0.04951801  0.74404083 -0.71578438 -0.68176313
  0.04555507]
[-5. -4. -1.  7. -3. -9.  3.]

 

• p.sqrt 함수는 배열의 각 요소에 대해 제곱근을 계산, 그러나 배열의 요소 중 음수가 포함되어 있으면, 그 값에 대한 제곱근은 실수 영역에서 정의되지 않기 때문에 경고 메시지와 함께 nan (Not a Number)이 반환된다.
• np.sqrt(arr, arr)처럼 두 번째 인수를 지정하면, 제곱근 결과를 원래 배열에 직접 저장하게 됩니다. 이로 인해 원래 배열도 변경된다.

arr

np.sqrt(arr)

np.sqrt(arr, arr)

arr

<ipython-input-55-bcce5ef9aa78>:2: RuntimeWarning: invalid value encountered in sqrt
  np.sqrt(arr)
<ipython-input-55-bcce5ef9aa78>:3: RuntimeWarning: invalid value encountered in sqrt
  np.sqrt(arr, arr)
array([       nan,        nan,        nan, 2.78281168,        nan,
              nan, 1.74515188])

2-5. 배열을 사용한 데이터 처리

points = np.arange(-5, 5, 0.01) # 1000 equally spaced points

xs, ys = np.meshgrid(points, points)

ys

array([[-5.  , -5.  , -5.  , ..., -5.  , -5.  , -5.  ],
       [-4.99, -4.99, -4.99, ..., -4.99, -4.99, -4.99],
       [-4.98, -4.98, -4.98, ..., -4.98, -4.98, -4.98],
       ...,
       [ 4.97,  4.97,  4.97, ...,  4.97,  4.97,  4.97],
       [ 4.98,  4.98,  4.98, ...,  4.98,  4.98,  4.98],
       [ 4.99,  4.99,  4.99, ...,  4.99,  4.99,  4.99]])

z = np.sqrt((xs ** 2) + (ys ** 2))

z

array([[7.07106781, 7.06400028, 7.05693985, ..., 7.04988652, 7.05693985,
        7.06400028],
       [7.06400028, 7.05692568, 7.04985815, ..., 7.04279774, 7.04985815,
        7.05692568],
       [7.05693985, 7.04985815, 7.04278354, ..., 7.03571603, 7.04278354,
        7.04985815],
       ...,
       [7.04988652, 7.04279774, 7.03571603, ..., 7.0286414 , 7.03571603,
        7.04279774],
       [7.05693985, 7.04985815, 7.04278354, ..., 7.03571603, 7.04278354,
        7.04985815],
       [7.06400028, 7.05692568, 7.04985815, ..., 7.04279774, 7.04985815,
        7.05692568]])

 

LaTeX는 과학 및 수학 문서 작성을 위한 고급 마크업 언어

• LaTeX를 사용하여 수식을 표현할 때는 보통 $ 기호를 사용하여 인라인 수식을, $$ 기호를 사용하여 디스플레이 수식을 작성

import matplotlib.pyplot as plt

plt.imshow(z, cmap=plt.cm.gray);

plt.colorbar()

plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")

Text(0.5, 1.0, 'Image plot of $\\sqrt{x^2 + y^2}$ for a grid of values')

 

plt.draw()

<Figure size 640x480 with 0 Axes>

 

파일을 열고 닫을때는 다썼으면 항상 close를 해주는 것이 좋다.

plt.close('all')

 

2-5-1. 배열연산으로 조건절 표현하기

xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])

yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])

cond = np.array([True, False, True, True, False])

result = [(x if c else y)

          for x, y, c in zip(xarr, yarr, cond)]

result

[1.1, 2.2, 1.3, 1.4, 2.5]

result = np.where(cond, xarr, yarr)

result

array([1.1, 2.2, 1.3, 1.4, 2.5])

 

 

arr = np.random.randn(4, 4) # rand만 하면 양수만 들고옴

arr

array([[-0.87861922, -0.02027518, -0.19702262,  0.49494806],
       [-0.20048939, -1.69634798,  1.18348629,  0.53803308],
       [-0.79133033, -0.30097681, -0.54936791,  0.74210303],
       [ 0.15464454,  0.29397788,  0.32126662,  1.04555782]])

arr > 0

array([[False, False, False,  True],
       [False, False,  True,  True],
       [False, False, False,  True],
       [ True,  True,  True,  True]])

np.where(arr > 0, 2, -2) #0보다 크면 2를 작으면 -2를 리턴

array([[-2, -2, -2,  2],
       [-2, -2,  2,  2],
       [-2, -2, -2,  2],
       [ 2,  2,  2,  2]])

np.where(arr > 0, 2, arr) # set only positive values to 2, 0보다 크면 2 아님 원래값 넣어라

array([[-0.87861922, -0.02027518, -0.19702262,  2.        ],
       [-0.20048939, -1.69634798,  2.        ,  2.        ],
       [-0.79133033, -0.30097681, -0.54936791,  2.        ],
       [ 2.        ,  2.        ,  2.        ,  2.        ]])

 

2-5-2. 수학 메소드와 통계 메소드

arr = np.random.randn(5, 4)

arr

array([[-1.25417795, -1.0534699 ,  0.64255036, -1.98149258],
       [ 1.786615  , -0.07500399,  0.01232515,  1.53307419],
       [-0.3441816 ,  1.98396668,  0.46314424,  0.20514597],
       [ 0.2274051 , -0.32340827, -0.59670309,  0.46545841],
       [ 0.18942443,  1.10625815, -0.81793688, -0.0247016 ]])

arr.mean()

0.10721459181540043

np.mean(arr)

0.10721459181540043

arr.sum()

2.1442918363080086

 

축 지정해서 평균값 계산 (0은 로우(행), 1은 컬럼(열))

arr.mean(axis=1) # 열 기준

array([-0.91164752,  0.81425259,  0.57701882, -0.05681196,  0.11326103])

arr.sum(axis=0) # 행 기준

array([-1.17651492,  0.62745125,  0.59247687,  0.34556712])

 

cumsum : 누적합

arr = np.array([0, 1, 2, 3, 4, 5, 6, 7])

arr.cumsum()

array([ 0,  1,  3,  6, 10, 15, 21, 28])

 

arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])

arr

print(arr.cumsum(axis=0)) # 행기준으로 누적합

print(arr.cumprod(axis=1)) # 열 기준으로 누적합

[[ 0  1  2]
 [ 3  5  7]
 [ 9 12 15]]
[[  0   0   0]
 [  3  12  60]
 [  6  42 336]]

2-5-3. 불리언 배열을 위한 메소드

arr = np.random.randn(100)

(arr > 0).sum() # Number of positive values

50

arr

array([ 1.33455503, -1.0799514 , -0.67697912,  1.43785143, -0.70609799,
        0.32280939, -2.65886002,  0.78521121, -0.81513527,  0.70595104,
        1.24209257,  0.93828393,  1.85087578,  1.80415341,  1.08827931,
       -0.57110892, -1.13116583,  0.52928888, -0.51802388, -0.79643948,
        1.85863318, -1.22659384, -0.57102941,  0.60266867,  0.28130688,
       -0.89871307,  1.00954541, -1.04621967, -0.42707254, -0.88548443,
        0.16517217,  1.33653896,  1.01990512,  1.200431  , -0.63634069,
       -0.76048001, -0.14640436, -0.70842833,  0.61570765,  0.26456433,
        1.327428  ,  0.9373116 ,  0.50557473, -0.93261726,  0.05061311,
        0.21789508,  1.17199977, -1.42296151,  0.88482975, -0.64599318,
        0.92106674, -1.0625743 , -0.44676127, -1.23943006,  0.10157491,
       -0.34316664,  0.44367653, -0.78977748,  0.77380698, -1.35129422,
       -0.50898886, -1.87041103, -0.1302399 , -0.81115088,  0.30895486,
       -1.0918783 ,  0.13984116, -0.47300834,  0.87216203,  0.17649997,
        0.18947673, -1.68946669, -0.62099707,  0.08624882,  0.2841831 ,
        2.72471551, -2.00513849, -0.81972458,  1.56282409,  1.52441391,
        0.06080744, -0.70218363, -0.43403293,  0.51382889,  1.18276367,
       -0.34258527, -1.571904  , -1.03991186,  0.81339957, -1.53300246,
        0.40444278, -0.16248265,  0.00362608,  1.12504321, -0.05479325,
       -0.25361964, -1.45209904,  0.19102457, -0.7385162 , -0.45394433])

print(arr>0)

[ True False False  True False  True False  True False  True  True  True
  True  True  True False False  True False False  True False False  True
  True False  True False False False  True  True  True  True False False
 False False  True  True  True  True  True False  True  True  True False
  True False  True False False False  True False  True False  True False
 False False False False  True False  True False  True  True  True False
 False  True  True  True False False  True  True  True False False  True
  True False False False  True False  True False  True  True False False
 False  True False False]

 

any() 함수는 반복 가능한 객체 내의 원소들 중 하나라도 참(True)인 값이 있을 경우 참(True)을 반환

all() 함수는 반복 가능한 객체 내의 모든 원소가 참(True)일 경우 참(True)을 반환하고, 하나라도 거짓(False)이면 거짓(False)을 반환

bools = np.array([False, False, True, False])

bools.any()

True

bools.all()

True

2-5-4. 정렬

arr = np.random.randn(6)

arr

array([ 1.02656115,  0.8079371 , -0.21351779, -0.98191918, -0.13679464,
        1.99789963])

arr.sort()

arr

array([-0.98191918, -0.21351779, -0.13679464,  0.8079371 ,  1.02656115,
        1.99789963])

arr = np.random.randn(5, 3)

arr

array([[-1.06079774,  1.59523589, -1.05682653],
       [-1.12294276,  0.79404114,  1.05618036],
       [-1.84365856, -0.65495481,  0.07259978],
       [ 0.45496901,  0.06344372, -0.74801799],
       [ 0.27582879,  1.22379075, -1.72971784]])

arr.sort(1) # 1은 컬럼기준 정렬, 값들이 세트로 움직이기 않는다(각각 따로 값이 바뀐다)

arr

array([[-1.06079774, -1.05682653,  1.59523589],
       [-1.12294276,  0.79404114,  1.05618036],
       [-1.84365856, -0.65495481,  0.07259978],
       [-0.74801799,  0.06344372,  0.45496901],
       [-1.72971784,  0.27582879,  1.22379075]])

 

 

large_arr = np.random.randn(100)

print(large_arr)

# 100개 생성

large_arr.sort()

print(large_arr)

# sort정렬

large_arr[int(0.5 * len(large_arr))]

0.012043351846583436

 

2-5-5. 집합함수

집합은 중복되는 값들이 들어가지않음(전부 유니크한 값들)

넘파이에서는 유니크(unique) 제공

names = np.array(['Joe', 'Will', 'Bob', 'Will', 'Bob', 'Joe', 'Joe'])

np.unique(names)

array(['Bob', 'Joe', 'Will'], dtype='<U4') # 중복된거 제거하고 함

ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])

np.unique(ints)

array([1, 2, 3, 4])

set(names)

{'Bob', 'Joe', 'Will'}

sorted(set(names))

['Bob', 'Joe', 'Will']

values = np.array([6, 0, 0, 3, 2, 5, 6])

np.in1d(values, [2, 3, 6])

array([ True, False, False,  True,  True, False,  True])

 

2-5-6. 배열을 사용한 파일 입출력

현재 위치에 some_array.txt 파일 저장

arr = np.arange(10)

np.save('./some_array.txt', arr)

넘파이에서 제공하는 텍스트 압축 파일

load로 읽어오기

np.load('./some_array.txt.npy')

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

 

savez  :  더 작은 공간에 저장하기 위해 묶어서 사용

np.savez('./array_archive.npz', a=arr, b=arr)

arch = np.load('./array_archive.npz')

print(arch['b'])

print(arch['a'])

[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]

np.savez_compressed('./arrays_compressed.npz', a=arr, b=arr)

 

압축해서 저장

2-6. 선형대수

x = np.array([[1., 2., 3.], [4., 5., 6.]])

y = np.array([[6., 23.], [-1, 7], [8, 9]])

x.dot(y) # x에다 y를 행렬곱 , 넘파이에서 어레이타입의 메소드로 제공

array([[ 28.,  64.],
       [ 67., 181.]])

np.dot(x, y) # 넘파이에서 함수로 제공

array([[ 28.,  64.],
       [ 67., 181.]])

 

np.ones(3)

array([1., 1., 1.])

np.dot(x, np.ones(3)) # 행렬곱

array([ 6., 15.])

x @ np.ones(3) # @ 도 행렬곱을 나타내는 연산자이다.

array([ 6., 15.])

 

선형대수에서 사용하고있는 코드

 

numpy.linalg.qr 함수는 QR 분해(QR decomposition)를 수행합니다. QR 분해는 행렬을 두 개의 행렬 Q(직교 행렬)와 R (상삼각 행렬)로 분해하는 방법

 

QR 분해의 목적

 

• 선형 시스템의 해를 구하는 데 사용
• 고유값 문제(eigenvalue problem)를 푸는 데 사용
• 최소 제곱 문제(least squares problem) 해결

결과 설명

 

• mat: 주어진 대칭 행렬 X^T X
• inv(mat): 주어진 행렬의 역행렬
• mat.dot(inv(mat)): 주어진 행렬과 그 역행렬의 곱. 이론적으로는 단위 행렬(identity matrix)이 되어야 하지만, 수치적 오차로 인해 완벽한 단위 행렬이 아닐 수 있다.
• r: QR 분해의 결과로 나온 상삼각 행렬 R

 

 

from numpy.linalg import inv, qr

X = np.random.randn(5, 5)

mat = X.T.dot(X)

inv(mat)

mat.dot(inv(mat))

q, r = qr(mat)

r

 

array([[-5.87415396,  2.81969888,  2.1718891 ,  0.67037583, -2.88674796],
       [ 0.        , -3.25633792,  0.23949067,  0.84809582,  0.63937392],
       [ 0.        ,  0.        , -0.98747836, -0.879367  ,  1.674039  ],
       [ 0.        ,  0.        ,  0.        , -0.61654179,  0.89420226],
       [ 0.        ,  0.        ,  0.        ,  0.        ,  0.00655302]])

 

2-7. 난수 생성

기존의 랜덤은 표준정규분포를 기반으로 데이터가 작성되는데 그중 normal분포를 이용해라는 것이다.

정규분포는 중심이 평균(mean)이고, 폭이 표준편차(standard deviation)인 종 모양의 분포

samples = np.random.normal(size=(4, 4))

samples

array([[ 0.00496828, -0.48327476,  0.20832977, -0.87050454],
       [ 1.0531076 ,  0.5248491 ,  0.81973167, -0.09020017],
       [ 2.57686253, -1.56645094,  0.13767585, -1.24449263],
       [-0.77756683,  0.15141695,  0.38842109,  1.50400856]])

 

from random import normalvariate

N = 10000

%timeit samples = [normalvariate(0, 1) for _ in range(N)]

%timeit np.random.normal(size=N)

The slowest run took 4.59 times longer than the fastest. This could mean that an intermediate result is being cached.
17.8 ms ± 8.4 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
432 µs ± 100 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

np.random.seed(1234)

rng = np.random.RandomState(1234)

rng.randn(10)

array([ 0.47143516, -1.19097569,  1.43270697, -0.3126519 , -0.72058873,
        0.88716294,  0.85958841, -0.6365235 ,  0.01569637, -2.24268495])