#모듈선언
import numpy as np

#3차원 배열 선언
test1 = np.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]]])

#데이터확인
test1

#데이터 길이, 차원, 갯수(크기)확인
print(test1.shape)
print(test1.ndim)
print(test1.size)

test1.reshape(9,3)

#3차원의 배열을 1차원으로 재배치
test1.reshape(27,)

#3차원의 배열을 2차원으로 재배치
test1.reshape(3,9)

#3차원의 배열을 재배치
test1.reshape(3,1,9)

#3차원의 배열을 1차원으로 재배치
test1.flatten()

#필요한 모듈 세팅
import tensorflow as tf
import numpy as np
#텐서플로우 버전 확인
print(tf.__version__)

for i in range(10):
    a = tf.Variable(tf.random.uniform((1,), -1.0, 1.0))
    b = tf.Variable(tf.random.uniform((1,), -1.0, 1.0))
    print(a.numpy(),b.numpy())

for i in range(10):
    tf.random.set_seed(0)
    a = tf.Variable(tf.random.uniform((1,), -1.0, 1.0))
    b = tf.Variable(tf.random.uniform((1,), -1.0, 1.0))
    print(a.numpy(),b.numpy())

# tf.random.set.seed()는 변수, 여기선 W1,W2값을 고정해 주는 역활을 합니다.
# 해당 코드를 몇번을 반복해도 같은 값을 돌려주게 됩니다.
tf.random.set_seed(0)

#변수 x1, x3 선언
x1_data = [5.,0.,3.,4.,5.]
x2_data = [4.,3.,1.,2.,0.]
#정답인 y값 선언
y_data  = [1.,2.,3.,4.,5.]

#변수가 2개이기 때문에 W(가중치, 기울기)도 2개를 선언해 줍니다.
#tf.random.uniform 균등분포를 따르는 난수를 생성해줍니다, -10~10사이의수
W1 = tf.Variable(tf.random.uniform((1,), -10.0, 10.0))
W2 = tf.Variable(tf.random.uniform((1,), -10.0, 10.0))
b = tf.Variable(tf.random.uniform((1,), -10, 10.0))

learning_rate=tf.Variable(0.001)

#단순 선형회귀에서 사용한 경사하강법과 동일합니다.
for i in range(1000+1):
    #tape에 모든 with연산기록 저장
    with tf.GradientTape() as tape:
        #hypothesis(추론,공식)을 전해줍니다.
        hypothesis = W1 * x1_data + W2* x2_data+b
        cost = tf.reduce_mean(tf.square(hypothesis - y_data))
    W1_grad, W2_grad, b_grad = tape.gradient(cost, [W1,W2, b])
    W1.assign_sub(learning_rate * W1_grad)
    W2.assign_sub(learning_rate * W2_grad)
    b.assign_sub(learning_rate * b_grad)
    
    if i % 50 ==0:
        print("{:5} | {:10.6f} | {:10.4f} | {:10.4f} | {:10.6f}".format(
          i, cost.numpy(), W1.numpy()[0], W2.numpy()[0], b.numpy()[0]))

#이번엔 같은 예제를 메트릭스를 활용하여 도출하겠습니다.
#메트릭스를 사용하지 않았을때(위예시)와 비교하면서 확인해야합니다.

#x와, y데이터를 따로따로 주었습니다.
x_data = [
    [5.,0.,3.,4.,5.],
    [4.,3.,1.,2.,0.]
]

y_data = [1.,2.,3.,4.,5.]
tf.random.set_seed(0)


W = tf.Variable(tf.random.uniform((1,2), -10.0, 10.0))
b = tf.Variable(tf.random.uniform((1,), -10.0, 10.0))

learning_rate = tf.Variable(0.001)

for i in range(1000+1):
    with tf.GradientTape() as tape:
        hypothesis = tf.matmul(W, x_data) + b 
        cost = tf.reduce_mean(tf.square(hypothesis - y_data))

        W_grad, b_grad = tape.gradient(cost, [W, b])
        W.assign_sub(learning_rate * W_grad)
        b.assign_sub(learning_rate * b_grad)
    if i % 50 ==0:
        print("{:5} | {:10.6f} | {:10.4f} | {:10.4f} | {:10.6f}".format(
            i, cost.numpy(), W.numpy()[0][0], W.numpy()[0][1], b.numpy()[0]))
        

#값 고정 역활
tf.random.set_seed(0)


# 데이터 세팅
x1 = [ 60.,  91.,  78.,  64.,  74.]
x2 = [ 70.,  87.,  60.,  80.,  67.]
x3 = [ 73.,  92.,  93., 99.,  71.]
Y  = [130., 170., 160., 170., 150.]

# 변수만큼 w갯수 세팅
w1 = tf.Variable(tf.random.normal((1,)))
w2 = tf.Variable(tf.random.normal((1,)))
w3 = tf.Variable(tf.random.normal((1,)))
b  = tf.Variable(tf.random.normal((1,)))


learning_rate = 0.000001
print("epoch | cost")
#경사하강법
for i in range(1000+1):
    with tf.GradientTape() as tape:
        hypothesis = w1* x1 + w2*x2 + w3*x3 + b
        cost =tf.reduce_mean(tf.square(hypothesis -Y))
        
    w1_grad, w2_grad, w3_grad, b_grad = tape.gradient(cost, [w1,w2,w3,b])
    
    w1.assign_sub(learning_rate * w1_grad)
    w2.assign_sub(learning_rate * w2_grad)
    w3.assign_sub(learning_rate * w3_grad)
    b.assign_sub(learning_rate * b_grad)
    
    if i % 500 == 0:
        print("{:5} | {:12.4f}".format(i, cost.numpy()))

#np배열로 x와 y 선언
data = np.array([
    # X1,   X2,    X3,   y
    [ 60.,  70.,  73., 130. ],
    [ 91.,  87.,  92., 170. ],
    [ 78.,  60.,  93., 160. ],
    [ 64.,  80., 99., 170. ],
    [ 74.,  67.,  71., 150. ]
], dtype=np.float32)

# 슬라이스로, 엑스와, y를 명확히 선언및 대입
X = data[:, :-1]
y = data[:, [-1]]

#x의 변수가 3개인것을 주의
W = tf.Variable(tf.random.normal((3, 1)))
b = tf.Variable(tf.random.normal((1,)))

learning_rate = 0.000001

# hypothesis, prediction function
def predict(X):
    return tf.matmul(X, W) + b

print("epoch | cost")

n_epochs = 1000
for i in range(n_epochs+1):
    # tf.GradientTape() to record the gradient of the cost function
    with tf.GradientTape() as tape:
        cost = tf.reduce_mean((tf.square(predict(X) - y)))

    # calculates the gradients of the loss
    W_grad, b_grad = tape.gradient(cost, [W, b])

    # updates parameters (W and b)
    W.assign_sub(learning_rate * W_grad)
    b.assign_sub(learning_rate * b_grad)

    if i % 50 ==0:
        print("{:5} | {:10.6f} | {:10.4f} | {:10.4f} | {:10.6f}".format(
            i, cost.numpy(), W.numpy()[0][0], W.numpy()[1][0], b.numpy()[0]))
        

#y값 확인
y

#X값 확인
X

#b값 확인
b

#predict공식을 통한 해 도출
predict(X).numpy()

#x1,x2,x3값 할당한 후 예측값
predict([[ 1.,  1.,  4.]]).numpy()

#2개의 해 동시 도출
predict([[ 1.,  1.,  4.],[ 145.,  50.,  50.]]).numpy()

#3개의 해 동시 도출
#특히 마지막 배열은 최초 선언시 주었던 x값임
predict([[ 1.,  1.,  4.],[ 145.,  50.,  50.],[ 74.,  67.,  71.]]).numpy()

#필요한 모듈 세팅
from pandas import Series

#리스트 선언
listTest = [10,20,30,40,50]
listTest

#시리즈가공
SeriesTest = Series(listTest)
SeriesTest

#인덱스를 활용하여 값 확인
print(SeriesTest[0])
print(SeriesTest[1])
print(SeriesTest[2])

#시리즈의 값 추출
a = SeriesTest.values
a

#시리즈의 값을 리스트로 변환하기
b = list(a)
b

#시리즈에서 값을 추출하여 리스트로 만들기
list(SeriesTest.values)

#시리즈의 인덱스만 추출하기
i = SeriesTest.index
i

#시리즈의 인덱스를 리스트로 변환하기
list(SeriesTest.index)

IndexTest1 = Series([300, 200])
IndexTest2 = Series([300, 200], index=['커피', '콜라'])
print(IndexTest1)
print(IndexTest2)

#일반 크기 비교
test1 = SeriesTest[SeriesTest > 30]
test1

# and
test2 = SeriesTest[SeriesTest<= 40][SeriesTest >=30]
test2

#or
test3 = SeriesTest[(SeriesTest<=10) | (SeriesTest >=40)]
test3

#시작에 앞서 np 선언
import numpy as np

test = np.array([[111,222,333],[555,666,777]])
print(test,'\n')#2행 3열 메트릭스 배열 
print(test[0],'\n')# 0번째 행 
print(test[0,0],'\n')#0번째 행 0번째 인덱스 요소
print(test[0][0],'\n')#0번째 행 0번째 인덱스 요소

test = np.array([[111,222,333],[555,666,777],[123,633,768]])
print(test[:],'\n')#모두 출력
print(test[1:],'\n')#인덱스1행 부터 출력
print(test[:-1],'\n')#맨뒤를 제외하고 모든 인덱스행 출력
print(test[1,1:3],'\n')#인덱스1행에서 1,2인덱스 요소 출력
print(test[1,0:3],'\n')#인덱스1행에서 0,1,2인덱스 요소 출력
print(test[1,::2],'\n')#인덱스 1행에서 한칸씩 뛰고 인덱스 출력

test1 = np.zeros((3,4))
test2 = np.zeros(shape=(3,4))
print(test1,'\n')
print(test2)

test1 = np.ones((3,4))
test2 = np.ones(shape=(3,4))
print(test1,'\n')
print(test2)

np.identity(10)

np.identity(n=4, dtype = int)

np.eye(N=4, M=5,dtype=int)

np.eye(N=4, M=5,k=3,dtype=int)

test =np.arange(12).reshape(4,3)
print(test)
print(np.diag(test))
print(np.diag(test, k=1))

np.random.uniform(0,1,10).reshape(2,5)

np.random.normal(0,1,20).reshape(4,5)

test = np.array([[[0,1,2],[3,4,5],[6,7,8],[111,222,333]],
                  [[9,10,11],[12,13,14],[15,16,17],[111,222,333]]])

test.shape

test = np.arange(1,17).reshape(4,4)
test

print(test.mean()) #모든 요소들의 평균
print(test.mean(axis = 0))#컬럼들의 평균 -> (1 + 5 + 9 + 13) / 4 = 7
print(test.mean(axis = 1))#로우의 평균 - >(1+2+3+4)/4 = 2.5

#기본 사칙 연산 가능
# + 외에 다른 사칙연산 대입하면됩니다.
test + test

#브로드캐스팅 1
# + 외에 다른 사칙연산 대입하면됩니다.
test + 3 

#브로드캐스팅 2
#위 브로드캐스팅 1에선 수 와 계산 했습니다.
#이번엔 차원 수가 다른 배열끼리의 계산입니다.
#각 행마다 1,2,3,4를 각각 요소에 맞게 더해줍니다.
test2 = np.array([1,2,3,4])
test + test2

test = np.arange(1,13).reshape(4,3)
test

test.transpose()

test.T

test.dot(test.T)

import numpy as np

test1 = np.array([0,1,2,3,4,5])#배열안의 원소값들의 데이터 형식을 지정 가능 디폴트 int
test2 = np.array([0,1,2,3,4,5,6], float)#원소값들을 플롯 형식으로지정
test3 = np.array(["0","1",2,3,4], int)#배열안에 문자값을 숫자값으로 읽어드릴 수 있다.
test4 = np.array(range(10))

print(test1)
print(test2)# 플롯 형식은 '0.', '1.' 식으로 저장됨
print(test3)# "0" ,"1"이 숫자로 저장됨
print(test4)

#ndarray 란 넘피 디맨션 어레이 = numpy dimansion array
print(type(test1))
print(type(test2))
print(type(test3))
print(type(test4))

#원소값을 직접 호출 가능하다
print(type(test1[0]))
print(type(test2[1]))
print(type(test3[2]))
print(type(test4[3]))

#배열은 다차원으로 만들 수 있다.
test1 = np.array([[0,1,2,3,4,],[5,6,7,8,9]], float)#로우와 컬럼이 존재하는 배열로 생성
print(test1)
print(type(test1))
print(type(test1[0]))
print(type(test1[0][0]))

test1 = np.array([0,1,2])#컬럼만 존재 [1차원]
test2 = np.array([[0,1,2],[3,4,5]])#컬럼과 로우가 존재[2차원] 
test3 = np.array([[0,1,2],[3,4,5],["6",7,8]])#로우한줄 추가[2차원]


#3차원 배열 선언
test4 = np.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]]])

test5 = [[[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]]]

print(test1.shape)#1차원의 경우 '(3,)' 과 같이 생성된다.
print(test2.shape)#차원이 늘어날 경우 기존 값은 오른쪽으로 밀리고, 새로운 값이 왼쪽에 생성된다.
print(test3.shape)
print(test4.shape)#(3 = 공간(테이블이 3개) , 3 =3줄(row), 3 = 3칸(column))
print(np.array(test5).shape)

#위에서 사용한 배열 참고
print(test1.ndim ," , ", test1.size)
print(test2.ndim ," , ", test2.size)
print(test3.ndim ," , ", test3.size)
print(test4.ndim ," , ", test4.size)#데이터의 수가 9개인 테이블이 3개 존재
print(np.array(test5).ndim ," , ", np.array(test5).size)# 3 *9 = 27

test1 = np.array([[0,1,2],[3,4,5],["6",7,8]])
print(test1.shape,'\n'*2)#2차원의 배열
print(test1.reshape(9,),'\n'*2)#1차원으로 변환
print(test1.reshape(3,3),'\n'*2)
print(test1.reshape(-1,3),'\n'*2)#size를 기반으로 row개수 선정
print(test1.reshape(3,1,3),'\n'*2)

test = [[[0,1]],[[2,3]],[[4,5]]]#3차원 선언
print(np.array(test),'\n'*2)

print(np.array(test).shape,'\n'*2)#3차원 shape확인

print(np.array(test).flatten(),'\n'*2)#3차원을 1차원으로 변환

print(np.array(test).flatten().shape,'\n'*2)# 확인

from collections import deque

#deque 선언하여, 0~9까지의 수를 저장해줌
deque_list = deque()
for i in range(10):
    deque_list.append(i)
print(deque_list)#일반적인 리스트 [] 와는 다른 deque([])로 생성됨
print(type(deque_list))#type은 collections.deque로 확인

deque_list.appendleft(777)#appendleft로 왼쪽에 원하는 요소 삽입가능
print(deque_list)

deque_list.append(999)#디폴트로 오른쪽에 들어감
print(deque_list)

deque_list.rotate(3)#값을 오른쪽으로 3칸 이동한다. 리스를 벗어나게 되는 오른쪽 3개의 값들은 왼쪽으로 온다.
print(deque_list)

print(deque(reversed(deque_list)))#요소의 순서를 역으로 한다.

deque_list.extend(['ㄱ',555,'A'])#요소에 값을 추가함 디폴트는 오른쪽
print(deque_list)

deque_list.extendleft(['','donut',888])#왼쪽으로 추가 가능
print(deque_list)

print(deque_list.pop())#제일 오른쪽 값을 삭제및 선택
print(deque_list)#맨 오른쪽 값이 삭제된 상태

from collections import deque
import time

시작시간 = time.time()
deque_list = deque()

for i in range(10000):
    for i in range(10000):
        deque_list.append(i)
        deque_list.pop()
print(time.time() - 시작시간, "초")

from collections import deque
import time

시작시간 = time.time()
일반리스트 = []

for i in range(10000):
    for i in range(10000):
        일반리스트.append(i)
        일반리스트.pop()
print(time.time() - 시작시간, "초")

test1 = {}
test1['x'] = 1
test1['y'] = 2
test1['z'] = 3
test1['l'] = 9

for i,v in test1.items():
    print(i,v)
print(test1)

from collections import OrderedDict

test2 = OrderedDict()
test2['x'] = 1
test2['y'] = 2
test2['z'] = 3
test2['a'] = 9

for i,v in test2.items():
    print(i,v)
print(test2)

#key값을 기준으로 정렬
for i,v in OrderedDict(sorted(test2.items(),key =lambda x: x[0])).items():
    print(i,v)

#value값을 기준으로 정렬
for i,v in OrderedDict(sorted(test2.items(),key =lambda x: x[1])).items():
    print(i,v)

from collections import defaultdict
d= defaultdict()
d = defaultdict(lambda: 2) #디폴트값 2 설정
print(d["first"])

text = "아침 점심 저녁으로 라면을 밥으로 먹자 아침에 일찍 일어나서 밥을 먹자 점심엔 밥을 안먹고 치킨을 먹자".split()
print(text)

from collections import OrderedDict
word_count = defaultdict(object)
#디폴트 값을 10으로 지정했기 때문에 모든 요소가 10부터 카운트가 된다.
word_count = defaultdict(lambda : 10)
for word in text:
    word_count[word] +=1
for i, v in OrderedDict(sorted(word_count.items(),key=lambda t: t[1],reverse =True)).items():
    print(i,v)

from collections import Counter

test1 = Counter()
test1 = Counter('배고프다')

print(test1)

test1 = Counter('Hellow')
print(test1)

#다음과 같이 dict선언을 통해 리스트를 생성하는것 또한 가능하다.
test2 = Counter({'aaa' : 5, 'bbb' : 2})
print(test2)
print(list(test2.elements()))

#연산기능도 제공한다.
#0과 음수는 표현하지 않는듯 하다.
test3 = Counter(a=4, b=20, c=3, d=101)
test4 = Counter(a=10, b=20, c=30, d=100)
print(test3 + test4)
print(test3 - test4)
print(test4 - test3)
print(test3 & test4)
print(test3 | test4)

from collections import namedtuple
test = namedtuple('test', ['x','y'])
t = test(11,y=22)
print(t[0] + t[1])

x,y = t
print(x,y)
print(t.x + t.y)
print(test(x=11,y=22))

test_list = ['one', 'two', 'three','four','five']
for i in test_list:
    print(i)

for i,v in enumerate(test_list):
    print(i,v)

list(enumerate(test_list))

#문자열을 빈칸으로 스플릿 한 후, enumerate로 인덱스와함께 dict형태로 보내기
{i:j for i,j in enumerate('동해물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라 만세'.split())}

#문자열을 '이'로 스플릿 한 후, enumerate로 인덱스와함께 dict형태로 보내기
{i:j for i,j in enumerate('동해물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라 만세'.split('이'))}

test_list1 = ['1','2','3','4','5']
test_list2 = ['가','나','다','라','마']

for i,v in zip(test_list1,test_list2):
    print(i,v)
#리스트 두개를 합칠 수 있습니다.

test_list1 = ['1','2','3','4','5']
test_list2 = ['가','나','다','라','마']
test_list3 = ['!','@','#','$','%']

for i,v,c in zip(test_list1,test_list2,test_list3):
    print(i,v,c)
#리스트 3개도 역시 합칠 수 있습니다.

#앞서 사용한 리스트를 활용하여 unpacking하기
a,b,c,d,e = zip(test_list1,test_list2)
print(a)
print(b)
print(c)
print(d)
print(e)

#앞서 사용한 리스트를 활용하여 unpacking하기
a,b,c,d,e = zip(test_list1,test_list2,test_list3)
print(a)
print(b)
print(c)
print(d)
print(e)

#컴프리헨션으로 각 튜플 요소들의 합을 구함
[sum(i) for i in zip((1,2,3),(10,20,30),(100,200,300))]

test_list1 = ['1','2','3','4','5']
test_list2 = ['가','나','다','라','마']

for i, (a,b) in enumerate(zip(test_list1,test_list2)):
    print(i,a,b)

test_list1 = ['1','2','3','4','5']
test_list2 = ['가','나','다','라','마']
v = a,b
for i, v in enumerate(zip(test_list1,test_list2)):
    print(i,v)