설명문 처리

워크시트의 명령을 전달하여 실행 : [CTRL]+[ENTER] 또는 [F5]

[CTRL]+[ENTER] : 커서 위치의 SQL 명령을 전달하여 실행

[F5] : 워크시트의 모든 SQL 명령을 전달하여 실행

범위를 지정하여 [CTRL]+[ENTER] 또는 [F5]를 입력할 경우 범위의 명령만 전달하여 실행 가능

SQL 명령은 대소문자를 구분하지 않으며 하나의 SQL 명령을 구분하기 위해 ;(세미콜론) 사용

테이블(TABLE)

• 데이타베이스에서 정보를 저장하기 위한 기본 객체
• 현재 접속 사용자의 스키마에 존재하는 테이블 목록 확인

SELECT TABLE_NAME FROM TABS;
SELECT * FROM TAB;

테이블의 구조 확인

• 테이블 속성 정보(컬럼명과 자료형)
• 형식) DESC 테이블명

EMP 테이블 : 사원정보를 저장하기 위한 테이블

DEPT 테이블 : 부서정보를 저장하기 위한 테이블

DESC EMP;
DESC DEPT;

DQL(DATA QUERY LANGUAGE)

• 데이타 질의어
• SELECT : 하나 이상의 테이블에서 행을 검색하기 위한 명령
• 형식) SELECT 검색대상,검색대상,... FROM 테이블명, 테이블명,...
• 검색대상 : * (모든 컬럼) - 다른 검색대상과 동시 사용 불가, 컬럼명, 연산식, 함수 등

SELECT * FROM EMP;
SELECT EMPNO, ENAME, SAL, DEPTNO FROM EMP;

COLUMN ALIAS : 검색대상에 별칭(임시 컬럼명)을 부여하는 기능

• 형식) SELECT 검색대상 [AS] 별칭, 검색대상 [AS] 별칭 FROM 테이블명,...
• 검색대상을 명확하게 표현하기 위해 별칭 사용
• AS 생략 가능

SELECT EMPNO AS NO, ENAME AS NAME, DEPTNO AS DNO FROM EMP;
SELECT EMPNO 사원번호, ENAME 사원이름, DEPTNO 부서코드 FROM EMP;

컬럼 별칭으로 공백 또는 특수문자를 사용하고자 할 경우 " " 기호를 사용하여 표현

SELECT EMPNO "사원 번호", ENAME 사원이름, SAL*12 연봉 FROM EMP;

식별자(테이블명, 컬럼명, 컬럼 별칭 등)는 단어와 단어를 _로 구분하여 표현

SELECT EMPNO, ENAME, SAL*12 ANNUAL_SALARY FROM EMP;

|| : 결합 연산자

• 검색대상의 결과값 결합
• 문자형 상수는 ' ' 기호를 이용하여 표현

SELECT ENAME || JOB FROM EMP;
SELECT ENAME || '님의 업무는' ||JOB|| '입니다.' FROM EMP;

EMP 테이블에 저장된 모든 사원의 업무 검색 (중복된 컬럼값 검색)

SELECT JOB FROM EMP;

DISTINCT : 검색대상의 중복값을 제외하고 유일한 하나의 결과값만 검색하는 기능 제공

형식) SELECT [DISTINCT] 검색대상[, 검색대상, ...] FROM 테이블명,...

SELECT DISTINCT JOB FROM EMP;

DISTINCT 키워드에 검색대상을 여러 개 나열 가능

SELECT DISTINCT JOB, DEPTNO FROM EMP;

WHERE : 조건식을 사용하여 조건이 참인 행을 검색하는 기능 제공

형식) SELECT 검색대상,... FROM 테이블명,... WHERE 조건식

EMP 테이블에서 사원번호가 7698인 사원의 사원번호, 사원이름, 업무, 급여 검색

단일행을 검색하고자 할 경우 조건식에 PK 제약조건이 부여된 컬럼을 이용하여 검색

SELECT EMPNO, ENAME, JOB, SAL FROM EMP WHERE EMPNO=7698;

EMP 테이블에서 사원이름이 KING인 사원의 사원번호, 사원이름, 업무, 급여 검색

문자형 상수는 ' ' 기호를 이용하여 표현

문자형 상수는 대소문자를 구분하여 비교

SELECT EMPNO, ENAME, JOB, SAL FROM EMP WHERE ENAME='KING';

EMP 테이블에서 입사일이 1981년 6월 9일인 사원의 사원번호, 사원이름, 업무, 급여, 입사일 검색

날짜형 상수는 ' ' 기호에 RR/MM/DD 형식의 패턴으로 표현 - 검색결과는 RR/MM/DD 표현

SELECT EMPNO, ENAME, JOB, SAL, HIREDATE FROM EMP WHERE HIREDATE='81/06/09';

EMP 테이블에서 업무가 SALESMAN이 아닌 사원의 사원번호, 사원이름, 업무, 급여 검색

SELECT EMPNO, ENAME, JOB, SAL FROM EMP WHERE JOB != 'SALESMAN'; 
SELECT EMPNO, ENAME, JOB, SAL FROM EMP WHERE JOB <> 'SALESMAN';

EMP 테이블에서 사원이름이 A, B, C로 시작되는 사원의 사원번호, 사원이름, 업무, 급여 검색

SELECT EMPNO, ENAME, JOB, SAL FROM EMP WHERE ENAME < 'D';

이중 검색 - WHERE 조건 AND 조건

EMP 테이블에서 업무가 SALESMAN인 사원 중 급여가 1500 이상인 사원의 모든 정보 검색

SELECT * FROM EMP WHERE JOB = 'SALESMAN' AND SAL >= 1500;

WHERE 조건 OR 조건

EMP 테이블에서 부서번호가 10이거나 업무가 MANAGER인 사원의 사원번호, 사원이름, 업무, 급여, 부서번호 검색 

SELECT EMPNO, ENAME, JOB, SAL, DEPTNO FROM EMP WHERE DEPTNO=10 OR JOB='MANAGER';

범위연산자를 이용하여 컬럼값이 작은값부터 큰값 범위에 포함될 경우의 조건식 구현

형식) 컬럼명 BETWEEN 작은값 AND 큰값

SELECT * FROM EMP WHERE SAL BETWEEN 1500 AND 3000;

선택연산자를 이용하여 컬럼값이 여러 개중 하나인 경우의 조건식 구현

형식) 컬럼명 IN(값,값,...)

SELECT * FROM EMP WHERE JOB IN('ANALYST' , 'SALESMAN');

EMP 테이블에서 사원이름이 A로 시작되는 사원의 모든 정보 검색

SELECT * FROM EMP WHERE ENAME>='A' AND ENAME<'B'; 
SELECT * FROM EMP WHERE (ENAME BETWEEN 'A' AND 'B') AND ENAME<>'B';

검색패턴기호 : 부정확한 값을 검색하기 위해 제공하는 기호

• %(전체) 또는 _(문자)
• 값이 비교하기 위해 = 연산자를 사용할 경우 % 또는 _를 문자로 인식하여 비교

SELECT * FROM EMP WHERE ENAME = 'A%';

패턴연산자를 이용하여 검색패턴기호로 조건식 구현

형식) 컬럼명 LIKE '값 또는 검색패턴기호'

SELECT * FROM EMP WHERE ENAME LIKE 'A%';

EMP 테이블에서 이름에 A가 포함된 사원의 모든 정보 검색

SELECT * FROM EMP WHERE ENAME LIKE '%A%';

EMP 테이블에서 이름 두번째 문자가 L인 사원의 모든 정보 검색

SELECT * FROM EMP WHERE ENAME LIKE '_L%';

※ 주의 - LIKE 연산자는 % 또는 _를 검색패턴기호로 인식하여 검색

ESCAPE 키워드를 이용하여 ESCAPE 문자를 표현하기 위한 기호 설정

% 또는 _를 검색패턴기호가 아닌 ESCAPE 문자로 인식되도록 설정

SELECT * FROM EMP WHERE ENAME LIKE '%\_%' ESCAPE '\';

컬럼값 대신 NULL로 표현된 경우 존재하는 값이 아니므로 연산식 미실행

IS 연산자를 이용하여 NULL 비교

형식) 컬럼명 IS NULL 또는 컬럼명 IS NOT NULL

SELECT * FROM EMP WHERE COMM IS NULL;

ORDER BY

• 컬럼값을 비교하여 행이 정렬되도록 검색하는 기능 제공
• 형식) SELECT 검색대상, ... FROM 테이블명, ... [WHERE 조건식] ORDER BY {컬럼명 | 연산식 | 별칭 | INDEX} {ASC | DESC}, {컬럼명 | 연산식 | 별칭 | INDEX} {ASC | DESC}, ...
• ASC : 오름차순 정렬, DESC : 내림차순 정렬
• 첫번째 정렬값이 동일한 경우 두번째 값으로 정렬
• ASC는 생략 가능 (기본값)

SELECT EMPNO,ENAME,JOB,SAL,DEPTNO FROM EMP ORDER BY SAL DESC;

검색대상에는 자동으로 첨자(COLUMN INDEX)가 부여

오라클에서는 첨자가 1부터 1씩 증가되는 값으로 표현

SELECT EMPNO, ENAME, SAL*12 ANNUAL FROM EMP ORDER BY 3 DESC;

EMP 테이블에서 모든 사원의 사원번호, 사원이름, 업무, 급여, 부서번호를 부서번호로 오름차순 정렬하고 같은 부서번호인 경우 급여로 내림차순 정렬하여 검색

SELECT EMPNO, ENAME, JOB, SAL, DEPTNO FROM EMP ORDER BY DEPTNO, SAL DESC;

DataBase란?

• 필요한 데이터의 중복을 취소화하고 구조화하여 검색과 갱신을 효율적으로 할 수 있도록 모아놓은 데이터들의 집합구조 (Data Structure)

데이터베이스 관리 시스템(Database Management System)

• 대용량의 데이터를 편리하게 저장하고 효율적으로 관리, 검색, 수정, 삭제(CRUD)할 수 있는 환경을 제공해 주는 소프트웨어를 데이터베이 스 관리 시스템(DBMS)이라고 한다.
• 데이터를 공유하여 정보의 체계적인 활용이 가능
• 응용프로그램과 데이터베이스의 중재자로서 모든 응용 프로그램들이 데이터베이스를 공용할 수 있게끔 관리해 준다

퍼셉트론(Perceptron)

• 퍼셉트론은 초기 형태의 인공 신경망으로, 다수 입력으로부터 하나의 결과를 내보내는 알고리즘
• 뉴런을 흉내내어 만든 구조

→ 이런 수식을 보여주는데 , 여기서 i가 한개밖에 없으면 결국 선형회귀랑 똑같음 !!

• 인공신경망은 퍼셉트론을 여러층 쌓고 이렇게 만듬
• 결국 선형회귀랑 로지스틱회귀를 여러개 겹쳐서 사용하면 인공신경망에 쓰는 딥러닝이 되는 구조

그래서 선형회귀랑 로지스틱 회귀를 잘 이해하고 넘어가야 함
거의 선형회귀랑 로지스틱회귀가 딥러닝의 밑거름

XOR 문제

→ AND 나 OR 같은 경우 선을 하나만 그으면 분류가 가능함 (선형회귀, 로지스틱 회귀)

→ XOR 는 선 하나만 가지고 분류가 불가능함

왜 인공지능에 딥러닝이 나왔는가 ?? (XOR 문제)

• 하나의 퍼셉트론은 선형으로만 분리할 수 있어, XOR은 풀 수 없음
• 퍼셉트론을 여러 층으로 쌓으면 곡선으로도 분리할 수 있음,, 그래서 딥러닝이 등장함!
  → 다층 퍼셉트론 (MultiLayer Perceptron, MLP) - 딥러닝의 제일 시초
• 다층 퍼셉트론처럼 은닉층이 2개 이상인 경우, 심층 신경망 (Deep Neural Network, DNN)이라고 부름

XOR 문제 실습 1

• 단순 로지스틱 회귀 → XOR 문제를 해결할 수 없음

import numpy as np
import tensorflow as tf

• Input 정의
  • 00 → 0 , 01 → 1 , 10 → 1 , 11 → 0

input = np.array([[0,0], [0,1], [1,0], [1,1]]).astype(np.float)
output = np.array([[0], [1], [1], [0]]).astype(np.float)

• tensorflow 를 활용해서 모델 생성
  • Input 데이터가 두개가 들어오면 거기에 대해서 Dense 라는 Layer를 추가
  • → 퍼셉트론이라고 생각하면 됨
  • → sigmoid 함수를 썼는데 1층만 있으면 결국 Logistic regression이랑 똑같음

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=2, dtype='float32'), # Input 정의
    tf.keras.layers.Dense(1, activation='sigmoid') # 실질적인 층
])

model.summary() # param:3 -> W:2, b:1

→ parameter 수가 3개라고 나옴,, Input 에서 두개가 들어오기때문에 두개에 대한 각각의 W가 생성이 되고 W 두개에 b가 한개 !!

• 로지스틱 회귀랑 선형회귀에서 계속 학습할 때 썼던 GD를 SGD이라고 생각하면 됨
  • SGD는 Gradient Descent 위에 momentum이라고 생각하면 됨

optimizer = tf.keras.optimizers.SGD(lr=0.01, decay=0, momentum=0.99, nesterov=True)
model.compile(optimizer=optimizer, loss='mse', metrics=['accuracy']) 

# 학습 fit() 함수 호출
model.fit(input, output, epochs=10)

→ 파라미터 3개에 대해서 10번 학습하는데 계속 정확도가 50밖에 안나옴

→ XOR 문제를 풀 수가 없어서 50밖에 안나옴

아무리 학습을 해도 50점밖에 안되는 구조가 있어서 그런 부분을 수학적으로 풀어주기 위해서 층을 더 쌓으면 풀 수 있다 !!

XOR 문제 실습 2

• 다층 퍼셉트론 → XOR 문제 해결 가능

import numpy as np
import tensorflow as tf

input = np.array([[0,0], [0,1], [1, 0], [1,1]]).astype(np.float)
output = np.array([[1,0], [0, 1], [0, 1], [1, 0]]).astype(np.float)

• 모델 생성

model = tf.keras.Sequential([
                             tf.keras.layers.Input(shape=2, dtype='float32'),
                             tf.keras.layers.Dense(4, activation='relu'),
                             tf.keras.layers.Dense(4, activation='relu'),
                             tf.keras.layers.Dense(2, activation='softmax')
                             ])
                             
model.summary()

• binary_crossentropy

optimizer = tf.keras.optimizers.SGD(lr=0.01, decay=0, momentum=0.99, nesterov=True)
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])

• 학습

model.fit(input, output, epochs=30)

→ 30번쯤 돌리니 정확도가 1점이 나옴 !! 드디어 !!!

XOR-1 에서는 모델에서 층을 하나만 줬음
XOR-2 에서는 모델에서 층을 3개를 쓰고, loss function도 binary_crossentropy 으로 바꿔줌
→ cross entropy가 분류에서 많이 씀
→ 멀티 Layer로 모델을 바꿔주고 학습을 하니깐 성능이 좋아짐
→ 이런식의 문제를 풀기 위해서 처음에는 단층을 썼었는데 XOR 문제도 당장 못풀기때문에 그부분을 해결하기 위해 다층 퍼셉트론으로 바꾸면서 DNN이 등장함 !!

SVM(Support Vector Machine)

• 머신러닝에서는 딥러닝이 활발해지기 전까지 제일 많이 활용됨

→ 흰색원 , 검은색원을 분류를 할 수 있는 기준을 찾는 것

• logistic regression은 함수의 fitting을 하면서 찾았고 SVM은 각 데이터들 사이에 선을 그을때 마진 (선이랑 가까운 데이터들의 거리) 을 최대한으로 그려주는 선을 찾는다.

SVM 실습

https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html?highlight=svc#sklearn.svm.SVC 
→ 파라미터 찾는 사이트
★ tensorflow가 딥러닝에 특화되어 있다면, scikit-learn은 기존의 머신러닝 알고리즘에 사용 가능하고 기초적인 딥러닝까지 가능한 라이브러리임 !

import numpy as np
import matplotlib.pyplot as plt

# scikit learn 알고리즘 - machine learning 
from sklearn.datasets.samples_generator import make_blobs
from sklearn.svm import SVC

• 임의의 데이터 생성 → 두개의 센터로 만들어서 50개 데이터를 만들어줌

X, y = make_blobs(n_samples=50, centers=2, random_state=0, cluster_std=0.60)
plt.scatter(X[:,0], X[:, 1], c=y, s=50, cmap='autumn')

• 임의의 데이터를 분류할 수 있는 선 생성

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:,0], X[:,1], c=y, s=50, cmap='autumn')

for m,b in [(1,0.65), (0.5, 1.6), (-0.2, 2.9)]:
  plt.plot(xfit, m*xfit+b, '-k')

plt.xlim(-1, 3.5);

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:,0], X[:,1], c=y, s=50, cmap='autumn')

for m,b in [(1,0.65), (0.5, 1.6), (-0.2, 2.9)]:
  plt.plot(xfit, m*xfit+b, '-k')

plt.xlim(-1, 3.5);

plt.plot([0.6], [2.1], 'x', color='blue', markeredgewidth=2, markersize=10)
plt.plot([3.0], [3.2], 'x', color='blue', markeredgewidth=2, markersize=10)

→ 선을 세개로 그을 수 있는데 임의의 데이터(X)가 들어왔을 때, 첫번째 선과 두번째 선이랑 분류결과가 다르게 나올 수 있기때문에 최적의 평균을 찾기 위해서 SVM을 돌린다.

• 모델 선언
  • scikit-learn의 SVC 사용
  • kernel = 'linear' → 직선
  • model.fit( ) 함수를 호출하면 학습이 완료됨

model = SVC(kernel='linear', C=1E10) # Support Vector Classifier
model.fit(X, y)

• 그림 그리기

def plot_svc_decision_function(model, ax=None, plot_support=True):
    """Plot the decision function for a 2D SVC"""
    if ax is None:
        ax = plt.gca()
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()
    
    # create grid to evaluate model
    x = np.linspace(xlim[0], xlim[1], 30)
    y = np.linspace(ylim[0], ylim[1], 30)
    Y, X = np.meshgrid(y, x)
    xy = np.vstack([X.ravel(), Y.ravel()]).T
    P = model.decision_function(xy).reshape(X.shape)
    
    # plot decision boundary and margins
    ax.contour(X, Y, P, colors='k',
               levels=[-1, 0, 1], alpha=0.5,
               linestyles=['--', '-', '--'])
    
    # plot support vectors
    if plot_support:
        ax.scatter(model.support_vectors_[:, 0],
                   model.support_vectors_[:, 1],
                   s=300, linewidth=1, facecolors='none');
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(model);

→ SVM을 학습하는 도구가 가장 가까운 데이터들에서 마진을 최대로 잡을 수 있는 선을 찾는다.

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plt.plot([0.6], [2.1], 'x', color='blue', markeredgewidth=2, markersize=10)
plot_svc_decision_function(model);

→ 아까 넣었던 임의의 데이터를 넣으면 선을 기준으로 노란색 원들과 더 가깝기 때문에 노란색으로 분류가 된다.

K-means clustering

• 머신러닝에서 비지도 학습의 대표적인 방법
• 위에서 배웠던 Linear, Logistic regression , SVM은 다 X에 따라서 y의 값이 있었고 어떤게 분류인지 이런 값이 있다던지, 선형회귀는 입력값에 대한 y값이 존재했는데 K-means clustering은 label이 없이 진행됨
• Original data 가 아무색도 없어서 몇개로 묶을 것인지 지정이 가능함 (K값 = 2)
  1. K값을 정하면 점이 K값만큼 생성된다.
  2. 모든 데이터에서 이 점들이랑 거리를 어떤게 더 가까운지 판별을 하고 가까운거에 대해서 cluster를 묶어준다.
  3. cluster로 묶어주고 cluster 내에 있는 점들을 활용해서 Centroid - 중심점을 옮겨주고 중심점이 옮겨진 후 한번 더 전체 데이터에 대해서 중심점에 대해서 어떤게 더 가까운지 다시 분류한다 !!!!!!
  4. 다시 묶은 다음 cluster를 옮기고 다시 또 !! 전체 데이터에서 분류를 한다,,
  → 이런 과정을 반복

실사용 예시 )

쇼핑몰에서 티셔츠 사이즈를 사람들의 키와 몸무게에 대한 데이터를 가지고 클러스터를 만든다.

→ 사이즈 추천

SVM 같은 경우에는 실제로 분류를 해야되는 경우에서 활용이 되는데, K-means clustering 은 분류없이 오리지널 데이터에서 클러스터링을 하고 클러스터를 나눔

K-means clustering 구현

1. 주어진 기본 코드를 이용하여 데이터 생성
2. K 값은 2 (랜덤한 좌표를 갖는 두 점을 생성)
3. 수식을 이용하여 모든 데이터와 Ki 값 사이의 거리를 계산
4. 데이터가 K1에 가까우면 K1으로 분류, 데이터가 K2에 가까우면 K2로 분류
5. 분류된 값들의 x, y 좌표 평균값을 구함
6. centroid 업데이트
7. 3~6번 (epochs)과정을 여러번 반봅
8. 결과 출력

K-means clustering 실습

• Import Libraries

import numpy as np
import matplotlib.pyplot as plt
import random
# Use matplotlib in notebook output
%matplotlib inline

• 데이터 정의
  • 먼저 알고리즘을 테스트 할 데이터를 정의합니다. 이 노트북에서 사용하고있는 데이터는 가짜 데이터이지만 이해하기 위해 축구 경기의 선수 통계라고 생각해 봅시다.

# Data - [average passes, average goals (player goals - opponent goals)]
X = [[100,5], [90,5], [110,5], [97,4], [102,4], [112,4], [92,4], [95,3], [90,3], [100,3],
     [110,5], [100,5], [110,4], [93,3], [107,2], [117,3], [96,2], [105,3], [100,3], [110,3],
     [60,-1], [70,-1],[40,1], [70,-3], [50,-1], [80,0],[50,0],[60,-1],[60,1],[55,0],
     [40,-1], [45,-1],[40,0], [55,-3], [60,-1], [65,0],[70,0],[51,-2],[51,1],[48,0]]

• 2D 그래프에 데이터 플로팅

plotx = []
ploty = []
for i in range(len(X)):
    plotx.append(X[i][0])
    ploty.append(X[i][1])
    # print(plotx, ploty)
plt.plot(plotx,ploty, 'bo')

def random_centers(dim,k):
    centers = []
    for i in range(k):
        center = []
        for d in range(dim):
            rand = random.randint(0,100)
            center.append(rand)
        centers.append(center)
    return centers

def point_clustering(data, centers, dims, first_cluster=False):
    for point in data:
        nearest_center = 0
        nearest_center_dist = None
        for i in range(0, len(centers)):
            euclidean_dist = 0
            for d in range(0, dims):
                dist = abs(point[d] - centers[i][d])
                euclidean_dist += dist
            euclidean_dist = np.sqrt(euclidean_dist)
            if nearest_center_dist == None:
                nearest_center_dist = euclidean_dist
                nearest_center = i
            elif nearest_center_dist > euclidean_dist:
                nearest_center_dist = euclidean_dist
                nearest_center = i
        if first_cluster:
            point.append(nearest_center)
        else:
            point[-1] = nearest_center
    return data

def mean_center(data, centers, dims):
    print('centers:', centers, 'dims:', dims)
    new_centers = []
    for i in range(len(centers)):
        new_center = []
        n_of_points = 0
        total_of_points = []
        for point in data:
            if point[-1] == i:
                n_of_points += 1
                for dim in range(0,dims):
                    if dim < len(total_of_points):
                        total_of_points[dim] += point[dim]
                    else:
                        total_of_points.append(point[dim])
        if len(total_of_points) != 0:
            for dim in range(0,dims):
                print(total_of_points, dim)
                new_center.append(total_of_points[dim]/n_of_points)
            new_centers.append(new_center)
        else: 
            new_centers.append(centers[i])
        
            
    return new_centers

• K- 평균 클러스터링 알고리즘

# Gets data and k, returns a list of center points.
def train_k_means_clustering(data, k=2, epochs=5):
    dims = len(data[0])
    print('data[0]:',data[0])
    centers = random_centers(dims,k)
    
    clustered_data = point_clustering(data, centers, dims, first_cluster=True)

    for i in range(epochs):
        centers = mean_center(clustered_data, centers, dims)
        clustered_data = point_clustering(data, centers, dims, first_cluster=False)
    
    return centers

def predict_k_means_clustering(point, centers):
    dims = len(point)
    center_dims = len(centers[0])
    
    if dims != center_dims:
        raise ValueError('Point given for prediction have', dims, 'dimensions but centers have', center_dims, 'dimensions')

    nearest_center = None
    nearest_dist = None
    
    for i in range(len(centers)):
        euclidean_dist = 0
        for dim in range(1, dims):
            dist = point[dim] - centers[i][dim]
            euclidean_dist += dist**2
        euclidean_dist = np.sqrt(euclidean_dist)
        if nearest_dist == None:
            nearest_dist = euclidean_dist
            nearest_center = i
        elif nearest_dist > euclidean_dist:
            nearest_dist = euclidean_dist
            nearest_center = i
        print('center:',i, 'dist:',euclidean_dist)
            
    return nearest_center

centers = train_k_means_clustering(X, k=2, epochs=5)

print(centers)

point = [110,3]
print(predict_k_means_clustering(point, centers))

plt.plot(plotx,ploty, 'bo', centers[0][0], centers[0][1],'ro', centers[1][0], centers[1][1], 'go')

선형회귀 실습

colab 이용하기 (구글에서 만든 주피터랑 비슷한 툴) 
https://colab.research.google.com/notebooks/intro.ipynb#recent=true

파이참에 tensorflow-cpu 라이브러리 설치하기
→ 설치 안되면 파이썬 버전 낮춰서 Project 새로 만들기

• tensorflow , plot(그래프 그리는)을 하기 위한 라이브러리 import
• linear regression을 하기 위한 model 생성 - 클래스 활용해서 생성
  • __init__ : 클래스 생성자
    • 모델을 만들면 W, b 값을 5, 0으로 초기 셋팅이 되게 하는 생성자
  • __call__ : tensorflow에서 짜면 자동으로 모델이 잘 호출이 된다.
    • y = model(x) 이런식으로 호출 가능하다.

import tensorflow as tf
import matplotlib.pyplot as plt

# linear regression model
class Model(object):
  def __init__(self):
    self.W = tf.Variable(5.0)
    self.b = tf.Variable(0.0)
  
  def __call__(self, x):
    return self.W * x + self.b # 가설값

• MSE: Mean Squared Error
  • 실제값과 가설값의 차이
  • y : 실제값 , predicted : 가설값
  • reduce_mean : 평균 구해주는 함수
  • square : 제곱해주는 함수

# MSE: Mean Squared Error
def loss_function(y, predicted):
  return tf.reduce_mean(tf.square(predicted - y))

• input을 random으로 만들고 w랑 b를 더하면 완전 선이 되니까 noise 를 더해준다.
• scatter 함수 → plt 라이브러리
  • outputs : 실제값 , c : color
  • model 함수 : 위에서 W와 b값을 미리 만들었기 때문에 그것에 대한 가설
• 실제 y값 = 3(실제 W값) * inputs(x값) + 2(실제 b값) + noise

model = Model()

true_w = 3.0 # 실제 W값
true_b = 2.0 # 실제 b값
examples = 1000 # 데이터 갯수

inputs = tf.random.normal(shape=[examples]) # input을 1000개 만든다.
noise = tf.random.normal(shape=[examples]) # noise를 1000개 만든다.
outputs = inputs*true_w + true_b + noise # 실제 y값

plt.scatter(inputs, outputs, c='b') # y - 파란선
plt.scatter(inputs, model(inputs), c='r') # H(x) - 빨간선
plt.show()

• outputs : 실제 y 값 , model(inputs) : 가설 h값
• 결과 Tensor 라는 함수로 반환을 하고 현재 loss는 8.85라고 출력

# loss function을 정의한 것에 대해서 loss값을 구해오는 것
loss = loss_function(outputs, model(inputs))
print(loss)

• GradientTape() 함수 : Tensorflow에 내장되어 있는 함수 사용
  • gradient 를 직접 구하기가 힘드니까 직접 구해주는 함수
  • gradient() 함수 호출하면 알아서 구해준다.

• 현재 loss를 기반으로 W와 b에 대해서 Gradient값을 구해주는 것
  • gradient : 기울기
• assign_sub : Gradient Descent 과정에서 learning rate를 곱해서 적용

# Gradient Desent를 적용하는 과정
def train(model, inputs, outputs, learning_rate):
  with tf.GradientTape() as t:
		# loss function을 정의한 것에 대해서 loss값을 구해오는 것
    current_loss = loss_function(outputs, model(inputs))
  dW, db = t.gradient(current_loss, [model.W, model.b])
  model.W.assign_sub(learning_rate*dW)
  model.b.assign_sub(learning_rate*db)

• train() 함수 : 학습하는 함수
• 반복문을 돌면서 loss를 구해서 출력 , 반복 학습
• numpy() 함수 : loss_function의 loss값만 가지고 오는 함수

Ws, bs = [], [] # plot 저장할 변수
epochs = 15 # 학습데이터에 대해서 몇번 반복할지에 대한 변수
for epoch in range(epochs):
  Ws.append(model.W.numpy())
  bs.append(model.b.numpy())
  current_loss = loss_function(model(inputs), outputs)

  train(model, inputs, outputs, learning_rate=0.1)
  print('epoch: %2d, W=%1.2f, b=%1.2f, loss=%2.5f'%(epoch, Ws[-1], bs[-1], current_loss))

• W값과 b값을 찾아가는 과정을 나타낸 그래프

plt.plot(range(epochs), Ws, 'r', range(epochs), bs, 'b')
plt.show()

선형회귀분석을 1차원으로 봤는데 딥러닝에서는 수십 차원에 대해서 학습한다.
딥러닝에서는 선이 굴곡지게 그려지는데 실제로 제일 잘 맞는 선을 찾아야함.
너무 많이 돌리면 학습 데이터에 너무 학습이 된다.
노이즈가 조금 달라서 조금만 달라져도 값이 엄청 차이가 나면 실제 데이터에서 성능이 안나오게 된다.
→ 아주 많이 돌리면 Overfitting이 일어난다.

로지스틱 회귀

이진 분류(Binary Classification)

• 2가지중 하나를 선택하는 문제

시그모이드 함수(Sigmoid Function)

• S자 형태로 그려지고, 0과 1 사이의 값을 가지는 함수

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
  return 1/(1+np.exp(-x))

x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)

plt.plot(x, y, 'g')
plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가
plt.title('Sigmoid Function')
plt.show()

→ 0을 기준으로 0보다 클때는 1로 분류 , 0보다 작을때는 0으로 분류

→ 두개로 분류하는 logistic regression

• 이런식으로 Sigmoid function이 움직이면서 분류에 맞게 점점 함수가 모양을 찾아감
  • Linear Regression이 처음에 선을 점점 옮겨가면서 데이터에 맞게 찾아가는 것처럼 Rogistic Regression은 Sigmoid Function이 움직여가면서 두개로 분류를 할 수 있게 모델이 움직인다.

비용함수(Cost function or Loss function)

• 실제값이 1이고 예측값이 0일 때는 cost가 무한으로 발산 실제값이 0이고 예측값이 0일 때는 cost가 0

→ cost를 이런 식으로 지정을 해주면 위의 내용이 바로 반영이 된다.

• 위에서 반영이 된 cost 값들을 다 더하게 cost function을 디자인을 한다.
• 이러한 cost function 을 cross entropy라고 함 → 분류에서 항상 사용이 됨 !! 중요한 부분

지금은 두개라서 0 ,1 인데 밀리면서 0 ,1 , 2 , 3 .. 이런식으로 디자인을 해서 멀티 클래스에서도 cross entropy를 기반으로 분류를 할 수 있음

Linear Regression이랑 Logistic Regression이 지금은 1차원으로 다루고 있지만 점점 2차원 , 3차원으로 올라가는게 딥러닝이다.

로지스틱 회귀 실습

import numpy as np
import tensorflow as tf

# numpy를 가지고 데이터를 임의로 만들어줌
# 데이터가 - 일때는 0이 되고 , + 일때는 1로 분류
x = np.array([-5, -3, -1, 1, 3, 5])
y = np.array([0, 0, 0, 1, 1, 1])

• loss function 함수 정의
  • y 값과 예측값(predicted 값)을 받아옴
  • cost function 수식대로 짜준다.

# cross entropy loss function
def loss(y, predicted):
  return tf.reduce_mean(-y*tf.math.log(predicted) - (1+y)*tf.math.log(1-predicted))

• 모델 생성
  • W만 정의해준다. → W만 있던지 b랑 W랑 있던지 똑같은 과정임

class Model(object):
  def __init__(self):
    self.W = tf.Variable(-0.01)

  def __call__(self, x):
    return 1/(1+tf.math.exp(self.W*x))

model = Model()

• 학습 함수
  • gradient 기울기 값 구해서 assign_sub 해줌
  • assign_sub : Gradient Descent 과정에서 learning rate(학습률)를 곱해서 적용

# Gradient Desent를 적용하는 과정
def train(model, inputs, ouputs, learning_rate):
  with tf.GradientTape() as t:
    predict = model(inputs)
    current_loss = loss(outputs, model(inputs))
    dW = t.gradient(current_loss, model.W)
    model.W.assign_sub(leaning_rate*dW)

epochs = 10
for epoch in range(epochs):
  current_loss = loss(y, model(x))
  train(model, x, y, learning_rate = 0.01)
  print("epoch:%2d, W=%1.2f, loss=%2.5f"%(epoch, model.W, current_loss))

→ epochs 값만큼 반복 학습함

→ 학습할수록 loss가 점점 줄어듬, W값 계속 변함

Linear Regression && Logistic Regression
머신러닝에서 제일 기초가 되는 과정이고 , 학습한 과정이 딥러닝 모델 학습하는 과정이랑 동일하고 좀더 복잡해지는 차이밖에 없음
꼭 잘 이해하고 넘어가야함 !!