2ast_Gun

Spring Standard - Spring MVC (1)

Wed, 17 Aug 2022 07:32:13 GMT

Spring MVC

원격 프로그램 실행

1. 로컬 프로그램 실행

자바 인터프리터가 main() 호출 호출할 수 있는 이유 : static라서 , static는 객체생성 필요 X

2. 원격 프로그램 실행

원격 프로그램은 Tomcat 같은 WAS가 필요. 외부에서 브라우저로 서버에 있는 프로그램을 실행할려면 2가지 작업 필요

프로그램 등록 2. URL과 프로그램을 연결

URL로 원격프로그램을 호출하면 톰캣이 객체 생성을 해주고 메서드 호출을 해줌

HTTP 요청과 응답 - 실습

1. HttpServletRequest

main(String[] args) -> main(HttpServletRequest request)

2. HttpServletRequest의 메서드

HTTP 요청과 응답 - 이론

1. 프로토콜(protocol)이란?

서로 간의 통신을 위한 약속, 규칙
주고 받을 데이터에 대한 형식을 정의한 것

2. HTTP(Hyper Text Transfer Protocol)란?

단순하고 읽기 쉽다. - 텍스트 기반의 프로토콜
상태를 유지하지 않는다.(stateless) - 클라이언트 정보를 저장 X

확장 가능하다. - 커스텀 헤더(header)추가 가능

3. HTTP 메시지

헤더와 바디로 구성되어 있다.

4. HTTP 메시지 - 응답 메시지

상태코드에 따라 의미가 다름, 주로 4XX(Client Error), 5XX(Server Error) 많이 봄

5. HTTP 메시지 - 요청 메시지

2022. 08. 17(수) Python 공부 13일차

Wed, 17 Aug 2022 01:19:08 GMT

클래스 연산자 재정의 이해 및 사용

# Point
# 2차원 좌표평면 각 점(x, y)
# 연산
# 두점의 덧셈, 뺄셈 (1, 2) + (3, 4) = (4, 6)
# 한점과 숫자의 곱셈 (1, 2) * 3 = (3, 6)
# 그 점의 길이 (0, 0) 부터의 거리
# x, y 값 가져오기
# 출력하기

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 두점의 덧셈, 뺄셈 (1, 2) + (3, 4) = (4, 6)
    def __add__(self, pt):
        new_x = self.x + pt.x
        new_y = self.y + pt.y

        return Point(new_x, new_y)

    # 두점의 덧셈, 뺄셈 (1, 2) + (3, 4) = (4, 6)
    def __sub__(self, pt):
        new_x = self.x - pt.x
        new_y = self.y - pt.y

        return Point(new_x, new_y)

    # 한점과 숫자의 곱셈 (1, 2) * 3 = (3, 6)
    def __mul__(self, factor):
        return Point(self.x * factor, self.y * factor)

    # 그 점의 길이 (0, 0) 부터의 거리
    def __len__(self):
        return self.x ** 2 + self.y ** 2

    # x, y 값 가져오기
    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            return -1

    # 출력하기
    def __str__(self):
        return '({}, {})'.format(self.x, self.y)


p1 = Point(3, 4)
p2 = Point(2, 7)
p3 = p1 + p2
p4 = p1 - p2
p5 = p1 * 3


print(p1)
print(p2)
print(p3)
print(p4)
print(p5)
print(len(p1))
print(p1[0])
print(p1[1])

# (3, 4)
# (2, 7)
# (5, 11)
# (1, -3)
# (9, 12)
# 25
# 3
# 4

클래스 연습문제 풀이

연습문제)

복소수 클래스를 정의 해봅시다.
덧셈, 뺄셈, 곱셈 연산자 지원
길이 (복소수의 크기) 지원
복소수 출력 '1 + 4j'와 같이 표현
비교 연산 ==, != 지원
=, <=, <, > 연산 지원
절대값 지원

Machine Learning 기초

Tue, 16 Aug 2022 05:26:17 GMT

Part1 : Machine Learning의 개념과 종류

Machine Learning의 개념

"무엇(X)으로 무엇(Y)을 예측하고 싶다"

데이터는 행과 열로 이루어져 있어야 한다. 예측하고 싶은 대상을 Y로 두었고 Y에 쓰이는 대상을 X로 주었다. X를 가지고 Y를 예측하고 싶을때 이럴경우 머신러닝을 사용한다

기계 학습 또는 머신 러닝(영어 : machine learning)은 인공 지능의 한 분야로, 컴퓨터가 학습할 수 있도록 하는 알고리즘과 기술을 개발하는 분야를 말한다 (위키피디아)

주어진 데이터를 통해서 입력변수와 출력변수간의 관계를 만드는 함수 f를 만드는 것
주어진 데이터 속에서 데이터의 특징을 찾아내는 함수 f를 만드는 것

즉 함수 f가 머신러닝이다. 그런데 하나 더 x를 가지고 y를 예측하는 것 뿐만 아니라 x에 대해서 x끼리의 숨겨진 패턴을 찾아낸다거나 이 데이터안에서 새로운 특징을 찾아내는거 또한 머신러닝이다.

Machine Learning으로 할 수 있는 것들

예측 탐지 모델, 이상 탐지 모델, 이미지 분류 모델 등등 X들로만 가지고 할 수 있는 것들 : Segmentation, 로그기록을 이용해서 맞춤 상품 추천 시스템, 소셜 및 사회 이슈 파악 등등

f란 무엇인가 (회귀 분석인 경우)

f를 구하기 위해서 입력 변수와 출력 변수가 필요함
p개의 입력 변수 X1, X2, ... Xp가 있고, 출력 변수 Y가 있을 때, X = (X1, X2, ..., Xp)라 하면 입력 변수와 출력 변수의 관계를 나타내는 식은 다음과 같음

앱실론 : 오차항 예측치와 실제 값의 차이를 오차항(앱실론)이라 부른다. 실제 Y값을 예측 할려면 f(X) + 앱실론 을 해야 한다. 함수 f : 정해졌지만 알 수 없는 함수

Population(모집단)을 알고 있다면 함수 f는 완벽하게 알 수 있다. 허나 모집단을 완벽하게 알 수 없으니 예측을 하는것

Population을 모를 때 샘플을 뽑아서 데이터를 학습하고 그 데이터를 가지고 함수 f를 추정한다. (추정을 하기 때문에 모자를 씌운다) 즉 Y햇

지도학습과 비지도학습

지도 학습(supervised learning)

Y가 연속형 변수일 때 우리는 이 문제를 회귀(regression) 문제 라고 이야기 하고, 그때의 모형을 회귀 모형(regression model)이라 한다. Y가 연속형이다 라는 뜻은 Y가 어떠한 실수값을 가질때를 얘기한다. 키, 몸무게, BMI 지수 이런것들을 다 모두 연속형 변수라고 한다.

Y가 이산형 변수를 가질 때 즉 어떠한 클래스를 가질 때 우리는 이 문제를 분류(Classification) 문제 라고 이야기 하고 이 때의 모형을 분류 모형(Classification model)이라 한다. 이산형 변수라는 것은 성별, 흡연여부, 질병여부, 주가 오른다 내린다, 불량이다 정상이다, 비만여부 등 이런것들을 이산형 변수라고 한다.

비지도 학습(unsupervised learning)

출력 변수(Y)가 존재하지 않고, 입력 변수(X)간의 관계에 대해 모델리 ㅇ하는 것
군집 분석 - 유사한 데이터끼리 그룹화
PCA - 독립변수들의 차원을 축소화

X들끼리 어떠한 패턴을 찾아내는것을 비지도학습이라 한다. 가장 대표적인 예가 군집 분석이다. PCA는 새로운 축을 만들어서 아에 새로운 변수를 만드는것이 PCA 기법이다.

강화학습(reinforcementlearning)

수 많은 시뮬레이션을 통해 현재의 선택이 먼 미래에 보상이 최대가 되도록 학습
Agent가 action을 취하고 환경에서 보상을 받고 이 보상이 최대가 되도록 최적의 action을 취하는 방법을 배움

최근에는 강화학습도 머신러닝의 일부라고 주장하는 사람들도 많다. 에이전트가 어떤 상태일때 어떤 액션을 취해야 먼 미래에 큰 보상을 받느냐가 기준이된다. 강화학습의 가장 유명한 예 : 알파고 -> 에이전트 : 바둑기사, 액션 : 바둑의 모든 수 state : 바둑 판, reward : 대국이 끝났을 대 이겼느냐 졌느냐를 따지는것

정리

머신러닝은 지도학습과 비지도학습으로 나뉠수 있는데 지도학습은 회귀와 분류로 나누고 비지도학습은 PCA나 군집화 기타 등등 많은 알고리즘들이 있고 두개의 큰 차이점은 Labeled data의 존재유무 차이이다. 요즘에는 강화학습도 머신러닝의 일부라고 주장하는 사람들도 있다.

Machine Learning의 종류

선형 회귀분석(Liner Regression)

독립변수와 종속변수가 선형적인 관계가 있다라는 가정하에 분석
직선을 통해 종속변수를 예측하기 때문에 독립변수의 중요도와 영향력을 파악하기 쉬움

선형 회귀분석은 어떤 직선을 그어서 이 직선을 가지고 X를 가지고 Y를 예측하고 싶어 한다 선형적인 관계가 있다 : X가 증가/감소할때 Y도 증가/감소해야 선형적인 관계가 있다라고 한다 단점은 비선형관계에 관해서는 표현을 잘 못한다.

의사결정나무(Decision Tree)

독립 변수의 조건에 따라 종속변수를 분리 (비가 내린다 -> 축구를 하지 않는다)
이해하기 쉬우나 overfitting이 잘 일어남

이 모델은 너무 직관적이다. 머신러닝을 잘 모르는 사람들도 이 그림을 보면 아 이런 모델이구나 라고 생각할 수 있을 정도로 직관적이다. 간단한 문제에는 잘 맞고 복잡한 문제에는 잘 맞지 않는 단점이 있다.

KNN(K-Nearest Neighbor)

새로 들어온 데이터의 주변 k개의 데이터의 class로 분류하는 기법

굉장히 간단한 모델이다. 이 데이터 내에서 3개의 클래스가 있다고 했을 때 물음표에 해당하는 데이터가 들어왔을때 이 주변 k개 데이터를 봐서 어느 클래스에 더 가까운지 묻고 그에 해당하는 대답에 대한 클래스로 분류하는것이 KNN이다. 여기서 k는 사람이 지정해주는 거라 k에 따라서 성능이 달라진다. 사람이 지정해 주어야 하는 파라미터를 하이퍼 파라미터라고 한다.

Neural Network

입력, 은닉, 출력층으로 구성된 모형으로서 각 층을 연결하는 노드의 가중치를 업데이트하면서 학습

딥러닝 모델의 근간이 되는 네트워크 모델이다. 수 많은 직선을 이용을 해서 복잡한 모형을 만들 수 있게 되는게 뉴럴 네트워크이다. 출력값을 내 뱉고 실제값과 출력값의 차이를 보고 다시 weight를 업데이트 시켜 분류가 잘 되게끔 학습을 시키는게 뉴럴 네트워크의 기본 원리라고 생각하면 된다. 치명적인 단점은 오버피팅이 너무 잘된다. 그래서 잘 쓰이지 않게 되었다.

SVM(Support Vector Machine)

Class 간의 거리(margin)가 최대가 되도록 decision boundary를 만드는 방법

2000년대 초중반까지 잘 쓰인 모델 이 클래스간의 거리가 최대가 되게끔 직선을 긋기 때문에 좀 더 decision boundary를 좋게 그을 수 있다. 실제 데이터에는 잘 맞지않는 오버피팅이 잘 발생하였다. SVM은 학습 과정 내에서 어느정도 오차는 허용한다. 학습하는 시간이 너무 오래걸리는 단점이 있다. 데이터가 커질 수록 더더욱 오래걸린다. 예를들어 일반적인 데스크탑인 경우 10000개의 데이터라고 가정할때, 칼럼이 4000개라면 SVM은 하루정도 걸릴수 있다.

Ensemble Learning

여러 개의 모델(classifier or base learner)을 결합하여 사용하는 모델

요즘 가장 많이 쓰이고 있는 앙상블 러닝 앙상블이라는 뜻 자체가 화합을 이루다 조화를 이루다라는 뜻 앙상블 러닝의 기본 모델은 classifier, base learner 이다. 디시전 트리를 많이 사용 한다. 디시전 트리를 기반으로 앙상블 러닝을 많이 사용하고 크게 3가지 정의가 있는데 다음시간에 배움.

여러개의 모델을 만든 다음에 데이터가 들어 왔을 때 예측을 하고 각각의 모델들이 아웃풋을 내뱉을건데 그때의 아웃풋을 평균을 내거나 투표를 한다.

앙상블 러닝 같은 경우에는 이 베이스 언어를 어떻게하면 다양하게 만들 수 있을까 좀 더 다양한 모델을 만들어서 하나의 새로운 성능이 좋은 분류기를 만들 수 있을까가 핵심이다.

앙상블 러닝에 크게 3가지 정의가 있을뿐이지 그 3개가 전부가 아니다.

K-means clustering

Label 없이 데이터의 군집으로 k개로 생성

언슈퍼바이저드 러닝의 가장 대표적인 예인 군집분석이고 가장 유명한 K-means clustering

데이터가 (a)처럼 되어있따고 가정 하면은 랜덤하게 포인트 2개를 찍고(b) 그 다음에 이 주변에 가까운 각각의 데이터들을 할당을 시킨다(c) 그 다음에 이 데이터의 중심점을 다시 찍는다(d) 다시 그 주변의 데이터들을 할당한다(e) 또 다시 데이터의 중심점을 찍는다(f)

k개를 어떻게 설정에 하느냐에 따라서 성능이 달라지는 단점이 있다.

2022. 08. 16(화) Spark & Hadoop 초격차 12일차

Tue, 16 Aug 2022 02:04:14 GMT

Apache Spark 기초

Spark 개요 (Spark Software Components)

Spark Software Components (1/2)

Driver는 클라이언트 사이드의 어플리케이션으로서 Spark 프로그램의 시작점인 Spark Context를 내부에 생성하고 유지합니다. Spark의 동작은 Spark Context로부터 시작됩니다. Driver는 Spark Context를 통해 Spark Standalone, Hadoop YARN과 같은 Cluster manager와 통신하여 실제 분산 병렬 연산을 수행하는 Executor 생성을 요청하게 됩니다.

Spark Software Components (2/2)

로컬 환경은 여러 머신이 아닌 단일머신에서 로컬 cpu 코어를 통해 병렬 쓰레드로 여러 task들을 수행합니다. 반면 분산 환경은 복수개의 머신에서 각 서버의 cpu 코어를 통해 다수개의 task들을 분산 병렬로 수행하게 됩니다. 결국 우리가 작성하여 실행하는 spark 어플리케이션은 하나의 드라이브 프로그램과 복수개의 Executor들로 구성되어 실행됩니다. 각각의 Executor들은 드라이브가 할당한 task들을 병렬로 실행하고 그 결과를 드라이브에게 전달합니다. spark 어플리케이션을 로컬환경에서 실행하면 익스큐트 프로그램은 별도로 실행되지 않고 드라이버 프로그램의 프로세스 내에서 로컬 스레드로 실행됩니다. 스팍 어플리케이션을 분산환경에서 실행하면 익스큐트 프로그램은 클러스터 매니저가 할당해준 서버들 위에서 각각 별도의 프로세스로 실행된다.

Submitting Applications on Cluster

프로그램을 제출하면 Spark Context가 클러스터 관리자에 연결됩니다.

연결되면 스파크는 클러스터의 노드에서 실행자와 함께 할당됩니다.

애플리케이션 코드(JAR에 의해 정의되거나 SparkContext에 전달된 Python 파일에 의해 정의됨)를 실행자에게 보냅니다. 그런 다음 SparkContext는 실행자가 실행하고 결과를 반환할 수 있도록 작업을 전송합니다.

Spark 개요 (Spark Programming Model)

Spark Programming Model - SparkContext

SparkContext는 클러스터 매니저에게 Executor 생성을 요청합니다. 실제 데이터를 읽고 처리하고 저장하는 것은 Executor의 타스크를 통해 이루어집니다. 데이터 캐시도 Executor의 메모리를 사용합니다.

Spark Programming Model - RDD (1/2)

로컬 컬렉션과 마찬가지로 분산 컬렉션 작업

불변의 데이터 구조
인메모리(명시적으로)
내결함성
병렬 데이터 구조
데이터 배치를 최적화하기 위한 제어된 파티셔닝
풍부한 연산자 집합을 사용하여 조작할 수 있음

Spark Programming Model - RDD (2/2)

RDD가 제공하는 API는 크게 3가지가 있다. RDD에 담겨진 데이터의 변경을 위한 Transformations API, RDD에 담겨진 데이터를 드라이브에 가져오거나 외부 저장소에 저장하는 Actions API, 반복적으로 자주 사용될 것 같은 RDD를 성능 향상을 위헤 메모리나 디스크에 캐시하기 위한 Persistence API가 그 3가지 입니다.

Transformations :

기존 데이터 집합에서 새 데이터 집합을 만듭니다.
천성이 게으르다. 일부 작업이 수행될 때만 실행됩니다.

Actions :

계산을 수행한 후 dirver 프로그램으로 값을 반환하거나 데이터를 스토리지 시스템으로 내보냅니다.

Persistence :

향후 작업을 위해 데이터셋을 메모리에 캐슁하는 데 사용됩니다.
Disk 또는 RAM에 저장하거나 혼합(스토리지 수준)하는 옵션

Spark 개요 (RDD - Lazy Evaluation + No Cache/Cache)

RDD - Lazy Evaluation + No cache

분석 클러스터는 마스터 서버 1대와 워크서버 3대로 구성되어 있습니다.

RDD - Lazy Evaluation + Cache

동일 작업에 대해 메모리 캐시를 이용하면 1TB의 데이터에 대해서도 5~7초 사이에 결과를 확인할 수 있다고 한다. 반복적으로 사용되는 RDD에 대한 Cache는 성능 향상을 가져옵니다.

RDD - Behavior with Less RAM

캐시는 RDD에 파티션 단위로 처리됩니다. 하나의 파티션을 메모리에 모두 캐시하기에 충분한 메모리가 없다면 메모리에 일부 여유가 있더라도 파티션의 일부만 캐시하지 않습니다. 하나의 파티션 전체가 캐시되거나 캐시되지않거나 입니다. 캐시되지 않는 파티션의 데이터는 디스크의 저장된 원본파일로부터 다시 읽어서 연산을 수행합니다 .메모리에 여유가 생겨 해당 파티션을 캐시하기 전까지는 Action 수행시마다 캐시되지 않은 파티션의 데이터는 디스크로부터 반복적으로 다시 읽어와야 합니다. 당연히 캐시된 파티션이 많을수록 실행속도는 빨라질것입니다.

Spark 개요 (RDD - Fault Tolerance)

RDD - Fault Tolerance

Apache Spark은 특정 RDD가 만들어지기까지 수행된 일련의 트랜스포메이션 작업들을 추척하고 있습니다. 이를 Lineage라 부릅니다. RDD의 혈통을 기록한것이라고 생각하면 됩니다. 이는 손실된 데이터를 다시 계산하여 결함이 발생한 RDD를 복구하는데에 사용됩니다. 예를 들어 메시지 RDD의 Lineage는 HDFS에 있는 특정 경로에 데이터를 읽어와 에러 메세지만 필터링 하고 구분자로 사용된 탭으로 스플릿하여 인덱스 인 위치의 값을 추출한다는 일련의 변환작업이 기록되어 있습니다.

RDD - Fault Recovery Test

첫번째 액션에서 실제 메모리에 캐시하는 작업이 이루어지기 때문에 실행시간이 조금 많이 걸립니다. 두번째 액션부터는 캐시된 데이터로 부터 연산이 시작되기 때문에 상대적으로 짧은 시간에 실행이 이루어집니다. 다섯번째 액션을 정상 실행한 후 장애가 발생합니다. 캐시된 데이터중 일부가 손실됩니다. 여섯번째 액션에서 손실되지 않은 캐시데이터는 정상적으로 사용됩니다. 손실된 일부 캐시데이터는 Lineage를 통해 처음부터 다시 재연산 됩니다. 이를 통해 캐시는 다시 100% 정상으로 복구됩니다. 이 과정에서 손실된 일부 데이터를 디스크에서 다시 읽어와 재연산하기에 시간이 다소 더 걸립니다. 하지만 대부분 정상적인 캐시를 사용하므로 첫번째 액션 수행보다는 짧은 시간안에 실행이 이루어집니다. 일곱번째 액션부터는 실행속도가 기존처럼 다시 빨라집니다.

2022. 08. 16(화) Python 공부 12일차

Tue, 16 Aug 2022 01:21:03 GMT

클래스 정의 및 사용하기

class란?

실세계의 것을 모델링하여 속성(attribute)와 동작(method)를 갖는 데이터 타입
python에서의 string, int, list, dict... 모두가 다 클래스로 존재
예를들어 학생이라는 클래스를 만든다면, 학생을 나타내는 속성과 학생이 행하는 행동을 함께 정의 할 수 있음
따라서, 다루고자 하는 데이터(변수)와 데이터를 다루는 연산(함수)를 하나로 캡슐화(encapsulation)하여 클래스로 표현
모델링에서 중요시 하는 속성에 따라 클래스의 속성과 행동이 각각 달라짐
```
### class란?
```

a = [1, 2, 3, 4] a.append(5) print(a)

### object란?
- 클래스로 생성되어 구체화된 객체(인스턴스)
- 파이썬의 모든 것(int, str, list... etc)은 객체(인스턴스)
- 실제로 class가 인스턴스화 되어 메모리에 상주하는 상태를 의미
- class가 빵틀이라면, object는 실제로 빵틀로 찍어낸 빵이라고 비유 가능

### class 선언하기
- 객체를 생성하기 위해선 객체의 모체가 되는 class를 미리 선언해야 함
```python
### class 선언하기
class Person:
    pass


bob = Person()
cathy = Person()

a = list()
b = list()

print(type(bob), type(cathy))
print(type(a), type(b))

생성자(init)의 이해 및 사용하기

_init_(self)

생성자, 클래스 인스턴스가 생성될 떄 호출됨
self인자는 항상 첫번째에 오며 자기 자신을 가리킴
이름이 꼭 self일 필요는 없지만, 관례적으로 self로 사용
생성자에서는 해당 클래스가 다루는 데이터를 정의
- 이 데이터를 멤버 변수(member variable) 또는 속성(attribute)라고 함
```
### __init__
```

class Person: def init(self): print(self, 'is generated')

p1 = Person() p2 = Person()

<main.Person object at 0x000001C69924CFD0> is generated

<main.Person object at 0x000001C69924CF10> is generated

class Person: def init(self, name, age=10): # print(self, 'is generated') self.name = name self.age = age

p1 = Person('Bob', 30) p2 = Person('Kate', 20) p3 = Person('Aaron')

print(p1.name, p1.age) print(p2.name, p2.age) print(p3.name, p3.age)

Bob 30

Kate 20

Aaron 10

## self 키워드의 이해 및 사용하기

### self
- 파이썬의 method는 항상 첫번째 인자로 self를 전달
- self는 현재 해당 메소드가 호출되는 객체 자신을 가리킴
- C++ / C#, Java의 this에 해당
- 역시, 이름이 self일 필요는 없으나, 위치는 항상 맨 처음의 parameter이며 관례적으로 self로 사용
```python
### self

class Person:
    def __init__(self, name, age=10):
        print('self: ', self)
        self.name = name
        self.age = age

    def sleep(self):
        print('self: ', self)
        print(self.name, '은 잠을 잡니다.')


a = Person('Bob', 30)
b = Person('Kate', 20)

print(a)
print(b)

a.sleep()
b.sleep()

# self:  <__main__.Person object at 0x0000020AE3C3CEB0>
# self:  <__main__.Person object at 0x0000020AE3C3CDC0>
# <__main__.Person object at 0x0000020AE3C3CEB0>
# <__main__.Person object at 0x0000020AE3C3CDC0>
# self:  <__main__.Person object at 0x0000020AE3C3CEB0>
# Bob 은 잠을 잡니다.
# self:  <__main__.Person object at 0x0000020AE3C3CDC0>
# Kate 은 잠을 잡니다.

method, static method 정의 및 사용하기

method 정의

멤버함수라고도 하며, 해당 클래스의 obejct에서만 호출 가능
메소드는 객체 레벨에서 호출되며, 해당 객체의 속성에 대한 연산을 행함
{obj}.{method}() 형태로 호출됨
```
### method 정의
```

1. 숫자를 하나 증가

2. 숫자를 0으로 초기화

class Counter: def init(self): self.num = 0

def increment(self):
    self.num += 1

def reset(self):
    self.num = 0

def print_current_value(self):
    print('현재값은: ', self.num)

c1 = Counter() c1.print_current_value() c1.increment() c1.increment() c1.increment() c1.print_current_value()

c1.reset() c1.print_current_value()

현재값은: 0

현재값은: 3

현재값은: 0


### method type
- instance method - 객체로 호출
  - 메소드는 객체 레벨로 호출 되기 때문에, 해당 메소드를 호출한 객체에만 영향을 미침
- class method(static method) - class로 호출
  - 클래스 메소드의 경우, 클래스 레벨로 호출되기 때문에, 클래스 멤버 변수만 변경 가능
```python
### method type
class Math:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b


print(Math.add(10, 20))
print(Math.multiply(10, 20))

# 30
# 200

클래스 상속의 이해 (코드를 재사용하기2)

Class Inheritance(상속)

기존에 정의해둔 클래스의 기능을 그대로 물려받을 수 있다.
기존 클래스에 기능 일부를 추가하거나, 변경하여 새로운 클래스를 정의한다.
코드를 재사용할 수 있게된다.
상속 받고자 하는 대상인 기존 클래스는 (Parent, Super, Base class라고 부른다.)
상속 받는 새로운 클래스는(Child, Sub, Derived class 라고 부른다)
의미적으로 is - a 관계를 갖는다.
```
### Class Inheritance(상속)
```

class Person: def init(self, name, age): self.name = name self.age = age

def eat(self, food):
    print('{}은 {}를 먹습니다'.format(self.name, food))

def sleep(self, minute):
    print('{}은 {}분동안 잡니다'.format(self.name, minute))

def work(self, minute):
    print('{}은 {}분동안 일합니다'.format(self.name, minute))

class Student(Person): def init(self, name, age): self.name = name self.age = age

Employee(부모클래스)

class Employee(Person): def init(self, name, age): self.name = name self.age = age

bob = Student('Bob', 25) bob.eat('BBQ') bob.sleep(30) bob.work(60)

Bob은 BBQ를 먹습니다

Bob은 30분동안 잡니다

Bob은 60분동안 일합니다


### method override
- 부모 클래스의 method를 재정의(override)
- 하위 클래스(자식 클래스)의 인스턴스로 호출시, 재정의된 메소드가 호출됨
```python
### method override

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self, food):
        print('{}은 {}를 먹습니다'.format(self.name, food))

    def sleep(self, minute):
        print('{}은 {}분동안 잡니다'.format(self.name, minute))

    def work(self, minute):
        print('{}은 {}분동안 일합니다'.format(self.name, minute))


class Student(Person):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def work(self, minute):
        print('{}은 {}분동안 공부합니다'.format(self.name, minute))

# Employee(부모클래스)
class Employee(Person):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def work(self, minute):
        print('{}은 {}분동안 업무를 합니다'.format(self.name, minute))


bob = Student('Bob', 25)
bob.eat('BBQ')
bob.sleep(30)
bob.work(60)

bob = Employee('Bob', 25)
bob.eat('BBQ')
bob.sleep(30)
bob.work(60)

# Bob은 BBQ를 먹습니다
# Bob은 30분동안 잡니다
# Bob은 60분동안 공부합니다

# Bob은 BBQ를 먹습니다
# Bob은 30분동안 잡니다
# Bob은 60분동안 업무를 합니다

super

하위클래스(자식 클래스)에서 부모클래스의 method를 호출할 때 사용
```
### super
```

class Person: def init(self, name, age): self.name = name self.age = age

def eat(self, food):
    print('{}은 {}를 먹습니다'.format(self.name, food))

def sleep(self, minute):
    print('{}은 {}분동안 잡니다'.format(self.name, minute))

def work(self, minute):
    print('{}은 {}분동안 준비를 합니다.'.format(self.name, minute))

class Student(Person): def init(self, name, age): self.name = name self.age = age

def work(self, minute):
    super().work(minute)
    print('{}은 {}분동안 공부합니다'.format(self.name, minute))

Employee(부모클래스)

class Employee(Person): def init(self, name, age): self.name = name self.age = age

def work(self, minute):
    super().work(minute)
    print('{}은 {}분동안 업무를 합니다'.format(self.name, minute))

bob = Employee('Bob', 25) bob.eat('BBQ') bob.sleep(30) bob.work(60)

Bob은 BBQ를 먹습니다

Bob은 30분동안 잡니다

Bob은 60분동안 준비를 합니다.

Bob은 60분동안 업무를 합니다

```

다음시간에

special method

__로 시작 __로 끝나는 특수 함수
해당 메소드들을 구현하면, 커스텀 객체에 여러가지 파이썬 내장 함수나 연산자를 적용 가능
오버라이딩 가능한 함수 목록은 아래 링크에서 참조

모두를 위한 딥러닝 - ML Lec 12

Mon, 08 Aug 2022 04:54:19 GMT

lec12: NN의 꽃 RNN 이야기

Sequence data

We don't understand one word only
We understand based on the previous words + this word. (time series)
NN/CNN cannot do this

우리가 사용하는 데이터중에서는 시퀀스 데이터들이 많이 있다. 음성인식이라던지 우리가 말하는 자연어를 보면 이게 하나의 데이터가 아니라 시퀀스로 되어있다.

h는 y로 이해하길 바람. 이전에 계산한 State가 다음 계산에 영향을 미친다.

Recurrent Nurial Network

RNN은 수행해서 Y값을 뽑아내게 되는데 어떻게 계산하는 걸까요?

new State를 계산하는데 중요한것은 이전의 state(old State)가 입력으로 사용이 된다. X라는 입력값과 old State을 가지고 어떤 함수를 이용해서 계산을 한다.

주어진 function이 모든 RNN에서 동일하다

(Vanilla) Recurrent Neural Network

기초적인 RNN 연산 방법

Character-level language model example

다음에 오는 글자를 예측하는 시스템을 language model

벡터로 표현하는 방법은 여러가지가 있는데 그 중 쉬운 방법은 One-hot Encoding

첫번째 hidden layer에는 이전 state 값이 없으니까 0으로 준다. 어떻게 보면 RNN이라는 것은 이전의 것들을 기억한다라는 의미가 있다.

Y를 구하는 식

RNN applications

활용하는 방법이 굉장히 다양하다. 다음 단어를 예측하는 Language Modeling

Recurrent Networks offer a lot of flexibility

RNN을 가지고 여러가지 형태를 구성할 수 있따. Image Captioning : sequence of words Sentiment Classification : many to one Maching Translation : many to many Video classification on frame level : many to many

Multi-Layer RNN

layer도 하나만 줄 수 있지만 여러개도 줄 수 있어서 더 복잡한 학습이 가능하다.

Training RNNs is challenging

2022. 08. 08(월) Spark & Hadoop 초격차 11일차

Mon, 08 Aug 2022 01:55:18 GMT

Apache Spark 기초

Spark 개요 (소개, 특징, RDD)

Apache Spark

Unified Engine : Support end-toend applications
High-level APIs : Easy to use, rich optimizations
Integrate Broadly : Storage systems, libraries, etc

아파치 Spark은 빅데이터에 대한 컴퓨터 연산을 다수의 서버로 구성된 클러스터에서 분산 병렬처리하기 위한 오픈소스 엔진이다.

일반적으로 데이터를 모아서 일괄처리하는 배치작업부터 구조화된 데이터에 대한 처리를 수행하는 SQL 작업, IOT 센서데이터와 같은 지속적으로 들어오는 실시간 데이터를 스토리지에 저장 없이 바로 처리하는 스트리밍 작업, 분산 환경에서의 대용량 학습 데이터를 통한 머신러닝 트레이닝 및 추론 작업, 그리고 버택스 엣지 구조?의 그래프 데이터에 대한 병렬 연산과 같이 다양한 작업을 개별 엔진이 아닌 하나의 엔진에서 처리할 수 있는 통합 데이터 처리 엔진이다.

Spark은 저장소가 아니다. 외부의 데이터를 읽어 분산 환경에서 원하는 형태로 데이터를 처리한 후 그 결과를 다시 외부에 저장하는 컴퓨팅 엔진이다.

Apache Spark란? (1/2)

Apache Spark는 대용량 데이터 프로세싱을 위한 빠르고 범용적인 인메모리 기반 클러스터 컴퓨팅 엔진
분산 메모리 기반의 빠른 분산 병렬 처리
배치, 대화형 쿼리, 스트리밍, 머신러닝과 같은 다양한 작업 타입을 지원하는 범용 엔진으로 Apache Hadoop과 호환
Scala, Java, Python, R 기반 High-level APIs 제공

Apache Spark란? (2/2)

Spark은 클러스터 환경에서 분산 병렬 연산이 가능하도록 설계되어 있다. 클러스터 매니저가 별도로 존재한다. ex) Hadoop YARN, apache Mesos, Kubernetes Spark Core는 분산 병렬 연산을 위한 작업 스케쥴 및 오류 발생시에도 문제없이 연산을 지속할 수 있는 폴트 토로론스?와 같은 다양한 핵심 기능 제공

이와 더불어 Spark의 기본데이터 모델인 RDD를 기반으로 데이터 연산을 분산 병렬로 처리합니다. Spark Core에서 다양한 확장 라이브러리가 동작한다. Spark SQL, Spart Streaming , MLlib, GraphX

기존 R과 Python 환경에서 Spark를 사용하기 위한 추가 패키지형태의 SparkR, Pyspark도 같이 제공

오픈소스 spark 커뮤니티는 글로벌하게 활동하고 있다. spark 공식 배포판에 없는 기능들은 별도의 공개된 비공식 패키지로 확장 가능하다.

Apache Spark 특징 (1/2)

In-Memory 컴퓨팅 (물론 Disk 기반도 가능)
RDD (Resilient Distributed Dataset) 데이터 모델
다양한 개발 언어 지원 (Scala, Java, Python, R, SQL)
Rich APIs 제공 (80여개 이상, 2 ~ 10x Less Code)
General execution graphs => DAG (Directed Acyclic Graph) => Multiple stages of map & reduce
Hadoop과의 유연한 연계 (HDFS, HBase, YARN and Others)

여러 단계의 Map&Reduce 작업을 워크플로우 형태로 연달아 이어서 처리 할 수 있다. 이러한 연속된 작업은 DAG 형태로 관리되며 Spark 내부에서 최적화되어 수행된다.

Apache Spark 특징 (2/2)

빠른 데이터 Processiong (In-Memory Cached RDD, Up to 100x Faster)
대화형 질의를 위한 Interactive Shell (Scala, Python, R Interpreter)
실시간(Real-time) Stream Processing (vs. MapReduce for stored Data)
하나의 애플리케이션에서 배치, SQL 쿼리, 스트리밍, 머신러닝과 같은 다양한 작업을 하나의 워크플로우로 결합 가능
Both fast to write and fast to run

RDD (resilient Distributed Dataset) (1/2)

Dataset
- 메모리나 디스크에 분산 저장된 변경 불가능한 데이터 객체들의 모음
Distributed
- RDD에 있는 데이터는 클러스터에 자동 분배 및 병렬 연산 수행
Resilient
- 클러스터의 한 노드가 실패하더라도 다른 노드가 작업 처리 (RDD Lineage, Automatically rebuilt on failure)

RDD는 실패에 강한 즉, 데이터 처리 과정중 실패로부터 쉽게 회복 가능한 분산 데이터 셋 구조를 추상한 모델입니다.

RDD (resilient Distributed Dataset) (2/2)

Immutable
- RDD는 수정이 안됨. 변형을 통한 새로운 RDD 생성
Operation APIs
- Transformations (데이터 변형, e.g. map, filter, groupBy, join)
- Actions (결과연산 리턴 / 저장, e.g. count, collect, save)
Lazy Evaluation : All Transformations (Action 실행 때까지)
Controllable Persistence
- Cache in RAM / Disk 가능 (반복 연산에 유리)

RDD가 제공하는 API는 크게 3가지로 나뉩니다. Cache 관련 API와 RDD 내의 데이터를 변형하는 API를 Transformations API, RDD 내의 데이터를 가져오거나 외부의 저장하는 등의 API를 Action API로 나뉩니다.

RDD 생성 -> RDD 변형 -> RDD 연산

외부 데이터를 읽어 RDD에 담는다. 외부 데이터를 읽을 때 부터 분산 병렬로 읽게된다

원하는 형태의 데이터가 될 때 까지 RDD Transformations을 반복 수행한다. Transformations은 기존 RDD 내용을 바꾸는 것이 아니라 바뀌어진 새로운 RDD를 생성한다.

Transformations 작업을 계속 반복 수행 합니다.

Transformations을 한번 더 수행하면 최종 원하는 모습의 데이터를 가지는 RDD를 얻게 됩니다

최종 RDD에 원하는 Action을 수행합니다. 데이터가 몇건 있는지 살펴 볼까요

이번에는 원하는 데이터를 배열로 다 가져와 봅시다. 이 때 드라이브로 가져오는 데이터의 크기가 너무 크다면 메모리가 부족해서 Out of Memory 즉 OM 예외가 발생할 수도 있다.

마지막으로 원하는 데이터를 향후 분석을 위해 외부 저장소에 저장합니다. 저장 작업도 RDD 내 파티션 단위로 병렬 처리되어 개별 파일로 저장이 됩니다.

Spark 개요 (지원 언어, Interactive Shell)

Spark Language Support

원하는 언어의 API를 이용하여 Spark Application을 개발해 독립적으로 실행 할 수 있다.

Interactive Shell

Spark이 제공하는 대화형 Shell을 통해서 Spark을 배우는 입문 초기에 Spark의 다양한 기능을 보다 쉽게 직접 테스트해보고 경험 해볼수 있습니다. Spark의 Interactive Shell은 로컬 실행 뿐만 아니라 Spark이 지원하는 다양한 클러스터 매니저에 연결하여 클러스터 내의 분산수행도 가능합니다.

Spark이 지원하는 여러 언어 중 Scala로 spark api를 사용할 수 있는 대화형 쉘인 Spark Shell 이다.

Python으로 Spark API를 사용할 수 있는 대화형 쉘인 pyspark 이다.

R로 Spark API를 사용할 수 있는 대화형 쉘인 SparkR 이다.

SQL 쿼리를 위한 대화형 쉘인 Spark Sql 이다.

Spark 개요 (Web Notebook, Zeppelin / Jupyter / RStudio)

Web Notebook

웹 기반 노트북은 대화형 분석이 가능하고 작성한 코드를 저장할 수 있으며 언어별 차트 라이브러리 및 노트북 자체 차트 기능을 통해 분석한 내용에 대해 시각화가 가능합니다

Web Notebook (w/ Spark)

Apache Zeppelin은 하나의 노트에서 여러 클러스터에 접근 가능합니다. Apache Zeppelin은 하나의 노트에서 여러 언어로 Spark Code를 작성할 수 있습니다. Apache Zeppelin은 하나의 노트에서 Spark 위의 다른 Shell도 실행 가능합니다.

Jupyter Notebook은 주로 파이썬 기반 웹 노트북으로 많이 사용하고 있다 파이썬 언어로 spark 사용할 경우 익숙한 환경을 제공한다. spark 연동 시 노트 하나가 하나의 Spark application이 됩니다

RStudio는 설치형 R Studio환경을 웹 브라우저에서도 경험 할수 있게 해주는 웹 기반 노트 환경을 제공합니다.

Spark 개요 (Web UI, Driver / Cluster Manager)

Administrative Web UIs

Driver (Spark Application)
History Server
Cluster Manager (Cluster Resource Manager)

Driver (Spark Application) Web UI

Spark Context가 제공하는 UI Web UI의 Default port는 4040, 만약 사용중이라면 포트 번호를 1씩 증가시키면서 할당한다.

History Server Web UI

이미 실행이 끝난 Spark Applicaiton의 실행내역을 볼 순 없을까요? Spark Applicaiton 실행 시 수행한 이벤트를 어딘가에 기록 한다면 볼 수 있다.

Spark Standalone Web UI

Spark 배포판 내부에 기본적으로 포함되어 있다. 빠르고 가벼운 Spark Application 전용 클러스터 매니저가 필요하다면 Spark Standalone 클러스터 매니저를 실행시키면 된다.

Hadoop YARN Web UI

hadoop mapReduce 뿐만 아니라 클러스터 환경에서 구동 가능한 다양한 Application 플랫폼을 지원합니다. Spark을 포함하여 Hive, HBase, Presto, Flink 등이 있다

Spark 개요 (Spark vs. MapReduce)

Hadoop - on Disk .... Limitations

맵리듀스는 기본적으로 HDFS에서 데이터를 읽어 연산 처리 후 그 결과를 다시 HDFS에 기록합니다. 데이터 연산은 Map 과 Reduce 라는 2개의 스테이지로 구분되어 처리됩니다. 필요한 데이터 처리를 위해 이러한 Map과 Reduce작업을 반복하게 됩니다. 데이터 처리 결과를 HDFS에 Write할때 데이터는 복제되고 직렬화 되며 기본적인 Disk IO가 발생하기에 다소 느린편이다. 머신러닝, 그래프, 네트워크 분석과 같은 반복적인 연산을 필요로 하는 알고리즘을 처리하는데 있어서는 HDFS에서 데이터를 읽고 쓰는 MapReduce 작업을 반복해야 하기에 다소 비효율적인 처리방식이라 볼 수 있다. 대화영 데이터 마이닝 작업에도 그리 효율적이지 않다.

Spark - Solutions ? In Memory + DAG ...

Spark은 반복적으로 사용하게 될 데이터를 메모리에 캐시 하여 디스크보다 빠르게 재사용할 수 있음. 디스크보다 10 ~ 100배정도 더 빠르다고 말함(참고용) Spark은 데이터를 처리하는 방식도 Map과 Reduce라는 2개의 스테이지로 얽메이지 않음. flatMap, filter, map, reduceByKey 다양한 상위레벨 API를 체인과 같이 연속적으로 사용하여 원하는 만큼 데이터에 대한 연산을 처리할 수 있다.

Spark vs Hadoop - Speed (1/3)

Spark vs Hadoop - Speed (2/3)

Spark vs Hadoop - Speed (3/3)

Spark vs Hadoop - Ease of Use (1/2)

Hadoop MapReduce는 자바 언어를 이용하여 객체지향 방식의 코드로 작성해야한다. Spark은 Scala, Java, Python, R과 같은 언어 기반으로 Spark이 제공하는 다양한 API를 사용하여 함수형 방식으로 코드를 작성하기에 상당히 간결한 코드를 유지할 수 있다.

Spark vs Hadoop - Ease of Use (2/2)

Spark은 기본적인 MapRduce를 포함하여 filter, group, join, sort 등 80여기 이상 다양한 연산을 위한 상위레벨 API를 통해 상대적으로 더 적은 노력만으로 원하는 데이터처리 코드를 보다 쉽게 작성 할 수 있다.

2022. 08. 08(월) Python 공부 11일차

Mon, 08 Aug 2022 01:20:24 GMT

함수의 이해 및 사용 (Lambda 함수의 이해)

Lambda 함수 이해 및 사용

Lambda 함수
- 단일문으로 표현되는 익명 함수
- 익명함수란 이름이 없는 구현체만 존재하는 간단한 함수를 의미
- 코드 상에서 한번만 사용되는 기능이 있을 때, 굳이 함수로 만들지 않고 1회성으로 만들어서 쓸 때 사용
```
#### Lambda 함수
```

이 함수를 한 줄로 쓰는게 Lambda 함수이다. 중요한건 return을 쓰면 안된다.

def square2(x): return x ** 2

square = lambda x: x ** 2 print(square(5)) # 25

파라미터가 2개 일 때

def add(x, y): return x + y

add2 = lambda x, y: x + y print(add2(10, 20)) # 30

문자열 길이에 따라 정렬하고 싶을 때

def str_len(s): return len(s)

strings = ['bob', 'charles', 'alexander3', 'teddy']

기본적인 sort는 알파벳순서로 정렬을 하는데 key 파라미터를 이용하면 원하는 형태로 정렬이 가능하다.

strings.sort(key=str_len)

함수를 생성해서 파라미터로 넣어도 되지만 람다함수를 이용하면 바로 간단하게 넣을 수 있다.

strings.sort(key=lambda s: len(s))

print(strings)


#### filter, map, reduce
  - lambda가 유용하게 사용되는 3가지 대표적 함수
  - 함수형 프로그래밍의 기본 요소이기도 함
  - filter : 특정 조건을 만족하는 요소만 남기고 필터링
  - map : 각 원소를 주어진 수식에 따라 변형하여 새로운 리스트를 반환
  - reduce : 차례대로 앞 2개의 원소를 가지고 연산. 연산의 결과가 또 다음 연산의 입력으로 진행됨. 따라서 마지막까지 진행되면 최종 출력은 한개의 값만 남게 됨.
```python
#### filter, map, reduce
# filter(함수, 리스트)
def even(n):
    return n % 2 == 0


nums = [1, 2, 3, 6, 8, 9, 10, 11, 13, 15]

# print(list(filter(even, nums)))  # [2, 6, 8, 10] ## 람다 함수를 안썼을 때
print(list(filter(lambda n: n % 2 == 0, nums)))  # [2, 6, 8, 10]

# map(함수, 리스트)
# 주어진 리스트, 리스트의 제곱을 한 숫자로 새로운 리스트
nums = [1, 2, 3, 6, 8, 9, 10, 11, 13, 15]
print(list(map(lambda n: n ** 2, nums)))  # [1, 4, 9, 36, 64, 81, 100, 121, 169, 225]

# reduce

import functools

# functools.reduce(함수, 리스트)
a = [1, 3, 5, 8]

print(functools.reduce(lambda x, y: x + y, a))  # 리스트 내의 모든 수의 합 # 17
print(functools.reduce(lambda x, y: x * y, a))  # 리스트 내의 모든 수의 곱 # 120

함수 연습문제

1. 주어진 숫자 리스트의 평균을 구하는 함수를 출력하시오
1. 해당 숫자가 소수인지 아닌지 판별하시오.
1. 2부터 해당 숫자사이에 소수가 몇개인지 출력하는 함수를 구하시오

#### 함수 연습문제
# 1. 주어진 숫자 리스트의 평균을 구하는 함수를 출력하시오
# 입력: 숫자 리스트
# 출력: 숫자 리스트의 평균값

def mean(nums):
    _sum = 0
    for i in nums:
        _sum += i
    return _sum / len(nums)


def mean2(nums):
    # sum 내장 함수로 대체 가능
    # _sum = 0
    # for i in nums:
    #    _sum += i
    return sum(nums) / len(nums)


print(mean([1, 2, 3]))  # 2.0
print(mean2([1, 2, 3, 4, 5]))  # 3.0
print(mean([1, 2, 3.0, 3.9, 8.7]))  # 3.72


# 2. 해당 숫자가 소수인지 아닌지 판별하시오.
# 소수 판별 (1과 자기 자신으로만 나눠지는 수)
# 입력: 양의 정수 1개
# 출력: boolean (소수: True, 합성수: False)

# 관례 : 함수에서 True, False를 반환시킬땐 변수명 앞에 is_를 붙힌다.
def is_prime(num):
    for i in range(2, num):
        if num % i == 0:
            return False
    return True


print(is_prime(89))  # True 소수
print(is_prime(100))  # False 합성수


# 3. 2부터 해당 숫자사이에 소수가 몇개인지 출력하는 함수를 구하시오
# 2, 3, 4, 5, 6, 7 -> 4
# 2, 3, 4, 5 -> 3
# 입력: 양의 정수 1개
# 출력: 2 ~ 해당 숫자 사이의 소수의 개수

def num_prime(num):
    count = 0
    for i in range(2, num + 1):
        if is_prime(i):
            count += 1
    return count


print(num_prime(7))     # 4
print(num_prime(5))     # 3
print(num_prime(100))   # 25

파이썬 모듈

모듈의 이해 및 사용과 import 방법

모듈 임포트

그동안 사용했던 함수들 처럼, 다양한 기능들이 미리 함수로 구현되어 모듈 형태로 제공
대표적으로 추후 과정에서 사용하게 될 아래의 모듈들이 존재
requests - HTTP 요청/응답 모듈
numpy - 수치해석 모듈
pandas - 데이터 분석 모듈

import

import를 사용하여 해당 모듈 전체를 import

#### import
# import를 사용하여 해당 모듈 전체를 import
import math

print(math.pi) print(math.cos(100))

#### from import
- 해당 모듈에서 특정한 타입만 import
```python
#### from import
# 해당 모듈에서 특정한 타입만 import
from math import pi
from math import cos
print(pi)
print(cos(100))

* 임포트

해당 모듈내에 정의된 모든 것을 import

일반적으로 사용이 권장되지 않음

#### * 임포트
# 해당 모듈내에 정의된 모든 것을 import
# 일반적으로 사용이 권장되지 않음
from math import *
print(sin(100))
print(e)

as

모듈 import 시, alias(별명) 지정가능

#### as
# 모듈 import 시, alias(별명) 지정가능
import math as m
print(m.exp(3))
print(m.cos(100))

```

모두를 위한 딥러닝 - ML Lec 11

Sun, 07 Aug 2022 13:04:35 GMT

lec11-1 ConvNet의 Conv 레이어 만들기

'The only limit is your imagination'

전체가 연결되어있다고 해서 FC 풀릿 커넥티드

입력을 여러개로 나눈다음 하나로 합치고 앞으로 내보내는걸 생각해볼 수 있는데 컴포셔널 뉴럴 네트워크 - CNN

preview

하나의 이미지가 있게 되면 이미지를 잘라서 넘기게되는데 이 창을 컴보셔널레이어 라고 한다.

중간에 RELU창을 넣고 중간에 POOL을 넣고 반복하면서 마지막에 풀릿 커넥티드를 한다

Start with an image (width * hight * depth)

32x32x3 의 이미지를 가지고 있다고 가정해보자

Let's focus on a small area only

고양이 실험에서 한 것 처럼 전체 이미지를 하나의 입력으로 받지않고 이미지 일부분만 처리하고 싶을때 여기서 처리한다는것을 필터라는 개념을 가지고 설명한다

Let's focus on a small area only (5 * 5 * 3)

색깔은 항상 같이 처리해서 끝에 3은 같다 필터는 항상 5 x 5 에 해당되는 값들 읽어들임

Get one number using the filter

필터는 궁극적으로 한 값을 만들어 낸다. 5, 5를 x라 했을때 x를 입력받아서 어떤 처리를 한 다음에 한 점만 뽑아 낸다.

Get one number using the filter

처음부터 많이 얘기했던 Wx + b 라는 폼을 사용한다. 무슨 이야기냐면 x값이 5개가 있다 가정했을 때 가설을 계산했던 식 처럼 계산하면 된다.

Let's look at other areas with the same filter (w)

그러면 이것을 가지고 이 똑같은 필터 w의 값은 같을 때 다른부분의 이미지도 보아야 한다

A closer look at spatial dimensions

한 칸씩 옆으로 움직일 때 이 값을 Stride 라고 부른다 Stride:1일땐 한칸씩 2일땐 2칸씩 움직인다는 뜻으로 보면 된다.

Stride: 2일때 3x3의 output이 생김

전반적으로 봤을 때 n x n 의 입력이 있다고 했을 때 필터 사이즈를 F 라 했을 때 총 몇개의 값이 뽑아 질 수 있을 것인가?

In practice: Common to zero pad the border

보통 실제적으로 사용할 때 Pad이란 개념을 사용한다. 테두리에다가 0으로 감싸는 하나의 입력을 가상적으로 있다고 만들어주는 것이다. 그림이 급격하게 작아지는것을 방지하기 위함이고, 다른 하나는 모서리다 라고 어떤형태로든 알려주고싶어서

그래서 padding을 해서 입력의 이미지와 출력의 이미지가 같아지게 만들어주는 것을 일반적으로 사용하고 있다.

Swiping the entire image

Convolution layers

lec11-2: ConvNet Max pooling 과 Full Network

Pooling layer (sampling)

pooling이라는건 간단하게 볼때 샘플링이라고 하면 된다 깊이는 몇개의 필터를 쓰느냐에 따라서 달라진다. 사이즈를 작게 만드는것을 풀링이라 한다

MAX POOLING

4 x 4 라는 이미지가 있을때 MAX POOL 하면 2 x 2 가되는데 그 4 x 4 이미지의 값들 중에서 제일 큰값만 따로 빼서 2 x 2 샘플링을 하면 된다.

Fully Connected layer (FC layer)

lec11-3 ConvNet의 활용예

Case Study : AlexNet

알렉스넷에서 렐루를 처음 만들어서 사용했었다.

Case Study: GoogLeNet

Inception module : 어지럽다ㅏㅏㅏㅏㅏㅏ

Case Study: ResNet

에러율 3.6%로 떨군 유명한 Case

알렉스넷이였을땐 8개의 레이어를 사용했는데 ResNet은 152개의 레이어를 사용했다.

CNN for Sentence Classification

2014년도에 윤 김 박사님께서 CNN을 가지고 자연어 처리

모두를 위한 딥러닝 - ML Lec 10

Fri, 05 Aug 2022 05:41:02 GMT

lec10-1: Sigmoid 보다 ReLU가 더 좋아

Let's go deep & wide !

W1 = [2, 5] => x의 갯수가 2개, 출력하고 싶은 갯수 = 5개 W2 = [5, 4] => W1에서 출력한 갯수를 받아와야하니 x의 갯수가 5개, 출력하고 싶은거 4개 W3 = [4, 1] => W2에서 출력한 갯수를 받아와야하니 x의 갯수가 4개, 출력하고 싶은거 1개

9 hidden layers!

처음과 마지막만 신경 쓰면 된다!

텐서보드를 이용해서 시각화 하고싶을 때

Tensorboard visualization

Poor results?

코스트 값이 떨어지지 않고 Accuracy가 0.5밖에 되지가 않는다? 왜 이러는거지?

Tensorboard Cost & Accuracy

방금 생긴 문제를 텐서보드를 활용해서 그래프로 나타내보았다

Backpropagation

2단 3단 그래프정도는 잘 학습이 되는데 10단 이상정도의 그래프는 학습이 안된다

lec 9-2 : Backpropagation (chain rule)

Vanishing gradient (NN winter2: 1986-2006)

기울기가 사라지는 문제이다. 그림으로 보면 앞단에 있는 경사나 기울기는 나타나는데 그러나 단수가 깊어 질수록 경사도가 사라져 버린다

Sigmoid!

0보다 작을경우 버리고 0보다 클 경우 갈때가지 가

ReLU: Rectified Linear Unit

기존에 시그모이드 함수 있던곳에 렐루 함수를 넣으면 된다!

ReLu

마지막 단은 시그모이드를 써야하는데 마지막 단의 출력은 0~1사이여야 하기 때문에

Works very well

학습이 잘 되는것을 볼 수 있다.

lec10-2: Weight 초기화 잘해보자

Cost function

ReLu를 두번 실행시키면 그래프의 값이 좀 다르게 나온다 그 이유는 실행 시킬때 W를 랜덤값으로 줘서 그런거임

Set all initial weights to 0

W값을 다 0으로 줘버린다면.. x의 값들을 계산을 다 하더라도 결국 w를 곱해야하는데 w가 0이 되버린다면 결과적으로 0이 나와서 안된다

Need to set the initial weight values wisely

Not all 0's
Challenging issue
Hinton et al. (2006) "A Fast LearningAlgorithmforDeep Belief Nets"
- Restricted Boatman Machine(RBM)

Good news

No need to use complicated RBM for weight initializations
Simple methods are OK
- Xavier initialization: X. Glorot and Y. Bengio, "Understandingthe difficulty of training deep feedforwardneural networks," in International conference on artificialintelligence and statistics, 2010
- He's initialization: K. He, X. Zhang, S. Ren, and J. Sun, "Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification," 2015

Xavier/He initialization

Still an active area of research

We don't know how to initialize perfectweight values, yet
Many new algorithms
- Batch normalization
- Layer sequential uniform variance
- ...

lec10-3: Dropout 과 앙상블

Overfitting

Am I overfitting?

Very high accuracyon the training dataset (eg:0.99)
Pooraccuracy on the test dataset (0.85)

파란색 선이 training error 빨간색 선이 test error y축이 acc x축이 w를 몇개를 사용했는지 하는 Layer

Solutionsfor overfitting

딥러닝에서는 굳이 features의 수를 줄일 필요는 없다

Regularization

Dropout: A Simple Way to Prevent Neural Networks form Overfitting [Srivastavaet al. 2014]

랜덤하게 몇개의 노드를 죽여보자 라고 얘기 나온게 Dropout

Waaaait a second... Howcould this possiblybe agood idea?

랜덤하게 노드를 죽여서 쉬게 만든 다음 학습시키고 마지막에 총동원해서 예측을 하니 더 잘된다

TensorFlow implementation

텐서플로우에서는 tf.nn.dropout로 랜덤하게 죽이는 메소드가 있다. 무조건 학습할때만 드랍아웃을 시키고 테스팅을 할땐 시키지말아야한다

What is Ensemble?

lec10-4: 레고처럼 넷트웍 모듈을 마음껏 쌓아 보자

Fast forward

Split & merge

Recurrent network

'The only limit isyour imagination'

2022. 08. 05(금) Spark & Hadoop 초격차 10일차

Fri, 05 Aug 2022 04:54:39 GMT

두번째 MapReduce - Sorting

추가 된 소스

public static class TopKMapper extends Mapper {
        // Key값을 기준으로 정렬이 되어있는 맵
        private TreeMap topKMap = new TreeMap<>();

        @Override
        protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            String[] columns = value.toString().split("\t");
            topKMap.put(Double.parseDouble(columns[1]), new Text(columns[0]));

            if (topKMap.size() > K) {
                topKMap.remove(topKMap.firstKey());
            }
        }

        @Override
        protected void cleanup(Context context) throws IOException, InterruptedException {
            for (Double k : topKMap.keySet()) {
                // 맵의 아웃풋으로 평점이 키로 출력이 되고, 두번째로 영화제목이 출력이 된다
                context.write(new Text(k.toString()), topKMap.get(k));
            }
        }
    }

    public static class TopKReducer extends Reducer {
        private TreeMap topKMap = new TreeMap<>();

        @Override
        protected void reduce(Text key, Iterable values, Context context) throws IOException, InterruptedException {
            for (Text value : values) {
                topKMap.put(Double.parseDouble(key.toString()), new Text(value));
                if (topKMap.size() > K) {
                    topKMap.remove(topKMap.firstKey());
                }
            }
        }

        @Override
        protected  void cleanup(Context context) throws IOException, InterruptedException {
            // 내림차순 키값으로 가져와서 처리
            for (Double k : topKMap.descendingKeySet()) {
                context.write(topKMap.get(k), new Text(k.toString()));
            }
        }
    }

    @Override
    public int run(String[] args) throws Exception {
        Job job = Job.getInstance(getConf(), "MovieAverageRateTopK First");
        job.setJarByClass(MovieAverageRateTopK.class);
        job.setReducerClass(MovieRatingJoinReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        MultipleInputs.addInputPath(job, new Path(args[0]), TextInputFormat.class, MovieMapper.class);
        MultipleInputs.addInputPath(job, new Path(args[1]), TextInputFormat.class, RatingMapper.class);

        FileOutputFormat.setOutputPath(job, new Path(args[2]));

        int returnCode = job.waitForCompletion(true) ? 0 : 1;

        // 정상적으로 완료가 됐을 시
        if (returnCode == 0) {
            Job job2 = Job.getInstance(getConf(), "MovieAverageRateTopK Second" );
            job2.setJarByClass(MovieAverageRateTopK.class);
            job2.setMapperClass(TopKMapper.class);
            job2.setReducerClass(TopKReducer.class);
            job2.setNumReduceTasks(1);
            job2.setOutputKeyClass(Text.class);
            job2.setOutputValueClass(Text.class);

            FileInputFormat.addInputPath(job2, new Path(args[2]));
            FileOutputFormat.setOutputPath(job2, new Path(args[3]));

            return job2.waitForCompletion(true) ? 0 : 1;
        }
        return 1;
    }

두번째 MapReduce - Unit Test

추가된 소스

/** 두번째 MapReduce - Unit Test */
    @Test
    public void topKMapTest() throws IOException {
        // withOutput 위치를 바꿀 시 에러가 뜸 즉, 출력순서가 뒤바뀜
        // 작은 순서부터 실행이 되야 하는데 순서가 뒤바뀌면서 큰 순서부터 되버려서 에러가 생김
        new MapDriver()
                .withMapper(new MovieAverageRateTopK.TopKMapper())
                .withInput(new LongWritable(0), new Text("Toy Story (1995)\t4.25"))
                .withInput(new LongWritable(1), new Text("Jumanji (1995)\t3.5"))
                .withOutput(new Text("3.5"), new Text("Jumanji (1995)"))
                .withOutput(new Text("4.25"), new Text("Toy Story (1995)"))
                .runTest();
    }

    @Test
    public void topKReduceTest() throws IOException {
        // 여기도 출력 결과의 순서가 중요함. 여긴 높은 평점부터 낮은평점순으로 순서가 되야 함.
        new ReduceDriver()
                .withReducer(new MovieAverageRateTopK.TopKReducer())
                .withInput(new Text("3.5"), Arrays.asList(new Text("Jumanji (1995)")))
                .withInput(new Text("4.25"), Arrays.asList(new Text("Toy Story (1995)")))
                .withOutput(new Text("Toy Story (1995)"), new Text("4.25"))
                .withOutput(new Text("Jumanji (1995)"), new Text("3.5"))
                .runTest();
    }

영화 평점 Top 30 실행

명령어를 통해 코드 실행

실행 결과 1

실행 결과 2

잘 작동되는걸 확인 할 수 있다.

2022. 08. 05(금) Python 공부 10일차

Fri, 05 Aug 2022 01:27:31 GMT

조건문 & 반복문 연습문제

if & for 연습문제

# 1번 문제 : 구구단을 2 - 9단까지 출력하시오
x = 2
while x <= 9:
    y = 1
    while y <= 9:
        print(x, 'x', y, '=', x * y)
        y += 1
    x += 1

# 2번 문제 : 1 - 100까지 정수 중 2의 배수 또는 11의 배수를 모두 출력하시오
nums = list(range(1, 101))
for x in nums:
    if x % 2 == 0 or x % 11 == 0:
        print(x)

# 3번 문제 : a = [22, 1, 3, 4, 7, 98, 21, 55, 87, 99, 19, 20, 45] 에서 최대값과 최소값을 찾으시오. (sorted, sort 사용 금지)

# sort 함수(정렬)을 사용한 경우
a = [22, 1, 3, 4, 7, 98, 21, 55, 87, 99, 19, 20, 45]
a.sort()
a[0], a[-1]

# 최대 최소 동시에
_min = a[0]
_max = a[0]
for x in a:
    if x < _min:
        _min = x
    if x > _max:
        _max = x

print(_min, _max)


# 4번 문제 : a = [22, 1, 3, 4, 7, 98, 21, 55, 87, 99, 19, 20, 45] 에서 평균을 구하세요.

# while
i = 0
_sum = 0
while i < len(a):
    _sum += a[i]
    i += 1

print(_sum / len(a))

# for
_sum = 0
for x in a:
    _sum += x

print(_sum / len(a))

함수의 이해 및 사용

함수?

지금까지 무심코 코드에서 사용된 많은 함수들이 존재 합니다.
예를들면, sum, len, range 같은 함수 등이 있죠.
함수란 우리가 알고있는 개념처럼 주어진 입력(input)에 대해서 의도된 출력(output)를 전달하는 역할을 합니다.
그렇다면 하나씩 살펴보겠습니다.
- range 함수는 정수를 입력으로 전달하면 [0, 정수) 로 이루어진 리스트를 생성하는 역할을 합니다.
- sum 함수는 리스트, 튜플등을 입력으로 전달하면 전체 아이템의 합을 출력으로 전달하는 역할을 합니다.
- len 함수는 리스트, 튜플 등을 입력으로 전달할하면 아이템의 개수를 출력으로 전달하는 역할을 합니다.
그리고, 위의 함수들은 모두 python 내부에 이미 정의(구현)이 되어 있습니다.
위와 같은 함수를 내장함수(built-in function)이라고 합니다.
```
### 함수?
```

내장 함수의 예

a = [1, 2, 3, 4] length = len(a) print(length)

summation = sum(a) print(summation)



#### 함수의 정의
- 정의 시 최초에 def 키워드 사용
- argument 정의 (함수에 입력으로 전달하는 값을 의미, argument 또는 parameter라고 함)
- : (콜론) -> 함수 역시 코드 블록이기 때문에 콜론(:) 필요
- body (함수의 구현 부분, 함수 역시 코드 블록이기 떄문에 들여쓰기 된 부분까지 함수의 코드블록으로 인지함)
  - 함수를 호출한 코드 (caller)로 함수가 해당 기능을 수행하고 완료된 값(output)을 전달하기 위해 return 키워드 사용
  - 즉, return 이후에 오는 값을 caller로 전달
- 함수의 네이밍 역시 중요
  - 즉, 어떤 기능을 하는 함수인지 이름으로 최대한 나타날 수 있게 해야함
  - e.g) get_a (x) get_student_name (o)
  ```python
  #### 함수의 정의
  def add(x, y):
      n = x + y
      return n

  c = add(30, 300)
  print(c)

함수의 사용(호출)

함수명(파라미터1, 파라미터2, ... 파라미터n)
위와 같이 정의 된 함수의 이름과 전달되는 parameter(인자)를 괄호안에 전달하여 함수를 호출
함수가 호출되면 실행의 흐름이 호출자(caller)에서 함수(callee)로 변경 됨
함수의 입력(인풋) 파라미터(parameter), 아규먼트(argument)라고도 함
```
#### 함수의 사용(호출)
d = add(30, 40)
print(d)
```

함수 네이밍(naming)

함수 이름으로부터 기능이 명시

의미와 반대되거나 맞지 않는 이름은 사용 금지

#### 함수 네이밍(naming)
# 의미에 맞지않는 함수명은 사용하지 말자
def substract(x, y):
  sub = x - y
  return sub

print(substract(4, 3))


#### parameter(argument) (인자)
- 함수에 전달되는 입력(input)
- 입력이 필요하지 않을 수도, 1개의 입력만 있을 수도, 여러개의 입력이 존재할 수도 있음
- 파라미터로 int, string, float, boolean, list, dict 등등 어떤 파이썬 객체도 전달 가능
- 심지어 함수도 함수의 파라미터로 전달 가능
- python의 경우, 타입 명시가 없기 때문에, 함수 생성 시, 의도된 파라미터의 타입에 맞게 입력을 전달하는 것이 중요
- 또한 파라미터를 전달 할 때, 정의된 순서에 따라 값을 전달하는 것이 중요
```python
#### parameter(argument)(인자)
def test():
    print('haha')
    print('good')

    return 100

a = test()
print(a)

Default parameter( 기본 인자)

함수의 파라미터에 기본값 지정 가능

파라미터를 명시하지 않을 경우, 지정된 기본값으로 대체

#### Default parameter(기본 인자)
def add2(x, y, z=5):
  a = x + y + z
  return a

add2(10, 20)


- **기본 파라미터의 다른 예**
  - print 함수
    - seq, end, file등 여러 기본 파라미터를 가짐
    ```python
    # 기본 파라미터의 다른 예
    print(1, 2, 3, sep='!', end='%%%')  # 1!2!3%%%
    print(2, 3, 4, sep='p') # 2p3p4
    ```

#### Default parameter 사용 시 주의점
- 디폴트 파라미터 뒤에 일반 파라미터가 위치할 수 없음
- e.g) 올바른 예
  > def test(a, b, c = 1)

  > def test(a, b =1, c = 2)

  > def test(a = 1, b = 1, c = 3)

- e.g) 올바르지 않은 예
  > def test(a, b = 1, c)

  > def test(a = 1, b, c)

  > def test(a = 1, b = 1, c)

![](https://velog.velcdn.com/images/eastgun_/post/c82e226e-9a65-4527-a2b1-c50562651d27/image.png)

#### keyword parameter (키워드 파라미터)
- 파이썬의 경우, 파라미터에 값을 전달 할 때, 파라미터의 이름을 명시하여 전달 가능
- 파라미터 이름을 사용하지 않을 경우, 기본적으로 순서에 맞게 전달

```python
    #### keyword parameter (키워드 파라미터)
    def test(x, y, z):
    a = x + y + z
    return a

    test(x=10, y=50, z=3)   # 63

return (리턴)

기본적으로 함수의 종료를 명시
- return옆에 값이나 수식이 있다면 해당 값을 호출자(caller)에게 반환(전달)
- return만 존재하면 None 반환
- return이 없는 경우, 기본적으로 함수 코드 블록이 종료되면 종료로 간주. 이때도 None 반환
```
  #### return (리턴)
  def weird_multiply(x, y):
    if x > 10:
        return x * y

    print(x + y)
    return (x + 2) * y

  print(weird_multiply(12, 5))

  # 비교
  def weird_multiply2(x, y):
    if x > 10:
        return x * y

  print(weird_multiply2(2, 5))
```

multiple return (복수 값 반환)

tuple반환을 하여 복수개의 값 리턴 가능

#### multiple return (복수 값 반환)
def add_mul(x, y):
  s = x + y
  m = x * y

  return s, m

c = add_mul(20, 3) print(type(c)) print(c)

a, b = add_mul(20, 3) print(a, b)


#### variable scope (변수의 범위)
- 변수가 참조 가능한 코드상의 범위를 명시
- 함수내의 변수는 자신이 속한 코드를 블록이 종료되면 소멸됨
- 이렇게 특정 코드 블록에서 선언된 변수를 **지역변수(local variable)** 이라고 함
- 반대로 가장 상단에서 정의되어 프로그램 종료 전까지 유지되는 변수를 **전역변수(global variable)** 이라고 함
- 같은 이름의 지역변수와 전역변수가 존재할 경우, 지역변수의 우선순위가 더 높음

```python
#### variable scope (변수의 범위)
num1 = 10
num2 = 30

def test(num1, num2):
    print(num1, num2)
    return num1 + num2

test(30, 40)

print(num1, num2)

variable length argument (가변길이 인자)

전달되는 파라미터의 개수가 고정적이지 않은 경우 사용
e.g)
- print 함수
- format 함수
args, *kwargs

*args : 파라미터를 튜플의 형태로 전달

**kwags : 파라미터를 딕셔너리 형태로 전달(네임드 파라미터)

#### variable length argument (가변길이 인자)

# 파라미터를 정의할때 앞에 * 붙이게 되면 그 함수는 호출하는 입장에선 가변길이 함수가 되고 내부적으론 튜플로 인식이 된다.
def test(*x):
    print(type(x))


test(10, 20)


def test_2(*args):  # arguments
    for item in args:
        print(item)


test_2(10, 30, 40)

keyword parameter (키워드 파라미터)

**가 붙은 경우에는 키워드 파라미터로 인식
즉 함수 호출 시, 파라미터의 이름과 값을 함께 전달 가능

#### keyword parameter (키워드 파라미터)
def test2(**kwargs):  # key word arguments
    for key, value in kwargs.items():
        print('key:', key, ', value:', value)

test2(a=1, b=2, c=3, d=4, name='Bob', age=90)

가변길이 함수의 대표적인 예 문자열 포맷 함수
- 여러가지 값과 포맷을 이용하여 문자열을 정의할 수 있는 함수
- {} placeholder를 문자열 내에 위치 시킨 후, 해당 위치에 format함수로 전달된 값으로 대체하여 문자열 생성
- 포맷 구성은 다음 링크 참조 : https://pyformat.info/

# 가변길이 함수의 대표적인 예 **문자열 포맷 함수**

a = '오늘 온도: {today_temp}도, 강수확률은: {today_prob}% 내일온도: {tomorrow_temp}도'.format(tomorrow_temp = 23, today_prob = 40, today_temp = 40)
print(a)

모두를 위한 딥러닝 - ML Lec 09

Thu, 04 Aug 2022 13:57:31 GMT

lec9-1: XOR 문제 딥러닝으로 풀기

One logistic regression unit cannot separate XOR

XOR은 굉장히 간단했지만 초창기 뉴럴 네트워크 전문가들한테는 절망을 안겨다 줬었다

Neural network (NN) "No one on earth had found a viable way to train*"

그 당시에 나왔던 이야기가, 여러가지로 겹치면 풀수가 있지만 각각의 W, b를 어떻게 학습할 수가 있냐 불가능하다 라고 나옴

XOR using NN

XOR의 속성으로는 리니어하게 선을 찾을 수 없다

Neural Net

이 문제를 3개의 네트워크를 가지고 풀어보자

4가지 케이스로 테스트 해봅시다. ( 1번째 케이스)

2번째 케이스

3번째 케이스

4번째 케이스

Forward propagation

각각 계산했던 식을 더 간편하게 작성 , 이게 즉 뉴럴 네트워크

NN

위에 작성했던 식을 더 간단하게 작성

수식어로 써본다면

lec9-x: 특별편: 10분안에 미분 정리하기 (lec9-2 이전에 보세요)

Basic derivative

델타 x를 아주 작은값, 0에 가까운 값으로 보낼 때 f(x)에 델타x를 더한값과 더하지 않는 값으로 해서 뺀걸 델타 x로 나눈다 다른말로 순간 변화율

Partial derivative: consider other variables as constants

f(x, y) = xy, ax/af 에서는 x를 미분으로 쓰고 뒤에 y는 상수취급

상수함수는 미분하면 0이 됨 f(x) = x + x 을 미분하면 2

복합함수 f(g(x))는 ax/af = (ag/af)*(ax/ag)

lec9-2: 딥넷트웍 학습 시키기 (backpropagation)

How can we learn W1, W2, B1, B2 from training data?

Derivation

Backpropagation (1974, 1982 by Paul Werbos, 1986 by Hinton)

Back propagation (chain rule)

간단한 예제를 가지고 어떻게 동작하는지 이해해 보자.

Sigmoid

2022. 08. 04(목) Spark & Hadoop 초격차 9일차

Thu, 04 Aug 2022 01:48:09 GMT

첫 번째 MapReduce - Join

MovieAverageRateTopK

package com.fastcampus.hadoop;

import org.apache.avro.generic.GenericData;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.MultipleInputs;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class MovieAverageRateTopK extends Configured implements Tool {
    public static class MovieMapper extends Mapper {
        private Text movieId = new Text();
        private Text outValue = new Text();

        @Override
        protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            String[] columns = value.toString().split(",");
            if (columns[0].equals("movieId")) {
                return;
            }
            movieId.set(columns[0]);
            outValue.set("M" + columns[1]);
            context.write(movieId, outValue);
        }
    }

    public static class RatingMapper extends Mapper {
        private Text movieId = new Text();
        private Text outValue = new Text();

        @Override
        protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            String[] colums = value.toString().split(",");
            if (colums[0].equals("userId")) {
                return;
            }
            movieId.set(colums[1]);
            outValue.set("R" + colums[2]);
            context.write(movieId, outValue);
        }
    }

    public static class MovieRatingJoinReducer extends Reducer {
        private List ratingList = new ArrayList<>();
        private Text movieName = new Text();
        private Text outValue = new Text();

        @Override
        protected void reduce(Text key, Iterable values, Context context) throws IOException, InterruptedException {
            ratingList.clear();

            for (Text value : values) {
                if (value.charAt(0) == 'M') {
                    movieName.set(value.toString().substring(1));
                } else if (value.charAt(0) == 'R') {
                    ratingList.add(value.toString().substring(1));
                }
            }

            double average = ratingList.stream().mapToDouble(Double::parseDouble).average().orElse(0.0);
            outValue.set(String.valueOf(average));
            context.write(movieName, outValue);
        }
    }

    @Override
    public int run(String[] args) throws Exception {
        Job job = Job.getInstance(getConf(), "MovieAverageRateTopK First");
        job.setJarByClass(MovieAverageRateTopK.class);
        job.setReducerClass(MovieRatingJoinReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        MultipleInputs.addInputPath(job, new Path(args[0]), TextInputFormat.class, MovieMapper.class);
        MultipleInputs.addInputPath(job, new Path(args[1]), TextInputFormat.class, RatingMapper.class);
        return 1;
    }

    public static void main(String[] args) throws Exception {
        int exitCode = ToolRunner.run(new MovieAverageRateTopK(), args);
        System.exit(exitCode);
    }
}

첫 번째 MapReduce - Unit Test

MovieAverageRateTopKTest

package com.fastcampus.hadoop;

import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
import org.apache.hadoop.mrunit.types.Pair;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mrunit.mapreduce.MapDriver;
import org.junit.Test;

import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;

public class MovieAverageRateTopKTest {
    @Test
    public void movieMapTest() throws IOException {
        MapDriver mapDriver = new MapDriver()
                .withMapper(new MovieAverageRateTopK.MovieMapper())
                .withInput(new LongWritable(0), new Text("movieId,title,genres"))
                .withInput(new LongWritable(1), new Text("1,Toy Story (1995),Adventure|Animation|Children|Comedy|Fantasy"))
                .withInput(new LongWritable(2), new Text("2,Jumanji (1995),Adventure|Children|Fantasy"));

        /*List> result = mapDriver.run();
        System.out.println(result);*/

        mapDriver.withOutput(new Text("1"), new Text("MToy Story (1995)"))
                .withOutput(new Text("2"), new Text("MJumanji (1995)"))
                .runTest();
    }

    @Test
    public void ratingMapTest() throws IOException {
        new MapDriver()
                .withMapper(new MovieAverageRateTopK.RatingMapper())
                .withInput(new LongWritable(0), new Text("userId,movieId,rating,timestamp"))
                .withInput(new LongWritable(1), new Text("1,1,4.0,964982703"))
                .withInput(new LongWritable(2), new Text("7,1,4.5,1106635946"))
                .withInput(new LongWritable(3), new Text("8,2,4.0,839463806"))
                .withInput(new LongWritable(4), new Text("18,2,3.0,1455617462"))
                .withOutput(new Text("1"), new Text("R4.0"))
                .withOutput(new Text("1"), new Text("R4.5"))
                .withOutput(new Text("2"), new Text("R4.0"))
                .withOutput(new Text("2"), new Text("R3.0"))
                .runTest();
    }

    @Test
    public void movieRatingJoinReduceTest() throws IOException {
        new ReduceDriver()
                .withReducer(new MovieAverageRateTopK.MovieRatingJoinReducer())
                .withInput(new Text("1"), Arrays.asList(new Text("MToy Story (1995)"), new Text("R4.0"), new Text("R4.5")))
                .withInput(new Text("2"), Arrays.asList(new Text("MJumanji (1995)"), new Text("R4.0"), new Text("R3.0")))
                .withOutput(new Text("Toy Story (1995)"), new Text("4.25"))
                .withOutput(new Text("Jumanji (1995)"), new Text("3.5"))
                .runTest();

    }
}

2022. 08. 04(목) Python 공부 9일차

Thu, 04 Aug 2022 01:18:55 GMT

반복문(while) 활용하기

loop(반복문)

반복적인 작업을 가능하게 해주는 도구
특정 조건을 만족하는 경우 수행할 수 있음(while)
리스트, 문자열, 튜플 등 컬렉션 타입의 아이템을 하나씩 순회하면서 사용 가능 (for)
코드 작업에서, 가장 많이 사용하는 구문 중 하나
주의할점: while을 사용할 경우, 반복을 멈추게 하는 장치가 필요
- 그렇지 않으면 셀이 무한히 수행되며, jupyter notebook의 재부팅이 필요

while 키워드

while 뒤의 조건이 True일 경우, while 코드 블록을 계속 수행
while 코드 블록
- if와 마찬가지로 while문 아래의 들여쓰기로 작성 된 부분을 의미
조건이 False가 되면 블록 수행을 멈추고 이후 코드를 수행

while 키워드 이용하여 리스트의 아이템 출력하기

    a = [1, 10, 9, 24, 566, 23, 45, 67, 89]
    i = 0 # 인덱스

    while i < len(a):
        print(a[i])        # 1 10 9 24 566 23 45 67 89
        i += 1

조건문과 함께 사용하기

  a = [1, 10, 9, 24, 566, 23, 45, 67, 89]
  i = 0 # 인덱스

  while i < len(a):
      if a[i] > 20:
          print(a[i])        # 24 566 23 45 67 89
      i += 1

무한 루프

while의 경우 종료가 되지 않도록 코드를 작성하면 블록에서 빠져나올 수 없음

    while True: # 무한 루프
        print('haha')

break

loop를 중단할 때 사용
보통 조건문 안에서 수행되며, 조건을 만족하는 경우 loop를 탈출하기 위해 사용

loop를 중단 하는 경우, while 이후의 코드를 수행

  a = [1, 10, 9, 24, 566, 23, 45, 67, 89]

  i = 0
  while i < len(a):
      if a[i] > 20:
          break
      print(a[i])        # 1 10 9
      i += 1

continue

break 처럼 반복을 중단하여 빠져나오진 않고, 다시 while 조건으로 점프함

특정한 경우에는 코드를 수행하지 않고 다음으로 건너 뛰기 위해 사용

  a = 7
  while a > 0;
      a -= 1
      if a == 5:
          continue
      print(a)    # 6 4 3 2 1

반복문(for) 활용하기

리스트, 문자열 등등 순회 가능한 객체를 순회하면서 값을 처리할 때 사용
아래와 같은 문법으로 사용
여기서 i는 매번 수행 될 때마다, a의 아이템으로 순차적으로 변경 됨

모든 아이템이 순회되면 for 블록 종료

  a = [1, 2, 3, 4, 5]
  for i in a:
      print (i, i * 2)

#### 문자열의 아이템 출력하기
- 문자열의 경우 순회 가능, 리스트의 유사하게 순회 가능
```python
    a = 'hello world'
    for character in a:
        print(character)

리스트 아이템 출력하기

    a = [1, 10, 3, 4, 5]
    for num in a:
        if num % 2 == 0:
            print(num/2)
        else:
            print(num+1)


    2
    5.0
    4
    2.0
    6

dict의 아이템 출력하기

dictionary의 경우 기본적으로 순회 하게 되면 key값을 참조
keys() 함수를 이용하여 key 값만 순회 가능
values() 함수를 이용하여 value 값만 순회 가능

items() 함수를 이용하여 tuple형태로 key, value 순회 가능

  a = {'korea' : 'seoul', 'japan' : 'tokyo', 'canada' : 'ottawa'}
  for key in a:
      print(key)
  korea
  japan
  canada

  for value in a.values():
      print(value)

  seoul
  tokyo
  ottawa

  for key, value in a.items():
      print(key, value)

  korea seoul
  japan tokyo
  canada ottawa

for에서 index 사용하기

기본적으로 for에 리스트를 순회하는 경우, 값만 추출 함
아래와 같은 코드로 인덱스와 값 모두 사용 가능(enumerate 함수 이용)
```
  a = [1, 2, 3, 4, 5]
  for index, num in enumerate(a):
      print(index, num)
```


#### break
- for의 경우에도 특정 조건일 때, loop 종료가 가능
```python
    a = [100, 90, 80, 70, 60, 50]
    for num in a:
        if num < 80:
            break
        print(num)

    100 
    90
    80

continue

해당 아이템을 건너 뛰고 싶을 때 사용

  a = [100, 90, 80, 70, 60, 50]
  for num in a:
      if num >= 60 and num <= 70:
          continue
      print(num)    

  100
  90
  80
  50

loop 중첩

반복문의 경우에도 중첩하여 사용 가능
중첩이라는 것은 반복문 블록의 코드안에 또 반복문의 코드가 작성되는 것을 의미
이런 경우, 내부 루프는 외부 루프가 수행되는 만큼 반복 수행 됨

또한 중첩의 경우 무한히 가능

  a = [1, 2, 4]
  for i in a:
      for j in a:
          print (i * j)

  1
  2
  4
  2
  4
  8
  4
  8
  16

구구단 출력하기

  x = [2, 3, 4, 5, 6, 7, 8, 9]
  y = [1, 2, 3, 4, 5, 6, 7, 8, 9]

  for i in x:
      for j in y:
          print(i, 'x', j, '=', i+j)

collection의 길이

len() 내장함수로 계산 가능
내장함수란 팡썬 내부에 구현되어 있어서, import하지 않고도 사용 가능한 함수를 의미
abs, len, type, range 등이 있음 (과정 진행하면서 필요할 때마다 다룰 예정)
```
  a = [1, 2 ,3, 4, 5, 1]
  len('hello world')
  11
```

range 함수

리스트를 쉽게 만들 수 있는 내장함수
주어진 값에 따라 다양한 결과를 반환
1 ~ 100까지의 리스트 생성하기
```
  a = list(range(1, 101))
```

- 연습문제 1부터 100사이의 5의 배수만을 갖는 리스트를 생성하시오
```python
    list(range(1, 101, 5))

모두를 위한 딥러닝 - ML Lec 08

Wed, 03 Aug 2022 05:36:47 GMT

lec 08-1: 딥러닝의 기본 개념: 시작과 XOR 문제

Ultimate dream: thinking machine

뇌가 굉장히 복잡하게 연결되어있다에 놀랍고, 연결된 부분부분들을 자세히 봤더니 Neuron이라 불리는 유닛이 너무 단순하게 동작이 되더라

Activation Functions

뉴런을 수학적으로 만든것이 Activation Functions x의 값을 w랑 곱하고 곱한 값들을 다 더하고 어떤 bias라는 값으로 합한다. 그런다음에 activation function이라는게 있어서 이 합한 값이 어떤 일정 값을 넘어가면 1이라는 신호를 주고 안넘어가면 0 신호를 준다.

Logistic regression units

Hardware implementations

이 기계를 직접 만들었었다.

False Promises

58년도 기사를 보면 "우리가 이런것을 만들어 냈는데 이것이 곧 스스로 학습해서, 걷기도 할 수있고, 말도하고, 볼수도 있고, 글도 쓰고, 자기생산, 더 가관인것은 자기존재를 인식하게 된다" 라고 말했었음

(Simple)AND/OR problem: linearly separable?

or은 x1의 값과 x2의 값이 00 이면 -0 01 10이면 1이고 11이면 1인 형태 and는 00 01 10이면 -0이고 11일때 1인 형태

(Simple)XOR problem : linearly separable?

XOR은 00, 11일때 0, 01 10일때 1이 된다. XOR은 리니어하게 선을 그어도 절대 구분을 할수가 없다.

Perceptrons(1969) by Marvin Minsky, founder of the MIT AI Lab

이 책에서는 당시 년도에서는 XOR을 풀 수 없다라고 함

"No one on earth had found a viable way to train*"

그리고 이런 레이어에서 즉 다시 강조한것이 "아무도 못한다"라고 얘기함

Backpropagation(1974, 1982 by Paul Werbos, 1986 by Hinton)

86년도가 되면서 문제가 해결이 됌 Backpropagation 알고리즘은 "뒷부분에서 에러를 구해서 이걸 뒤로 전달해나가면서 각각 진행시켜나가면 어떨까?" 에서 시작됐다.

Convolutional Neural Networks

고양이에게 그림을 보게 한 다음에 시신경에 있는 뉴런이 어떻게 동작하는지 봤는데 그림의 형태에 따라 일부의 뉴런만 활성화되고 다른그림을 주면 다른 뉴런이 활성화되는것을 발견함

그림을 한번에 다 학습시키는게 아니라 부분부분 보내서 나중에 합치는 네트워크를 개발하게 되었다.

A BIG problem

Backpropagation 알고리즘도 곧 큰 문제에 봉착하게 된다. 이 문제는 에러를 구해서 앞으로 보내게 될때 갈수록 신호가 약해지게 되면서 Layer가 많을수록 에러가 거의 전달되지 않고 학습을 시킬 수 없게 돼 성능이 떨어지게 되었다.

lec 08-2: 딥러닝의 기본 개념2: Back-propagation 과 2006/2007 '딥'의 출현

CIFAR

훌륭한 단체, 캐나다에서 세운 연구소인데 연구소를 세우면서 당장 돈이 되고 활용도가 높지 않아도 연구하라고 밀어준 단체이다. 이렇게 되면서 뉴럴 네트워크 전문가였던 Hinton은 캐나다로 이민을 갔다

"Everyone else was doing something different"

CIFAR 단체 덕분에 딥러닝이 개발 된듯???

2006/2007 년도에 Hinton 교수와 Bengio 교수님이 큰 Breakthrough가 되는 두 논문을 발표하게 된다.

초기값을 잘 선택한다면 학습할 수 있다는게 2006 논문 2007 논문에서는 한걸음 더 나아가서 신경망을 구축하면 굉장히 복잡한 문제를 풀 수 있다.

정말 주목을 받게된 계기

2012년에 모두를 깜짝 놀랄만한 논문이 발표되었는데 Hiton 교수 밑에 있는 Alex 박사과정 학생이 26%오류를 15%로 떨구게 되는 논문을 발표 했다

Neural networks that can explain photos

그림을 설명할 수 있게 됨

Deep API Learning*

Speech recognition errors

바이두에서는 노이즈가 많은 환경에서도 사람의 말을 90% 정도 알아 들을 수 있게 개발함

Geoffrey Hinton's summary of findings up to today

왜 이전에 잘 안됐을까를 4가지정도로 파악했는데 이것은 다음시간에 공부함

Why should I care?

나는 연구자도 아니고 컴공도 아닌데 무슨상관이냐? 이것을 알아두면 굉장히 좋다.

이러한 기술이 이미 사용되고 있다 예로 , 유튜브에 있는 자동 자막 기능이 컴퓨터가 딥러닝으로 자막을 단거다.

ML lab 08: Tensor Manipulation

Simple ID array and slicing

2D Array

행렬쓰 4행 3열

Shape, Rank, Axis

1차원 Array 일 경우 rank = 1, Shape = [4] 2차원 Array 일 경우 rank = 2, Shape = [2, 2] 4차원 Array 일 경우 rank = 4, Shape = [1, 2, 3, 4]

Axis

Axis 같은 경우 제일 안쪽에 있는 값이 큰 값, 바깥쪽으로 나갈경우 작아짐.

Matmul VS multiply

그런데 가끔 matrix 곱을 하지않고 실수로 일반 곱을 했을 경우 matrix곱과 일반 곱의 결과는 다르다.

Broadcasting (@@@WARNING)

Shape이 같아야 단순 덧셈이 가능하다

그런데 Shape이 달라도 연산을 해줄 수 있게 해주는게 Broadcasting 이다

Reduce mean

.reduce_mean은 평균을 구하는데 그것을 하나로 줄여서 구한다? axis의 값이 무엇이냐에 따라서 값이 다르게 나온다.

Reduce sum

axis의 값이 무엇이냐에 따라서 값이 다르게 나온다.

Argmax

Argmax는 axis의 값에 따라 비교를 하면서 크기를 구하는데 구할때 결과값이 value값이 아니라 인덱스 값으로 나오는듯 axis의 값이 무엇이냐에 따라서 값이 다르게 나온다.

reshape** ( 별이 두개! 중요 !)

안에거는 3 앞에는 너 알아서해?! reshape을 할 때 보통 가장 안쪽의 값은 건드리지 않음

Reshape (squeeze, expand)

squeeze는 개별적인 값으로 되어 있을때 하나의 값으로 표현시켜준다? expand는 쉐입을 변경시키는 값?

One hot

Casting

주어진 tensor에서 True, False 값을 0이나 1로

Stack

여러개 변수의 값을 하나로 쌓되 axis의 값에 따라 다르게 쌓아짐

Ones and Zeros like

비슷한 모양이나 똑같은것으로 0또는 1로된 Tensor를 만들고 싶을 때 ones 로 하면 1로 zeros로 하면 0으로

Zip

복수개의 Tensor를 가지고 있을 때 Zip으로 묶어서 한방에 처리 할 때

2022. 08. 03(수) Spark & Hadoop 초격차 8일차

Wed, 03 Aug 2022 04:35:32 GMT

MRUnit을 이용한 Unit Test

wordCountTest

package com.fastcampus.hadoop;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mrunit.mapreduce.MapDriver;
import org.apache.hadoop.mrunit.mapreduce.MapReduceDriver;
import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
import org.apache.hadoop.mrunit.types.Pair;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;

public class WordCountTest {
    MapDriver mapDriver;
    ReduceDriver reduceDriver;
    MapReduceDriver mapReduceDriver;

    @Before
    public void Setup() {
        mapDriver = new MapDriver<>(new WordCount.TokenizerMapper());
        reduceDriver = new ReduceDriver(new WordCount.IntSumReducer());
        mapReduceDriver = new MapReduceDriver<>(new WordCount.TokenizerMapper(), new WordCount.IntSumReducer());
    }

    @Test
    public void wordCountMapTest() throws IOException {
        new MapDriver()
                .withMapper(new WordCount.TokenizerMapper())
                .withInput(new LongWritable(0L), new Text("dog dog cat cat owl cat"))
                .withOutput(new Text("dog"), new IntWritable(1))
                .withOutput(new Text("dog"), new IntWritable(1))
                .withOutput(new Text("cat"), new IntWritable(1))
                .withOutput(new Text("cat"), new IntWritable(1))
                .withOutput(new Text("owl"), new IntWritable(1))
                .withOutput(new Text("cat"), new IntWritable(1))
                .runTest();
    }

    @Test
    public void wordCountMapTest2() throws IOException {
        List> result = mapDriver.withInput(new LongWritable(0L), new Text("dog dog cat cat owl cat"))
                .run();
        System.out.println(result);
    }

    @Test
    public void wordCountReduceTest() throws IOException {
        new ReduceDriver()
                .withReducer(new WordCount.IntSumReducer())
                .withInput(new Text("cat"), Arrays.asList(new IntWritable(1), new IntWritable(1), new IntWritable(1)))
                .withInput(new Text("dog"), Arrays.asList(new IntWritable(1), new IntWritable(1)))
                .withInput(new Text("owl"), Arrays.asList(new IntWritable(1)))
                .withOutput(new Text("cat"), new IntWritable(3))
                .withOutput(new Text("dog"), new IntWritable(2))
                .withOutput(new Text("owl"), new IntWritable(1))
                .runTest();
    }

    @Test
    public void wordCountReduceTest2() throws IOException {
        List> result =  reduceDriver
                .withInput(new Text("cat"), Arrays.asList(new IntWritable(1), new IntWritable(1), new IntWritable(1)))
                .withInput(new Text("dog"), Arrays.asList(new IntWritable(1), new IntWritable(1)))
                .withInput(new Text("owl"), Arrays.asList(new IntWritable(1)))
                .run();

        System.out.println(result);
    }

    @Test
    public void wordCountTest() throws IOException {
        mapReduceDriver
                .withInput(new LongWritable(0L), new Text("dog dog cat cat owl cat"))
                .withOutput(new Text("cat"), new IntWritable(3))
                .withOutput(new Text("dog"), new IntWritable(2))
                .withOutput(new Text("owl"), new IntWritable(1))
                .runTest();;
    }

    @Test
    public void wordCountTest2() throws IOException {
        List> result = mapReduceDriver
                .withInput(new LongWritable(0L), new Text("dog dog cat cat owl cat"))
                .run();
        System.out.println(result);
    }

    @Test
    public void wordCountWithCounter() throws IOException {
        MapDriver mapDriver1 = new MapDriver<>(new WordCountWithCounter.TokenizerMapper());
        mapDriver1
                .withInput(new LongWritable(0L), new Text("'hello' 'world fastcampus hadoop !!'"))
                .run();
        System.out.println(mapDriver1.getCounters().findCounter(WordCountWithCounter.Word.WITHOUT_SPECIAL_CHARACTER).getValue());
        System.out.println(mapDriver1.getCounters().findCounter(WordCountWithCounter.Word.WITH_SPECIAL_CHARACTER).getValue());
    }
}

Mockito를 이용한 Unit Test

wordCountTest With mockito

package com.fastcampus.hadoop;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Counter;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.junit.Test;
import com.fastcampus.hadoop.WordCount.TokenizerMapper;
import org.mockito.InOrder;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;

import static org.mockito.Mockito.*;

public class WordCountTestWithMockito {
    @Test
    public void wordCountMapTest() throws IOException, InterruptedException {
        TokenizerMapper mapper = new TokenizerMapper();
        Mapper.Context context = mock(Mapper.Context.class);
        mapper.word = mock(Text.class);
        mapper.map(new LongWritable(0), new Text("dog dog cat"), context);

        InOrder inOrder = inOrder(mapper.word, context);
        inOrder.verify(mapper.word).set(eq("dog"));
        inOrder.verify(context).write(eq(mapper.word), eq(new IntWritable(1)));
        inOrder.verify(mapper.word).set(eq("dog"));
        inOrder.verify(context).write(eq(mapper.word), eq(new IntWritable(1)));
        inOrder.verify(mapper.word).set(eq("cat"));
        inOrder.verify(context).write(eq(mapper.word), eq(new IntWritable(1)));
    }
    @Test
    public void wordCountReduceTest() throws IOException, InterruptedException {
        WordCount.IntSumReducer reducer = new WordCount.IntSumReducer();
        Reducer.Context context = mock(Reducer.Context.class);

        List values = Arrays.asList(new IntWritable(1), new IntWritable(1));

        reducer.reduce(new Text("dog"), values, context);
        verify(context).write(new Text("dog"), new IntWritable(2));
    }

    @Test
    public void counterTest() throws IOException, InterruptedException {
        WordCountWithCounter.TokenizerMapper mapper = new WordCountWithCounter.TokenizerMapper();
        Mapper.Context context = mock(Mapper.Context.class);
        Counter counter = mock(Counter.class);
        when(context.getCounter(WordCountWithCounter.Word.WITHOUT_SPECIAL_CHARACTER)).thenReturn(counter);

        mapper.map(new LongWritable(0), new Text("dog dog cat"), context);

        verify(counter, times(3)).increment(1);
    }
}

2022. 08. 03(수) Python 공부 8일차

Wed, 03 Aug 2022 01:24:19 GMT

컬렉션 타입의 이해

tuple

리스트와 같이 복수개의 값을 갖는 컬렉션 타입

생성된 후 변경이 불가능

  a = [1, 2, 3]
  b = (1, 2, 3)

  print(type(a))
  print(type(b))

  a[0] = 100
  print(a)

  b[0] = 100
  print(b)



[100, 2, 3]

![](https://velog.velcdn.com/images/eastgun_/post/a0a757da-edb4-46d7-a9c5-fd5b43a034d5/image.png)


#### typle unpacking
- 튜플의 값을 차례대로 변수에 대입
```python
    a, b, c = 100, 200
    print(a, b, c)

    100 200

연습문제 : a와 b의 값을 교환하시오

  a = 5
  b = 4

  print(a, b)

  # 일반적인 logic
  temp = a
  a = b
  b = temp

  # 파이썬은 튜플의 언팩킹으로 쉽게 교환 가능
  a, b = b, a

  print(a, b)

  5 4
  4 5

dictionary

키와 값을 갖는 데이터 구조
키는 내부적으로 ahsh값으로 저장

순서를 따지지 않음. 즉, 인덱스가 없음

  # dictionary 은 중괄호를 사용함
  a = {'Korea' : 'Seoul', 
       'Canada': 'Ottawa', 
       'USA': 'Washington D.C' }

  b = {0:1, 1:6, 7:9, 8:10}
  type(b)        # dict
  print(b[0])    # 인덱스값을 찾는게 아니라 b의 딕셔너리 값들이 상수여서 상수 0을 찾는것

  print(a)    # {'Korea' : 'Seoul', 'Canada': 'Ottawa', 'USA': 'Washington D.C' }
  print(a['Korea'])    # Seoul

항목 추가 및 변경

기존에 키가 존재 하면, 새로운 값으로 업데이트

존재하지 않으면, 새로운 키, 값 생성

a = {'Korea' : 'Seoul', 
     'Canada': 'Ottawa', 
     'USA': 'Washington D.C' }

a['Japan'] = 'Tokyo'
a['China'] = 'Beijing'

print(a)    # {'Korea' : 'Seoul', 'Canada': 'Ottawa', 'USA': 'Washington D.C', 'Japan':'Tokyo', 'China':'Beijing' }

update()
- 두 딕셔너리를 병합함
- 겹치는 키가 있다면 parameter로 전달되는 키 값이 overwrite된다.
```
a = {'a': 1, 'b': 2, 'c': 3}
b = {'a': 2, 'd': 4, 'e': 5}
```
a.update(b)

print(a) {'a': 2, 'b': 2, 'c': 3, 'd': 4, 'e': 5} ```
key 삭제
- del 키워드 사용
- pop 함수 이용
```
a = {'a': 1, 'b': 2, 'c': 3}
print(a)    # {'a': 1, 'b': 2, 'c': 3}
```
a.pop('b') del a['b'] # 범용적으로 지울 수 있는 del print(a) # {'a': 1, 'c': 3}

clear()

딕셔너리의 모든 값을 초기화

a = {'a': 1, 'b': 2, 'c': 3}
print(a)    # {'a': 1, 'b': 2, 'c': 3}
a.clear()
print(a)    # {}

in
- key값 존재 확인
- O(1) 연산 - 딕셔너리의 크기와 관계없이 항상 연산의 속도가 일정하다는 의미
```
a = {'a': 1, 'b': 2, 'c': 3}
print(a)    # {'a': 1, 'b': 2, 'c': 3}
```
'b' in a # True 'd' in a # False ## dict의 in은 갯수가 무수히 많든 바로 찾음 ```
value access
- dict[key]로 접근, 키가 없는 경우 에러 발생
- .get() 함수로 접근, 키가 없는 경우 None반환

모든 keys, values 접근

keys() - 키만 반환
values() - 값만 반환

items() - 키, 값의 튜플을 반환

   a = {'a': 1, 'b': 2, 'c': 3}
  print(a)                 # {'a': 1, 'b': 2, 'c': 3}
  print(a.keys())            # dict_keys(['a', 'b', 'c'])
  print(a.values())        # dict_values([1, 2, 3])

  print(list(a.keys()))    # ['a', 'b', 'c']    ## list로 변환가능
  print(list(a.values()))    # [1, 2, 3]            ## list로 변환 가능

  list(a.items())            # [('a', 1), ('b', 2), ('c', 3)]

set

dictionary에서 key만 활용하는 데이터 구조로 이해

수학에서의 집합과 동일한 개념

  a = {1, 1, 2, 3, 3, 4, 1, 5}
  print(a)    # {1, 2, 3, 4, 5}        ## 중복을 제거해서 출력함
  print(a[0])    # 인덱스 값이 없어 오류남

set()으로 집합으로 변환

  a = set()        # 빈 set을 생성함
  a = [1, 1, 2, 3, 3, 4, 1, 5]
  print(a)    # [1, 1, 2, 3, 3, 4, 1, 5]

  b = set(a)
  print(b)    # {1, 2, 3, 4, 5}

- **set operations**
  - 수학 연산과 동일
  - 교집합, 합집합, 차집합 등 지원
```python
    a = {1, 2, 3}
    b = {2, 3, 4}

    print(a.union(b))        # {1, 2, 3, 4}    ## 합집합
    print(a.intersection(b))# {2, 3}        ## 교집합
    print(a.difference(b))    # {1}            ## 차집합
    print(a.issubset(b))    # False            ## 부분 집합

조건문(if, elif, else) 활용하기

condition (조건문)

특정 조건을 만족하는 경우에만 수행할 작업이 있는 경우 사용
모든 조건은 boolean으로 표현 됨 (예외 사항은 아래 배울 예정)
if, elif, else 키워드가 사용
조건문의 경우 if, elif, else 블록에 종속된 코드는 들여쓰기로 표현 가능
즉 아래코드에서와 같이, 조건문 아래에 들여쓰기된 2줄의 코드만이 조건문의 조건에 따라 수행될 수도, 수행되지 않을 수도 있는 코드라고 할 수 있음
들여쓰기 된 코드를 블록(block), 또는 코드블록이라고 함

python에서 모든 블록의 시작점의 마지막에는 :(콜론, colon) 추가가 필요

  if 6 >= 5:
      print ('6 is greater than 5')
      print ('Yeah, it is true')
  print ('This code is not belongs to if statements')

Logical AND, OR, NOT
- 조건문에 사용되는 조건의 경우, boolean이기 때문에, 논리식 AND, OR, NOT이 사용 가능
- AND : and
- OR : or
- NOT : not
논리표
- AND
  - T AND T : T
  - T AND F : F
  - F AND T : F
  - F AND F : F
- OR
  - T OR T : T
  - T OR F : T
  - F OR T : T
  - F OR F : F
- NOT
  - NOT T : F
  - NOT F : T
우선순위
- NOT > AND > OR

if의 조건이 bool이 아닌 경우

일반적으로는 조건문에는 bool이 주로 위치 함
하지만, 정수, 실수, 문자열 리스트 등 기본 타입도 조건에 사용 가능
False로 간주되는 값( 각 타입의 기본값)
- None
- 0
- 0.0
- ''
- [] -> 빈 리스트
- () -> 빈 튜플
- {} -> 빈 딕셔너리
- set() -> 빈 집합
그 밖에는 모두 True로 간주

if, else

if가 아닌 경우, 나머지 조건을 표현하고 싶다면 바로 아래 else 블락 사용
이 경우, if조건이 True인 경우, if 블락의 코드가 수행, 거짓인 경우 else 블락의 코드가 수행

주의 할 점: if와 else사이에 다른 코드 삽입 불가

  # 짝수인 경우에는 2로 나눈 값을 출력하고
  # 홀수인 경우에는 1을 더한 값을 출력해라

  a = 10
  if a % 2 == 0:    # 짝수인지 판별
      print(a / 2)
  else:
      print(a + 1)

  5.0

if, elif, else

조건이 여러개인 경우, 다음 조건을 elif 블록에 명시 가능
이 경우, 각 조건을 확인 후, True인 조건의 코드 브락을 실행 한 후, 전체 if, elif, else 구문을 종료
조건문을 사용할 때는, if 이후, 0개 이상의 elif를 사용 가능하며 0개 또는 1개의 else를 사용 가능함

중첩 조건문(nested condition)

조건문의 경우 중첩하여 작성 가능

중첩의 의미는 depth(깊이)로 생각할 수 있으며, depth의 제한은 없음

  a = 10
  b = 9
  c = 8

  if a == 10:
      if c == 8:
          if b == 8:
              print('a is ten and b is 8')
          else:
              print('a is ten and b is not 8')

2022. 08. 02(화) Spark & Hadoop 초격차 7일차

Wed, 03 Aug 2022 00:00:55 GMT

Reduce-side join 실습 2

순서

정렬하고자 하는 값을 포함하는 복합 키 클래스 정의
정의한 복합키를 통해서 어느 리듀스에게 전달될지 결정하는 파티셔너 클래스 정의
리듀스에 입력될 값을 그룹핑해주는 클래스 정의
리듀스에 입력을 키를 기준으로 정렬해 주기위한 클래스를 정의

1. TextText 클래스 - 복합 키 클래스 정의

package com.fastcampus.hadoop;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class TextText implements WritableComparable {
    private Text first;
    private Text second;

    // 생성자 정의
    public TextText() {
        set(new Text(), new Text());
    }

    public TextText(String first, String second) {
        set(new Text(first), new Text(second));
    }

    public TextText(Text first, Text second) {
        set(first, second);
    }

    public void set(Text first, Text second) {
        this.first = first;
        this.second = second;
    }

    public Text getFirst() {
        return first;
    }

    public Text getSecond() {
        return second;
    }

    @Override
    public int compareTo(TextText o) {
        // 첫번 째 들어있는 first 값들을 기준으로 비교를 하고
        int cmp = first.compareTo(o.first);
        // 일치하지 않을 때에
        if (cmp != 0) {
            return cmp;
        }

        // 일치할땐 second 값들을 리턴
        return second.compareTo(o.second);
    }

    /** Writable 인터페이스 밑에 있는 두개의 메소드를 재정의 */
    // 직렬화를 위한
    @Override
    public void write(DataOutput out) throws IOException {
        first.write(out);
        second.write(out);
    }

    // 직렬화된 데이터를 읽을 때
    @Override
    public void readFields(DataInput in) throws IOException {
        first.readFields(in);
        second.readFields(in);
    }

    // Hashcode 재정의
    @Override
    public int hashCode() {
        // 해쉬코드 값을 재정의 할때는 소수를 많이 곱해줌
        return first.hashCode() * 163 + second.hashCode();
    }

    // equals 재정의
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof TextText) {
            TextText tt = (TextText) obj;
            return first.equals(tt.first) && second.equals(tt.second);
        }

        return false;
    }

    // toString 재정의
    @Override
    public String toString() {
        return first.toString() + ", " + second.toString();
    }
}

2. KeyPartitioner 클래스 - 파티셔너 클래스 정의

// 파티셔너 클래스 정의
    public static class KeyPartitioner extends Partitioner {
        @Override
        public int getPartition(TextText key, Text value, int numPartitions) {
            return (key.getFirst().hashCode() & Integer.MAX_VALUE) % numPartitions;
        }
    }

3. GroupComparator 클래스 - 그룹핑 클래스 정의

// 그룹핑 클래스 정의
    public static class GroupComparator extends WritableComparator {
        protected GroupComparator() {
            super(TextText.class, true);
        }

        @Override
        public int compare(WritableComparable a, WritableComparable b) {
            TextText t1 = (TextText) a;
            TextText t2 = (TextText) b;
            return t1.getFirst().compareTo(t2.getFirst());
        }
    }

4. KeyComparator 클래스 - 키 정렬 클래스 정의

// 키 정렬 클래스 정의
    public static class KeyComparator extends WritableComparator {
        protected KeyComparator() {
            super(TextText.class, true);
        }

        @Override
        public int compare(WritableComparable a, WritableComparable b) {
            TextText t1 = (TextText) a;
            TextText t2 = (TextText) b;
            int cmp = t1.getFirst().compareTo(t2.getFirst());
            if (cmp != 0) {
                return cmp;
            }
            return t1.getSecond().compareTo(t2.getSecond());
        }
    }

전체 코드

package com.fastcampus.hadoop;

import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Partitioner;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.MultipleInputs;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import java.io.IOException;
import java.util.Iterator;

public class ReduceSideJoinCustomkey extends Configured implements Tool {
    static enum DataType {
        DEPARTMENT("a"), EMPLOYEE("b");

        DataType(String value) {
            this.value = value;
        }
        private final String value;
        public String value() {
            return value;
        }
    }

    public static class DepartmentMapper extends Mapper {
        TextText outKey = new TextText();
        Text outValue = new Text();

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            // dept_no, dept_name
            String[] split = value.toString().split(",");

            outKey.set(new Text(split[0]), new Text(DataType.DEPARTMENT.value));
            outValue.set(split[1]);
            context.write(outKey, outValue);
        }
    }

    public static class EmployeeMapper extends  Mapper {
        TextText outKey = new TextText();
        Text outValue = new Text();

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            // emp_no, birth_date, first_name, last_name, gender, hire_date, dept_no
            String[] split = value.toString().split(",");

            outKey.set(new Text(split[6]), new Text(DataType.EMPLOYEE.value));
            outValue.set(new Text(split[0] + "\t" + split[2] + "\t" + split[4]));
            context.write(outKey, outValue);
        }
    }

    public static class ReduceJoinReducer extends Reducer {
        Text outKey = new Text();
        Text outValue = new Text();

        @Override
        protected void reduce(TextText key, Iterable values, Context context) throws IOException, InterruptedException {
            Iterator iter = values.iterator();

            // 항상 values에는 values로  값이 전달 될땐 두번째의 키 값으로 정렬이 되어 있기 떄문에 항상 department text가 먼저 오게 된다.
            String departmentText = iter.next().toString();

            while (iter.hasNext()) {
                Text employeeText = iter.next();
                String[] employeeSplit = employeeText.toString().split("\t");
                outKey.set(employeeSplit[0]);
                outValue.set(employeeSplit[1] + "\t" + employeeSplit[2] + "\t" + departmentText);
                context.write(outKey, outValue);
            }
        }
    }

    // 키 정렬 클래스 정의
    public static class KeyComparator extends WritableComparator {
        protected KeyComparator() {
            super(TextText.class, true);
        }

        @Override
        public int compare(WritableComparable a, WritableComparable b) {
            TextText t1 = (TextText) a;
            TextText t2 = (TextText) b;
            int cmp = t1.getFirst().compareTo(t2.getFirst());
            if (cmp != 0) {
                return cmp;
            }
            return t1.getSecond().compareTo(t2.getSecond());
        }
    }

    // 그룹핑 클래스 정의
    public static class GroupComparator extends WritableComparator {
        protected GroupComparator() {
            super(TextText.class, true);
        }

        @Override
        public int compare(WritableComparable a, WritableComparable b) {
            TextText t1 = (TextText) a;
            TextText t2 = (TextText) b;
            return t1.getFirst().compareTo(t2.getFirst());
        }
    }

    // 파티셔너 클래스 정의
    public static class KeyPartitioner extends Partitioner {
        @Override
        public int getPartition(TextText key, Text value, int numPartitions) {
            return (key.getFirst().hashCode() & Integer.MAX_VALUE) % numPartitions;
        }
    }

    // 드라이버 정의
    @Override
    public int run(String[] args) throws Exception {
        Job job = Job.getInstance(getConf(), "ReduceSideJoinCustomKey");

        job.setJarByClass(ReduceSideJoinCustomkey.class);
        job.setReducerClass(ReduceJoinReducer.class);
        job.setMapOutputKeyClass(TextText.class);
        job.setMapOutputValueClass(Text.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        job.setPartitionerClass(KeyPartitioner.class);
        job.setSortComparatorClass(KeyComparator.class);
        job.setGroupingComparatorClass(GroupComparator.class);

        MultipleInputs.addInputPath(job, new Path(args[0]), TextInputFormat.class, EmployeeMapper.class);
        MultipleInputs.addInputPath(job, new Path(args[1]), TextInputFormat.class, DepartmentMapper.class);

        FileOutputFormat.setOutputPath(job, new Path(args[2]));
        return job.waitForCompletion(true) ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        int exitCode = ToolRunner.run(new ReduceSideJoinCustomkey(), args);
        System.exit(exitCode);
    }
}

실행 결과

모두를 위한 딥러닝 - ML Lec 07

Tue, 02 Aug 2022 05:24:17 GMT

lec 07-1: 학습 rate, Overfitting, 그리고 일반화 (Regularization)

Gradient descent

우리가 cost function을 정의하고 그 cost function을 최소화하는 값을 찾기 위해서 사용 했던 Gradient descent 알고리즘 이다.

Large learning rate : overshooting

러닝 레이트를 잘 정하는게 중요한데 만약에 이 값을 엄청 크게 주었다고 가정해 보자. 그럴 땐 그래프 바깥으로 튕겨나가버릴 수 있다. 이렇게하면 학습이 이루어지지 않을 뿐만 아니라 코스트펑션을 출력할 때 숫자가 아닌 값들이 찍혀나올 수 있다. 이러한 현상을 Overshooting 이라 한다.

Small learning rate : takes too long, stops at local minimum

반대로 굉장히 작은 러닝 레이트를 지정해준다면 지정한 횟수를 수행하고도 최저점을 못찾고 중간에 멈춰버릴 수 있다.

Try several learning rates

전반적으로는 러닝 레이트를 정하는 것에 특별한 방법은 없다.가진 환경에 따라 다 다르기 때문에 보통 0.01로 시작을 많이 하고 오버슈팅이 일어나면 작게 반대로 너무 적게 움직여서 끝나는거같으면 크게 올리면 된다.

Data (X) preprocessing for gradient descent

데이터를 사전처리해야할 이유가 있는데, 우리가 가장 많이 사용하는 알고리즘인 gradient descent 알고리즘으로 예시를 들겠다.

예를 들어서 우리가 가지고 있는 데이터의 값 중에 x1의 값과 x2의 값에 큰 차이가 난다면 이전 그래프의 등고선 모양보다는 옆으로 길게 늬운 등고선이 나타난다. 그러면 우리가 시작점을 잡고 러닝 레이트 값이 좋은 값임에도 불과하고 조금이라도 밖으로 나가게되면 튀어 나가게 되어버린다. 데이터 값에 큰 차이가 있을 경우에 Normalize 할 필요가 있다

오리지날 데이터가 2차원 형태로 저렇게 되어 있다고 할 때 보통 많이 쓰는 방법이 zero-centered data이며 데이터의 중심이 0으로 갈 수 있도록 바꿔주는 방법을 취하기도 하고 또 가장 많이 사용하는 방법은 어떤 값이 이 값 전체의 범위가 어떤 형태의 범위안에 항상 들어가도록 Normalized data 하는 방법이 있다

그래서 내가 러닝 레이트를 잘 잡은 거 같은데 이상하게 학습이 일어나지 않고 코스트 함수가 발산을 한다거나 이상한 동작을 보일때는 데이터중에 큰 차이가 나는 값이 있는지 그리고 preprocessing을 했는지 점검해보면 좋다

Standardization

x의 값을 우리가 계산한 평균과 분산의 값을 가지고 나누어 주면 되는데 파이썬을 가지고 만든다면 이렇게 한줄로 표시할 수 있다. 이런 형태의 노말리제이션이 있지만 그 중에 한 가지를 선택해서 x 데이터를 처리해보는 것도 머신러닝에 좋은 성능을 발휘하기 위한 방법일 수가 있다.

Overfitting

Our model is very good with training data set (with memorization)
Not good at test dataset orin real use

머신러닝의 가장 큰 문제인 Overfitting, 오버피팅이란 학습 데이터에 너무 잘맞는 모델을 만들 수가 있는데 training data set에는 잘 맞지만 test data set이나 실제 사용했을 경우에는 정확성이 떨어지는걸 오버피팅이라 한다

왼쪽 모델1같은 경우는 리니어하게 그어서 좋은 모델의 표본이라 할 수 있지만 오른쪽 모델2같은 경우는 가지고 있는 데이터에 너무 딱 맞게 선을 그어버려서 training data set에는 잘 맞겠지만 다른 데이터가 들어오게 될 때는 굉장히 정확도가 떨어 질 수 있다. 이러한 모델이 오버피팅이다.

Solutions for overfitting

More training data!
Reduce the number of features
Regularization

오버피팅을 줄이는 가장 좋은 방법은 training data를 많이 가지고 있는것이다 또 하나는 우리가 가지고 있는 features의 갯수를 중복된 것이 있으면 줄인다던지 이런 방법도 오버피팅을 줄이는방법이다.

마지막으로 이 두가지 방법 외에도 하나의 기술적인 방법이 있는데 이게 Regularization이라는 방법이다.

Regularization

Let's not have too big numbers in the weight

일반화 시킨다는 얘기는 우리가 가지고 있는 w를 너무나 큰 값을 가지지 말자 우리가 주로 오버피팅이라고 설명을 할 때 보통 그래프의 선을 데이터에 맞게 구부리는 것을 말하는데 이것을 구부리지말고 피자 라고 하는걸 Regularization 여기서 편다는 이야기는 같이 좀 w이 적은 값을 가진다는 얘기고 구부린다는 것은 w값이 큰 값을 가졌을때 구부러지는건데 그래서 좀 구부리지 말고 좀 펴 라는 얘기이다.

이것을 하기 위해서는 우리가 코스트 함수를 설명할 때 코스트를 최소화 시키는 것이 우리의 목표였는데 이 코스트 함수의 뒤에 이 텀을 추가시켜 준다

람다값을 regularization strength라 한다 텐서플로우로 구현할때 간단하게 표현할 수 있다.

lec 07-2: Training/Testing 데이타 셋

Performance evaluation: is this good?

이전 시간에 배운것들을 통해서 우리의 머신러닝 모델을 데이터를 가지고 학습을 시켰다. 이렇게 학습을 시킨 모델이 얼마나 훌륭한가? 얼마나 성공적으로 예측을 할 수 있을까 평가를 할까요

Evaluation using training set?

우리가 이런 형태의 데이터가 있다고 생각을 해보자. 보통 training set 을 가지고 모델을 학습을 시키는데 다 시키고 난 뒤 다시 training set 을 가지고 물어보게 되면 이것이 공정한 방법일까요? 이런식으로 한다면 머신러닝은 100% 완벽한 답을 할 수도 있을것이다. 그냥 외워버리면 되니까 이것은 좋은방법이 아니다

Training and test sets

좋은 방법은 우리가 시험을 보는 방식이랑 똑같다. 얼추 3:7로 나뉘어서 7은 training 3은 test set으로 구분해서 training set을 가지고 모델을 학습 시키고 완벽하게 끝났다라고 했을 때 단 한번의 기회로 testing data set을 가지고 비교를 한다. 한마디로 training set은 교과서이고 이 교과서를 가지고 공부를 하다가 다 했을 경우 testing data set을 시험이라 비유했을 경우 단 한번 시험으로 성능을 평가하면 된다.

Training, validation and test sets

바로 직전에 얘기 했듯이 보통 통상적으로 트레이닝 셋과 테스팅 셋으로 나뉘는게 일반적인데 지난번에 얘기 할때 알파라는 러닝 레이트라는것을 얘기 했었고, 또 하나의 상수가 학습할 때 들어가는 것이 람다라고 했던 어떤 레귤러제이션을 하는데 얼마나 강하게 할것인가하는 값이였다. 이러한 값을 조금 튜닝할 필요가 있을 때 우리가 가지고 있는 트레이닝 셋을 Training과 Validation 두개로 다시 나눕니다. 일반적으로 트레이닝 셋으로 모델을 학습시킨 다음에 이 벨리데이션 셋을 가지고 이런 상수 값들이 어떤것이 좋을까 하는 것들을 튜닝을 하게 된다. 이것을 이제 Validation이라 하고 비유하자면 모의고사로 보면 되고 해서 완벽하게 되면 이제 Testing data set을 가지고 모델이 잘 동작하는지 평가를 하면 된다.

Online learning

그리고 데이터 셋이 굉장히 많을 경우에 한번에 다 넣어서 학습을 시키기가 힘들 때가 있다. 이럴 때 나온게 Online learning이다.

예를 들어 데이터가 100만개가 있다고 가정할때, 한번에 넣어서 학습을 시킬려면 베타공간도 많이 필요하고 하니까 그렇게 하지 않고 잘라 가지고 10만개 씩 잘라서 학습을 시킵니다. 한번 학습 시키고 끝났으면 두번째를 학습시키고 세번째를 학습시키고,, 자 이때 모델이 해야하는 일은 첫번째 학습이 된 결과가 모델에 남아 있어야 한다. 그래서 두번째 데이터를 학습 시키면 이 모델에 추가가 되어서 새로운 학습이 되어야 한다.

MINIST Dataset

유명한 데이터셋인데 그림을 보면 사람이 적어놓은 숫자를 컴퓨터가 인식을 할 수 있는지를 테스트하는 Dataset 이다. 이것이 필요했던 이유는 미국 우체국에서 우편번호를 받게되면 최소한 자동으로 분류를 할 수 있게 컴퓨터에게 시키기 위해서 만들어졌다.

여기 보면 데이터셋이 나뉘어져 있는데 training set과 test set으로 나뉘어져있는것을 볼 수 있다.

ML lab 07-1: training/test dataset, learning rate, normalization

Training and Test datasets

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

tf.set_random_seed(777)  # for reproducibility

x_data = [[1, 2, 1], [1, 3, 2], [1, 3, 4], [1, 5, 5], [1, 7, 5], [1, 2, 5], [1, 6, 6], [1, 7, 7]]
y_data = [[0, 0, 1], [0, 0, 1], [0, 0, 1], [0, 1, 0], [0, 1, 0], [0, 1, 0], [1, 0, 0], [1, 0, 0]]

# Evaluation our model using this test dataset
x_test = [[2, 1, 1], [3, 1, 2], [3, 3, 4]]
y_test = [[0, 0, 1], [0, 0, 1], [0, 0, 1]]

X = tf.placeholder("float", [None, 3])
Y = tf.placeholder("float", [None, 3])

W = tf.Variable(tf.random_normal([3, 3]))
b = tf.Variable(tf.random_normal([3]))

# tf.nn.softmax computes softmax activations
# softmax = exp(logits) / reduce_sum(exp(logits), dim)
hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)

# Cross entropy cost/loss
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))
# Try to change learning_rate to small numbers
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)

# Correct prediction Test model
prediction = tf.argmax(hypothesis, 1)
is_correct = tf.equal(prediction, tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))

# Launch graph
with tf.Session() as sess:
    # Initialize TensorFlow variables
    sess.run(tf.global_variables_initializer())

    for step in range(201):
        cost_val, W_val, _ = sess.run([cost, W, optimizer], feed_dict={X: x_data, Y: y_data})
        print(step, cost_val, W_val)

    # predict
    print("Prediction:", sess.run(prediction, feed_dict={X: x_test}))
    # Calculate the accuracy
    print("Accuracy: ", sess.run(accuracy, feed_dict={X: x_test, Y: y_test}))

Learning rate: NaN!

Big learning rate - ex) 1.5 일 때

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

tf.set_random_seed(777)  # for reproducibility

x_data = [[1, 2, 1], [1, 3, 2], [1, 3, 4], [1, 5, 5], [1, 7, 5], [1, 2, 5], [1, 6, 6], [1, 7, 7]]
y_data = [[0, 0, 1], [0, 0, 1], [0, 0, 1], [0, 1, 0], [0, 1, 0], [0, 1, 0], [1, 0, 0], [1, 0, 0]]

# 이 테스트 데이터 세트를 사용하여 모델 평가
x_test = [[2, 1, 1], [3, 1, 2], [3, 3, 4]]
y_test = [[0, 0, 1], [0, 0, 1], [0, 0, 1]]

X = tf.placeholder("float", [None, 3])
Y = tf.placeholder("float", [None, 3])

W = tf.Variable(tf.random_normal([3, 3]))
b = tf.Variable(tf.random_normal([3]))

# tf.nn.softmax computes softmax activations
# softmax = exp(logits) / reduce_sum(exp(logits), dim)
hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)

# Cross entropy cost/loss
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))
# Try to change learning_rate to small numbers
optimizer = tf.train.GradientDescentOptimizer(learning_rate=1.5).minimize(cost)

# 정확한 예측 테스트 모델
prediction = tf.argmax(hypothesis, 1)
is_correct = tf.equal(prediction, tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))

# Launch graph
with tf.Session() as sess:
    # 세션을 열고 변수 초기화
    sess.run(tf.global_variables_initializer())

    for step in range(201):
        cost_val, W_val, _ = sess.run([cost, W, optimizer], feed_dict={X: x_data, Y: y_data})
        print(step, cost_val, W_val)

    # 테스트 데이터로 확인해보기
    print("Prediction:", sess.run(prediction, feed_dict={X: x_test}))
    # Calculate the accuracy
    print("Accuracy: ", sess.run(accuracy, feed_dict={X: x_test, Y: y_test}))

Small learning rate - ex) 1e-10 일 때

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

tf.set_random_seed(777)  # for reproducibility

x_data = [[1, 2, 1], [1, 3, 2], [1, 3, 4], [1, 5, 5], [1, 7, 5], [1, 2, 5], [1, 6, 6], [1, 7, 7]]
y_data = [[0, 0, 1], [0, 0, 1], [0, 0, 1], [0, 1, 0], [0, 1, 0], [0, 1, 0], [1, 0, 0], [1, 0, 0]]

# 이 테스트 데이터 세트를 사용하여 모델 평가
x_test = [[2, 1, 1], [3, 1, 2], [3, 3, 4]]
y_test = [[0, 0, 1], [0, 0, 1], [0, 0, 1]]

X = tf.placeholder("float", [None, 3])
Y = tf.placeholder("float", [None, 3])

W = tf.Variable(tf.random_normal([3, 3]))
b = tf.Variable(tf.random_normal([3]))

# tf.nn.softmax computes softmax activations
# softmax = exp(logits) / reduce_sum(exp(logits), dim)
hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)

# Cross entropy cost/loss
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))
# Try to change learning_rate to small numbers
optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-10).minimize(cost)

# 정확한 예측 테스트 모델
prediction = tf.argmax(hypothesis, 1)
is_correct = tf.equal(prediction, tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))

# Launch graph
with tf.Session() as sess:
    # 세션을 열고 변수 초기화
    sess.run(tf.global_variables_initializer())

    for step in range(201):
        cost_val, W_val, _ = sess.run([cost, W, optimizer], feed_dict={X: x_data, Y: y_data})
        print(step, cost_val, W_val)

    # 테스트 데이터로 확인해보기
    print("Prediction:", sess.run(prediction, feed_dict={X: x_test}))
    # Calculate the accuracy
    print("Accuracy: ", sess.run(accuracy, feed_dict={X: x_test, Y: y_test}))

Non-normalized inputs

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as np
tf.set_random_seed(777)  # for reproducibility


xy = np.array([[828.659973, 833.450012, 908100, 828.349976, 831.659973],
               [823.02002, 828.070007, 1828100, 821.655029, 828.070007],
               [819.929993, 824.400024, 1438100, 818.97998, 824.159973],
               [816, 820.958984, 1008100, 815.48999, 819.23999],
               [819.359985, 823, 1188100, 818.469971, 818.97998],
               [819, 823, 1198100, 816, 820.450012],
               [811.700012, 815.25, 1098100, 809.780029, 813.669983],
               [809.51001, 816.659973, 1398100, 804.539978, 809.559998]])

x_data = xy[:, 0:-1]
y_data = xy[:, [-1]]

# placeholders for a tensor that will be always fed.
X = tf.placeholder(tf.float32, shape=[None, 4])
Y = tf.placeholder(tf.float32, shape=[None, 1])

W = tf.Variable(tf.random_normal([4, 1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

# Hypothesis
hypothesis = tf.matmul(X, W) + b

# Simplified cost/loss function
cost = tf.reduce_mean(tf.square(hypothesis - Y))

# Minimize
optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-5)
train = optimizer.minimize(cost)

# Launch the graph in a session.
sess = tf.Session()
# Initializes global variables in the graph.
sess.run(tf.global_variables_initializer())

for step in range(101):
    cost_val, hy_val, _ = sess.run(
        [cost, hypothesis, train], feed_dict={X: x_data, Y: y_data})
    print(step, "Cost: ", cost_val, "\nPrediction:\n", hy_val)

Normalized inputs (min-max scale)

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as np
tf.set_random_seed(777)  # for reproducibility

def min_max_scaler(data):
    numerator = data - np.min(data, 0)
    denominator = np.max(data, 0) - np.min(data, 0)
    # noise term prevents the zero division
    return numerator / (denominator + 1e-7)

xy = np.array(
    [
        [828.659973, 833.450012, 908100, 828.349976, 831.659973],
        [823.02002, 828.070007, 1828100, 821.655029, 828.070007],
        [819.929993, 824.400024, 1438100, 818.97998, 824.159973],
        [816, 820.958984, 1008100, 815.48999, 819.23999],
        [819.359985, 823, 1188100, 818.469971, 818.97998],
        [819, 823, 1198100, 816, 820.450012],
        [811.700012, 815.25, 1098100, 809.780029, 813.669983],
        [809.51001, 816.659973, 1398100, 804.539978, 809.559998],
    ]
)

# very important. It does not work without it.
xy = min_max_scaler(xy)
print(xy)

x_data = xy[:, 0:-1]
y_data = xy[:, [-1]]

# placeholders for a tensor that will be always fed.
X = tf.placeholder(tf.float32, shape=[None, 4])
Y = tf.placeholder(tf.float32, shape=[None, 1])

W = tf.Variable(tf.random_normal([4, 1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

# Hypothesis
hypothesis = tf.matmul(X, W) + b

# Simplified cost/loss function
cost = tf.reduce_mean(tf.square(hypothesis - Y))

# Minimize
train = tf.train.GradientDescentOptimizer(learning_rate=1e-5).minimize(cost)

# Launch the graph in a session.
with tf.Session() as sess:
    # Initializes global variables in the graph.
    sess.run(tf.global_variables_initializer())

    for step in range(101):
        _, cost_val, hy_val = sess.run(
            [train, cost, hypothesis], feed_dict={X: x_data, Y: y_data}
        )
        print(step, "Cost: ", cost_val, "\nPrediction:\n", hy_val)

xy = MinMaxScaler(xy) 을 주게 되면 제일 작은값을 0 제일 큰값을 1로 줘서 그 사이를 값에 따라서 노말라이즈를 한다

ML lab 07-2: Meet MNIST Dataset

MNIST Dataset

28x28x1 image

MNIST Dataset(code)

import tensorflow.compat.v1 as tf
import matplotlib.pyplot as plt
import numpy as np
import random

tf.disable_v2_behavior()

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

print(len(x_train), len(y_train), x_train.shape, y_train.shape)
print(len(x_test), len(y_test), x_test.shape, y_test.shape)

x_train, x_test = x_train / 255.0, x_test / 255.0  # Feature scaling 적용

nb_classes = 10;

x_train_new = x_train.reshape(len(x_train), 784)  # 60000 * 784 배열로 변경 - 한행당 이미지 하나
y_train_new = np.zeros((len(y_train), nb_classes))  # 60000 * 10 배열 생성
for i in range(len(y_train_new)):
    y_train_new[i, y_train[i]] = 1  # one-hot encoding

x_test_new = x_test.reshape(len(x_test), 784)  # 60000 * 784 배열로 변경 - 한행당 이미지 하나
y_test_new = np.zeros((len(y_test), nb_classes))  # 60000 * 10 배열 생성
for i in range(len(y_test_new)):
    y_test_new[i, y_test[i]] = 1  # one-hot encoding

# MNIST data image of shape 28 * 28 = 784
X = tf.placeholder(tf.float32, [None, 784])
# 0 - 9 digits recognition = 10 classes
Y = tf.placeholder(tf.float32, [None, nb_classes])  # 6만개의 학습에 대한 10개의 가설 결과

W = tf.Variable(tf.random_normal([784, nb_classes]))  # 가설이 10개이고 가설별로 784개의 weigh을 가짐, 즉 7840개의 w
b = tf.Variable(tf.random_normal([nb_classes]))  # 가설이 10개니 가설의 b도 10

# Hypothesis (using softmax)
hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)  # 60000 x 10 행렬 - 행별로 열의 값을 확율로 바꿈

# cross entropy
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)

# Test model
is_correct = tf.equal(tf.arg_max(hypothesis, 1), tf.arg_max(Y, 1))
# Calculate accuracy
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))

# parameters
training_epochs = 15  # traing을 몇번 돌릴것인지
batch_size = 100  # 한번에 몇건씩 읽은것인지
total_batch = int(len(x_train_new) / batch_size)

with tf.Session() as sess:
    # Initialize TensorFlow variables
    sess.run(tf.global_variables_initializer())
    # Training cycle
    for epoch in range(training_epochs):
        avg_cost = 0

        for i in range(total_batch):
            # print (epoch,batch_size )
            batch_xs = x_train_new[(epoch * batch_size):(epoch + 1) * batch_size]
            batch_ys = y_train_new[(epoch * batch_size):(epoch + 1) * batch_size]

            _, cost_val = sess.run([optimizer, cost], feed_dict={X: batch_xs, Y: batch_ys})
            avg_cost += cost_val / total_batch

        print("Epoch: {:04d}, Cost: {:.9f}".format(epoch + 1, avg_cost))

    # Test the model using test sets
    print(
        "Accuracy: ",
        accuracy.eval(
            session=sess, feed_dict={X: x_test_new, Y: y_test_new}
        ),
    )

    # Get one and predict
    random_idx = random.randrange(1, 10000)
    print("random_idx : ", random_idx)
    print(
        "Prediction: ",
        sess.run(tf.argmax(hypothesis, 1), feed_dict={X: x_test_new[random_idx: random_idx + 1]}),
    )

    plt.imshow(
        x_test_new[random_idx: random_idx + 1].reshape(28, 28),
        cmap="Greys",
        interpolation="nearest",
    )
    plt.show()