욱이의 냉철한 공부

[딥러닝 기본] Transfer learning (전이 학습)

냉철한 욱 — Fri, 1 Apr 2022 13:22:50 +0900

1. Transfer learning 개념

적은 이미지 데이터 세트에서 딥러닝을 적용하기 위한 효과적인 방법은 전이학습이다. 전이학습은 높은 정확도를 비교적 짧은 시간 내에 달성할 수 있게 해주기 때문에 컴퓨터 비전 분야에서 널리 쓰이는 방법론이다. 일반적으로 대규모 이미지 데이터 세트에서 사전 훈련된 DCNN 모델을 새로운 task에 적합하도록 수정하여 활용한다. 그림 10과 같이 기존 DCNN 모델에서는 하위계층이 일반적인 특징을 추출하도록 학습이 이루어지고, 상위계층은 특정 문제에서만 나타날 수 있는 구체적인 특징을 추출하도록 학습되어 졌다. 전이학습 시 하위계층들은 일반적으로 재사용될 수 있지만, 상위계층은 데이터 크기와 유사성에 따라 재학습이 필요하다.

<그림 10> 일반적인 DCNN 모델의 형태

전이학습을 진행하는 방법은 그림 11처럼 4가지 경우로 분류된다.

첫째는 새로운 문제의 데이터 크기가 크고 사전 학습된 데이터와 유사성이 적은 경우이다. 이 경우는 사전학습된 모델의 구조만 사용하면서, 전체 파라미터를 새로운 데이터에 재학습시키는 방법이 적합하다. 기존 사전학습된 모델의 하위계층에서 추출한 일반적인 특징이 새로운 데이터 세트에서 추출할 특징과 차이가 클 수 있기 때문이다.

둘째는 새로운 문제의 데이터 크기가 크고 사전 학습된 데이터와 유사성이 높은 경우이다. 이 경우는 상위계층의 일부분만 새로운 데이터에 재학습시키는 방법이 적합하다. 데이터의 유사성이 높아서 사전 학습된 모델의 일반적인 정보를 최대한 활용하는 것이 효과적이다. 또한, 데이터 세트가 크기 때문에 과적합 문제를 최소화할 수 있어 필요한 파라미터만 재학습시킬 수 있다.

셋째는 새로운 문제의 데이터 크기가 작고 사전 학습된 데이터와 유사성도 적은 경우이다. 이 경우에는 그림 12처럼 재학습시킬 적절한 계층의 수를 찾아야 한다. 너무 많은 계층을 새로 학습시키면 작은 데이터 세트에 모델이 과적합 될 우려가 있고, 너무 적은 계층만을 학습시키면 모델은 제대로 학습되지 않을 것이다. 더불어 작은 크기의 데이터 세트를 보완하기 위해 데이터 증강 기법처럼 과적합 방지 기술이 함께 필요하게 된다.

넷째는 새로운 문제의 데이터 크기가 작지만, 사전 학습된 데이터와 유사성은 높은 경우이다. 이 경우에는 그림 13처럼 사전학습된 모델의 마지막 부분인 분류기만 제거하고 특징 추출기는 모두 재사용한다. 새로운 분류기만 학습함으로써, 기존의 추출된 특징들을 그대로 사용하는 것이다.

<그림 11> 데이터 크기와 유사성을 고려한 전이학습 방법

<그림 12> 데이터 크기가 작고 유사성도 적은 경우의 전이학습 방법

<그림 13> 데이터 크기가 작고 유사성은 높은 경우의 전이학습 방법

2. EX) 논문 리비전 할 때 Transfer learning 관련 답변서

For the comparison, typically the pretrained transformers outperform the normal model like CNN/LSTM. The authors should introduce more about their setups of baselines: were the models fine-tuned? how were the model fine-tuned? only the final layer was fine-tuned or the whole? ...

우리는 사전 훈련된 언어 모델(LM)에 대한 기준 설정의 세부 사항을 자세히 설명해야 한다는 데 동의합니다.
그림 R1.(c)에서 볼 수 있듯이 매우 작은 학습률로 전체 모델을 미세 조정했습니다. 더 구체적으로 말하자면, 큰 LM에 대한 사전 훈련된 지식을 유지하고 과적합을 피하기 위해 모델은 3e-5의 작은 학습률과 32개의 미니 배치로 30개의 에포크에 대해 미세 조정되었습니다. β1 = 0.9, β2 = 0.999, ε = 1e–8인 Adam 최적화기는 모든 변압기 기반 LM에 대해 고려되었습니다. 수정된 원고에서 이러한 기준 설정을 명시적으로 설명했습니다.

그림 R1과 같이 LM을 최적화하기 위해 세 가지 방법으로 미세 조정 실험을 수행했습니다. 이러한 실험에 대한 교육 세부 정보는 표 R2에 나와 있습니다. 표 R1은 전체 모델의 미세 조정이 최고의 성능을 달성했음을 보여줍니다(그림 R1(c)). 특히 전체 모델을 미세 조정하면 최종 레이어만 미세 조정하는 것보다 더 나은 결과를 얻을 수 있습니다. 따라서 사전 훈련된 전체 LM을 원고에 미세 조정한 결과를 제시했습니다.

좀 더 자세하게는 임베딩 레이어를 포함한 전체 모델을 동결하고 분류 레이어(최종 레이어)만 미세 조정한 경우(그림 R1(a)) 성능이 좋지 않았다. 그러나 임베딩 레이어도 학습되었을 때(그림 R1(b)), 임베딩 레이어가 동결되었을 때(그림 R1(a))에 비해 상대적으로 높은 성능 향상이 발생했습니다. 사전 훈련된 데이터셋(위키피디아)과 달리 결함 텍스트에 있는 대부분의 단어가 빌딩 관리에 특화된 기술 용어(전문용어)로 구성되어 임베딩 레이어를 미세 조정한 결과가 더 좋았다고 생각합니다. 또한 데이터 세트와 작업이 모두 다르기 때문에(다음 단어 예측 대 결함 분류) 전체 모델을 미세 조정하는 성능을 최고로 만들 수 있습니다.

귀하가 언급했듯이 변압기 기반 대형 LM은 일반적으로 기본 CNN/LSTM 접근 방식을 능가합니다. 변압기 기반 LM은 많은 매개변수로 상당한 표현력을 갖기 때문입니다. 그러나 최적의 네트워크 아키텍처는 작업의 난이도와 샘플 수에 따라 다릅니다(Shorten & Khoshgoftaar, 2019). 따라서 작업의 복잡성과 샘플 수에 비해 너무 큰 신경망을 설계하면 과적합되기 쉽습니다. 특히 사전 훈련된 LM을 미세 조정할 때 데이터 샘플의 수가 중요합니다. 본 연구에서 건물 결함 텍스트 데이터 세트의 샘플 수는 16,106개에 불과하며 각 샘플은 평균 15개의 토큰( BertTokenizer 사용). 우리의 과제는 기술 용어와 매우 짧은 텍스트로 인해 도전적이지만 텍스트 분류와 유사한 작업 수준이며 LM이 일반적으로 해결하는 기계 번역 및 질문 답변만큼 어렵지 않습니다. Shin et al. (2021), 작업이 상대적으로 간단하고 데이터 수가 적기 때문에 더 적은 수의 매개변수를 사용하여 효율적으로 설계된 모델이 과적합을 방지하면서 큰 LM을 능가할 수 있습니다. Shinet al. (2021) CNN-Word2Vec은 건강 진단 텍스트를 사용하여 갑상선 상태를 자동으로 분류하는 데 LM ELECTRA보다 더 높은 F1 점수를 달성했다고 보고했습니다. CNN은 로컬 연결성 및 가중치 공유로 인해 매개변수가 적고 필터 및 깊이를 통해 로컬 및 글로벌 관계(토큰과 컨텍스트 간의 관계)를 캡처할 수 있어 문장 분류(Y. Kim)와 같은 비교적 쉬운 작업에 대해 좋은 성능을 보입니다. , 2014; Conneau et al., 2016). 이러한 CNN의 특성과 작업을 고려하여 CNN 기반 AutoDefect 모델을 개발했습니다.

Figure R1. Fine-tuning methods of a pre-trained language model.

	Model	Task average	Average F1-score [%]
	Model	Task average	Work	Location	Defect	Element
(a) Training only the classifier	BERT (multilingual-cased)	54.74	40.30	66.36	60.15	52.16
	BERT	20.63	15.11	32.61	20.48	14.33
	ELECTRA	28.30	15.72	44.40	34.92	18.17
	GPT2	43.14	21.52	76.98	40.96	33.12
(b) Fine-tuning only the classifier and embedding layer	BERT (multilingual-cased)	87.69	87.70	93.00	84.31	85.76
	BERT	86.70	85.81	91.77	83.22	85.98
	ELECTRA	84.75	81.88	91.13	81.21	84.76
	GPT2	84.83	83.35	90.69	82.08	83.19
(c) Fine-tuning all layers of the whole model	BERT (multilingual-cased)	89.39	88.04	94.29	86.93	88.28
	BERT	89.62	88.12	93.80	86.07	90.47
	ELECTRA	89.47	89.71	93.51	86.18	88.49
	GPT2	89.68	89.19	93.55	85.52	90.46
AutoDefect (FastText+Word2Ve)		90.72	90.08	93.74	87.05	92.02

Table R1. Results of fine-tuning experiments on pre-trained language models

Table R2. Training details of fine-tuning experiments on pre-trained language models

	Training details
	Optimizer	Epoch	Batch size	Initial learning rate	learning rate decay scheduling
(a) Training only the classifier	Adam	50	32	3e-4	0.2 decay factor 6 epochs patience
(b) Fine-tuning only the classifier and embedding layer	Adam	50	32	3e-4	0.2 decay factor 10 epochs patience
(c) Fine-tuning all layers of the whole model	Adam	30	32	3e-5	fixed learning rate
AutoDefect (FastText+Word2Ve)	Adam	30	32	1e-3	0.2 decay factor 2 epochs patience

[딥러닝 기본] ML Strategy 2

냉철한 욱 — Fri, 1 Apr 2022 13:07:26 +0900

* 출저

본 개념정리는 제 지도교수님이신 연세대학교 정보대학원 김하영 교수님 수업과 Andrew 교수님의 Coursera 수업을 통해 얻은 정보를 통해 정리했습니다. 자료는 대부분 Andrew 교수님의 Coursera 수업자료입니다.

1. Error Analysis

1) Carrying out error analysis

- examples 확인

강아지를 고양이로 잘못 카테고리화 한 경우 찾는다.

* 선택

10% error : 100장 중 50장이 mislabeled라면 수정하는 것이 가치가 있을 수 있다.

ex) 100장 중 강아지를 고양이로 잘못 분류한 경우가 50장!

- parallel 방식의 error analysis

- 요약

요약하자면, 오류 분석을 실행하는데에는 먼저 dev set나 devleopment set에서 잘못 레이블된 example을 찾고, 이러한 잘못 레이블된 example들을 찾아서 false positives와 false negatives를 찾습니다. 그리하여 다양한 카테고리에 대한 오류의 총 개수를 각각 카테고리별로 찾아냅니다. 이런 진행과정에서 새로운 오류 관련 카테고리를 보신것과 같이 생성하기 원할 수 있는데요. example들을 보면서 "우와, 인스타그램 필터가 많네, 또는 스냅쳇 필터가 많네, " 라고 하며 분류기를 망친다는 생각이 드시면, 진행 와중에 새로운 카테고리를 생성하실 수 있습니다. 다양한 사유로 잘못 레이블된 example들을 직접 세면서 그 비율을 계산하면 우선순위를 정하는데 도움이 될 것입니다. 아니면 새로운 방향을 갖도록 자극제 역할을 해줄 수도 있구요.

2) Cleaning up incorrectly labeled data

- 레이블이 잘못된 경우

가치가 있을 경우 먼저 고치고 아니면 다른 것 먼저 해라
직접 손으로 하는 것을 게을리 해서는 안된다.
하지만 전문 도메인 지식 없으면 어렵다.

- train set에서 레이블 수정이 가치가 있는 경우

1. random error
딥러닝은 상대적으로 이 error에 강함
이럴 경우, 혹은 토탈 데이터 세트 사이즈 크고, 오류 퍼센트 크지 않으면 수정하지 않아도 좋음

2. system error

딥러닝은 이 error에 강하지 않음

ex) 레이블 한 사람이 지속적으로 흰색의 강아지를 고양이로 레이블한 경우

-> 분류기가 모든 흰색 강아지를 고양이로 분류하도록 배웠기 때문

=> 수정 필요

- dev set, test set에서 레이블 수정이 가치가 있는 경우

- 레이블 수정에 고려 사항

1. dev, test 세트에 동일한 프로세스를 적용하여 동일한 분포 유지

2. 알고리즘이 틀린 사례, 맞은 사례 모두 검토

3. train과 dev, test 데이터는 미묘하게 다른 분포로부터 나올지도 모른다.

3) Bulid your first system quickly, then iterate

- Build your first system quickly

시스템을 먼저 만들고, 테스트를 반복

처음부터 어렵게 가지 말고 서서히 고쳐나가는 것 중요

첫째를 빨리 만들어서 살을 붙여나가는 것 중요

- Build your first system quickly 절차

1. 학습이 완료된 시스템의 구축
2. 학습이 완료된 시스템을 통해 편향/편차를 조절
3. 시스템 우선순위를 결정하는 것
4. 오류 분석을 가능하게하고, 실수 확인
5. 이에 맞는 수많은 접근 방식과 방향성을 알아내서, 어떤 부분이 가장 값어치가 있는지 알아내는 것

2. Mismatched training and dev/test set

1) Traning and testing on different distributions

1. option1
장점 : 훈련, 개발, 테스트 모두 같은 분포도로 관리하기 쉬움
단점 : 2500개의 개발 세트 보면 진정 관심있는 앱의 이미지보다 웹페이지의 분포가 주축

2. option2
장점 : 개발 세트에 관심있어하는 분포의 이미지 적용.

모바일 앱 이미지 분포에서 잘 작동하는 머신 러닝 시스템을 만드는 것 가능

단점 : 훈련 분포가 당신의 개발과 테스트 세트 분포와 다르다는 것

그러나 장기적으로 더 좋은 결과 창출

=> option2 사용해야 한다.

핵심 데이터는 dev, test에 전부 집어넣는다.

2) Bias and Variance with mismatched data distributions

- 분석의 문제 2가지

1. 트레이닝 세트의 데이터는 봤지만, dev 세트의 데이터는 그렇게 하지 못함.
-> 일반적은 편차문제, dev세트에서 일반화 시키지 못함.

2. dev 세트의 데이터 분포도가 트레이닝 세트와 다름 (데이터 미스매치 문제)

- training-dev set 정의

트레이닝 세트 <-> dev, test set
training-dev : 트레이닝 세트에서 추출한 부분집합 (트레이닝 세트와 동일한 분포)
-> 어떤 문제인지 확인 가능

ex) 트레이닝 오류 1%, training-dev 오류 1.5%, dev 10%

낮은 편차의 문제, 전형적인 데이터 미스매치 문제(데이터 분포도 다름)

- 오류의 차이에서 확인 할 것

1. avoidable bias와 편차 확인
2. 데이터 미스매치 문제

3) 데이터 불일치 해결법(traing <-> dev, test 다른 분포)

1. traing <-> dev, test 차이를 이해하고 수동 오류 분석을 수행.

기술적으로 오류 분석을 하기위해 테스트 세트가 아닌 개발 세트만 수동으로 확인
특성 파악할 수 있다면 train 데이터를 보다 유사하게 만들 수 있는 방법 찾는다.

2. train 데이터를 dev, test와 유사하게 만든다.

또는 유사한 데이터를 더 수집한다.

3 Learning from multiple tasks

1) Transfer learning

- 개요

학습된 모델을 가져와서 사용
마지막 레이어 제외하고, 학습된 레이어 가져와 마지막 레이어를 알맞게 학습시킨다.
즉 마직막 층을 위한 무작위로 초기화된 weight 세트를 생성

- 학습하는 방법 종류

1. 새로운 데이터양이 적을 때
나머지는 매개변수는 고정하고 마지막 층만 retrain

2. 새로운 데이터양 조금 더 있을 때

출력층 가까운 곳부터 조금씩 줄여나간다.

3. 새로운 데이터양 많으면

모든 신경망의 매개 변수를 다시 학습 시킨다.

* pre-training -> fine tuning

ex) 이미지 인석 기능에서 습득한 지식을 방사선학 진단하는데 적용 또는 진단법에 그 지식을 트렌스퍼 시킨 것입니다.

이것이 도움을 줄 수 있는 이유는, edges를 감지하는 특성, 커브 감지, poitive object를 감지하는 특성들과 같이 수 많은 low level 특성 때문입니다.
이러한 아주 큰 이미지 인식 데이터세트에서 내용을 익히는 것이, 러닝 알고리즘이 방사선학 진단에 도움이 되도록 해줄 것입니다.
이미지의 구조가 어떻게 되는지, 이미지가 어떻게 생겼는지에 대해 많이 익힌 지식 내용이 유용할 수 있습니다.

- 성립하기 위한 조건 (업무A -> 업무B)

1. 업무 A와 B가 같은 타입의 X를 가져야 한다.
2. 업무 B보다 A가 더 많은 데이터 가져야 한다.
(업무 B에 있어 B가 더 값진 데이터이기 때문에)
3. A로부터 낮은 층의 특성들이 B에 도움이 될 수 있을 것 같다고 판단되는 경우

2) Multi-task learning

- 개요

한 모델에서 여러 가지 일을 하는 것
복수의 레이블 존재
하나의 모델로 4개의 문제를 푸는 것과 같다.
4개의 모델 따로 가져서 합치는 것보다 더 좋은 성능 가진다.
? 제외하고 레이블 되어있는 것만 이용하다.

- 언제 사용하는가?

1. shared low-level features로부터 이득을 볼 수 있는 업무들을 학습 시킬 때,

자율주행차 같은 경우엔, '신호등, 보행자, 차량'을 인식하는 것이 'stop sign'과 같은 것을 인식하는 것에 도움을 줄 수 있는 특성과 비슷할 것입니다. 이것들은 모두 도로의 특성을 가지고 있기 때문입니다.

2. 업무마다 데이터양이 비슷할 때

multi-task 러닝에서 부스트 효과가 있으려면, 다른 업무의 총 데이터 합산 양이 다른 업무에 비해 훨씬 더 많아야 한다는 것

3. 큰 신경망을 트레이닝 시키는 경우에만

그렇기 때문에 multi-task 러닝의 대안은 각각의 업무에 대해서 개별적으로 신경망을 트레이닝 시키는 것.

3) 요점 정리

1. transfer learning

오늘날 더 많이 사용.
데이터량이 적은데서 문제를 해결하기 위해 많이 사용.

2. multi-task learning

잘하고 싶어하는 업무의 양이 굉장히 큰 경우 드물기 때문에 적게 사용
사용하는 대표적인 경우는 컴퓨터 비전. 여러 가지 물체를 한 번에 감지하는 어플 많음
이 경우에는 물체를 감지하는데 있어, 따로 신경망을 트레이닝 시키는 것보다 잘 작동.

4. End to end deep learning

1) What is end-to-end deep learning

- 개요

엔드 투 엔드 딥 러닝이 하는 일은 여러 단계를 거치는 것 들을 수행하고 하나의 신경 네트워크로 변환

- 특성

중간 피쳐를 확인하는 방식은 아니다. 방대한 데이터 양 필요하다.

- 장점

1. 완벽한 학습을 통해 데이터가 말을 할 수 있도록 하는 것입니다.
만일 여러분이 충분한 X, Y데이터를 가지고 있다면, X에서 Y에 이르기까지 가장 적절한 기능 지도를 만들어 낼 것
2. 필요한 구성품의 수동 설계가 더 적다는 것 -> 설계 작업 흐름을 단순화

- 단점

1. 데이터 많이 필요
2. 유용한 수동 설계 요소를 배제 (손을 많이 쓸 수 없다.)
훈련 세트가 작을 경우 데이터에서 얻을 수 있는 통찰력이 부족
따라서 수동으로 부품을 설계하는 것이 더 좋을 수 있다.
데이터가 많지 않을 때는 조심스럽게 손으로 설계 한 시스템을 사용하면 실제로 인간이 문제에 대한 많은 지식을 알고리즘에 투입 할 수 있고, 매우 도움이 될 것

- 결정 포인트

만약 여러분이 새로운 기계 학습 시스템을 구축하고 있고 깊이 있는 학습을 사용할지 여부를 결정하기 위해 노력하고 있다면, 중요한 질문은, X에서 Y에 이르기까지 지도를 그리는데 필요한 복잡성의 함수를 배울 수 있는 충분한 데이터가 있는가를 확인하는 것.

[딥러닝 기본] ML Strategy 1 (human-level performance)

냉철한 욱 — Fri, 1 Apr 2022 08:28:58 +0900

* 출저

1. Introduction to ML Strategy

1) Why ML Strategy?

2) Orthogonalization

2. Setting up your goal

1). Single number evaluation metric

- idea – code – experiment

- 다양한 평가지표

평가지표 : Precision, Recall
새로운 평가지표 : F1 score
또 다른 방법 : 알고리즘 대륙 전체 평균

2). Satisficing and Optimizing metric

- Satisficing(최소한의 충족) + optimizing(최적화)

ex) 종합 평가 수치 = 러닝타임 + 정확도

3) Train, dev, test distributions

- 무작위로 섞인 데이터 분포도 활용해야 한다.

- 같은 분포도를 가지는 Train, dev 활용

train, dev 같은 목표를 타깃 해야 한다.
dev set 설정하는 방법과 validation metric 중요.
어떠한 목표를 타깃하는지 정의

- 어떻게 트레이닝 세트를 설정하는가에 따라서 얼마나 잘 목표를 맞추는지 결정 가능.

ex) 저소득층, 고소득층 데이터 활용 x

4) Size of the dev and test sets.

- 많은 데이터 셋을 가지는 경우 : 98% 트레이닝 세트, 1% dev, 1% 테스트로 분배가 합리적.

큰 데이터 세트를 보유하고 있는 것에 대한 문제점이 상당부분 트레이닝 세트로 이전

- size of test set 유연하게 조절

테스트 세트의 목적은 시스템 개발을 마친 이후로는, 테스트 세트가 마지막 시스템이 얼마 나 좋은지 평가하는데 도움
테스트 세트를 적당히 크게 하여 전반적인 시스템의 성능의 컨피던스 레벨이 높을 수 있도 록 하는 것
그렇기 때문에 마지막 최후 시스템이 얼마나 잘 작동하는지 매우 자세히 알아야 하는 것이 아니라고 하면 수백만 개의 example이 필요치 않을 것

5) When to change dev/test sets and metrics

- metric change 개요

dev set와 평가 매트릭 지표를 세팅하는 것은 팀이 목표를 지향할 수 있도록 방향성을 제시하는 것과 같다.
하지만 프로젝트 진행도중에 잘못된 방향이었다는 것을 뒤늦게 깨닫는 경우도 있다.
이런 경우엔, 목표를 이동해야 한다.
오류 있을 경우 새로운 매트릭(목표)를 정의해야한다.

ex) 성능이 좋은 A알고리즘에 오류값에 포르노 사진이 있다면? : 잘못된 알고리즘

=> 새로운 매트릭 정의 필요 : 포르노 사진에 가중치를 더 두는 손실함수 설정 필요)

- metric change 단계

1단계 : 목표 설정 (매트릭 정의)
2단계 : 튜닝 (어떻게 하면 이 메트릭이 성능을 잘 발휘할지 생각)

- dev/test sets change 개요

고품질 이미지로 알고리즘 구현했지만 실제 어플에서는 저품질 이미지 사용?
=> 데이터 셋을 변경할 필요가 있다.

3. Comparing to human-level performance

1). Why human level performance?

- 머신러닝 시스템 vs 인간레벨 시스템

첫째 : 딥러닝의 발전으로, 머신러닝 알고리즘 잘 구동.
인간레벨 서능과 비교했을 때, 이와 견줄만한 정도로 알고리즘 실효성 입증

둘째 : 인간이 할 수 있는 영역에서, 머신러닝 시스템을 디자인하고 수행절차 설립과정 이전에 비해 효율적으로 발전.

(시스템 발전 등)

- Bayes error (Bayes optimal error)

어떤 오디오는 너무 시끄러워서 어떤 내용이 들어있는지 판단 불가
어떤 이미지는 너무 흐릿하여 이미지가 고양이 사진인지 판단 불가
=> 이런 오류들 다 제외한 오류가 Bayes error

- 정확도는 인간레벨성능을 능가한 이후로 느려짐.

1. 인간레벨성능이 Bayes error와 많이 떨어져 있지 않다.
(인간은 보통 이미지를 구분하고 고양이인지 여부를 확인하는데 능숙, 오디오를 들어서 표기화 하는 것에 능숙)
=> 인간레벨성능을 이미 능가한 시점에서는 더 발전할 수 있는 부분 제한적

2. 인간레벨성능에 미치지 못하는 이상, 여러 가지 툴을 이용하여 성능을 발달시킬 수 있는 부분 있다.

하지만 인간레벨성능 초과시점부터는 사용하기 어렵.

=> 인간이 잘 수행하는 업무 : 인간으로부터 labeled data 습득 가능

=> 인간이 알고리즘보다 더 능숙한 성능 : 인간에게 물어봐 통찰력 기를 수 있다.

=> 편향, 편차

2) Avoidable bias

- 1. 사례 : 인간레벨성능 1% 오류 (ex)고양이 인식 프로그램)
트레이닝 오류 : 8%
dev 오류 : 10%
트레이닝 세트에서의 알고리즘 성능과 인간의 차이가 매우 큼
트레이닝 세트에서 잘 피팅되고 있지 않다. => Bias 문제에 중점
=> 해결안 : 더 큰 신경망 트레이닝 하거나 더 오래 동안 학습.

- 2. 사례 : 인간레벨 성능 7.5% 오류 (ex)고양이이미지가 너무 흐리거나 품질 이상)

트레이닝 오류 : 8%

dev 오류 : 10%

트레이닝 세트에서의 알고리즘 성능과 인간의 차이가 매우 작음 => variance 문제에 중점

=> 해결안 : 일반화 시도

- 인간레벨오류를 Bayes error의 추정치로 생각

컴퓨터비젼 영역에서는 매우 합리적인 프록시 값.
사람이 컴퓨터 비전영역에서 능숙하기에
그리고 대부분 인간레벨오류는 Bayes error에 크게 떨어져 있지 않다.

- avoidable bias

Bayes error 또는 Bayes error(인간레벨오류)의 근사치와 트레이닝 오류의 차이
avoidable bias는 용어 자체가 최소의 오류 값이나 특정 오류가 있다는 것을 인정

Bayes error는 7.5퍼센트인 경우 이 이하로 내려갈 수 없다는 뜻도 내포

=> 트레이닝 오류가 8퍼센트라고 이야기하기 보다는, 8퍼센트는 바이어스의 측정수치

해당 예시에서는 avoidable bias가 0.5퍼센트이거나, 2퍼센트는 편차 수치

3) Understanding human-lavel performance

- 사례

0.7% 오류에 도달했을 때, Bayes error를 추정하는데 신경 쓰지 않는 이상, Bayes error에서 얼마나 떨어져 있는지 알기 어렵. (의사팀인 0.5%를 기반으로 Bayes error를 추정해야 avoidable bias 측정 가능)
그러므로 avoidable bias를 얼마나 줄여야 할지도 모른다.

=> 인간라벨성능과 가까운 선상에 있는 경우, 바이어스와 편차효과를 제거하기가 굉장히 더 어렵.

결과적으로는 더 잘하면 잘할수록 머신러닝에서 발전을 이루기가 점진적으로 어렵

- 정리

1) 인간레벨성능의 추정치를 알면 Bayes error의 예상 값을 알 수 있음
2) 알고리즘에서 바이어스의 값을 줄일지, 편차 값을 줄일지 의사결정
=> 이런 테크닉은 인간레벨성능을 도달하기 전까지는 잘 작동

이후로는 Bayes error 추정 값이 구하기 어렵기 때문에 의사결정을 내리는데 어려움

4) Surpassing human-level performance

- 사례 (인간레벨성능을 뛰어넘는 사례)

1. 온라인 광고 (한 사람이 광고를 클릭할 확률)
2. 영화나 책 추천.
3. A지점에서 B까지 운전하여 이동하는데 얼마나 걸릴지 예측
4. 대출금을 갚을 확률
=> 이러한 유형의 특성은 구조화된 데이터를 기반.(데이터베이스를 기반)
자연적으로 인지되는 문제들 아니다. (컴퓨터의 영역, 음성인식, 자연처리)
=> 아주 방대한 데이터 양 보유.
인간이 볼 수 있는 데이터 양보다 훨씬 더 많이 조회
이런 부분이 컴퓨터가 그래도 어느 정도 쉽게 인간레벨 따라 잡을 수 있는 요소

- 단점

컴퓨터가 조사할 수 있는 데이터가 너무 많으므로 그래서 그것은 심지어 인간의 생각도 패턴화하며 왜곡

- 전망

최근에는 음성인식분야에서도 인간레벨성능을 뛰어넘는 수준.
컴퓨터 영역과, 이미지 인식 업무도 마찬가지로, 인간레벨성능을 뛰어 넘고 있음.
사실 인간은 자연적으로 인식하는 업무에 굉장히 뛰어나기 때문에, 컴퓨터가 현재자리까지 도달하기 어려웠던 부분 많음.
하지만 충분한 데이터양 확보된다면 지도학습 분야에서 인간레벨성능을 뛰어넘는 경우 많아질 것.

5) Imporving your model performance

[Python, 정리] Pandas - 데이터 그룹연산

냉철한 욱 — Mon, 28 Mar 2022 08:12:53 +0900

1. GroupBy

=> 그룹연산 : Split 분리 - Apply 적용 - Combine 결합

그룹의 색인은 다양한 형태가 될 수 있으며, 모두 같은 타입일 필요도 없다.

. 그룹으로 묶을 축과 같은 길이의 리스트나 배열

. DataFrame의 칼럼 이름을 지칭하는 값

. 그룹으로 묶을 값과 그룹 이름에 대응하는 사전이나 Series 객체

. 축 색인 혹은 색인 내의 개별 이름에 대해 실행되는 함수

df = DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'],

'key2' : ['one', 'two', 'one', 'two', 'one'],

'data1' : np.random.randn(5),

'data2' : np.random.randn(5)})

1.

grouped = df['data1'].groupby(df['key1'])

grouped.mean()

2.

means = df['data1'].groupby([df['key1'], df['key2']]).mean()

means

3.

states = np.array(['Ohio', 'California', 'California', 'Ohio', 'Ohio'])

years = np.array([2005, 2005, 2006, 2005, 2006])

df['data1'].groupby([states, years]).mean()

4.

df.groupby('key1').mean() : key2는 숫자데이터가 아니기 때문에 결과에서 제외

df.groupby(['key1', 'key2']).mean()

df.groupby(['key1', 'key2']).size()

2. GroupBy - 그룹 간 순회하기

- 그룹 이름과 그에 따른 데이터 묶음을 튜플로 반환한다.

1.

for name, group in df.groupby('key1'):

print(name)

print(group)

2.

for (k1, k2), group in df.groupby(['key1', 'key2']):

print((k1, k2))

print(group)

3. 사전형으로 바꿔서 인덱싱 할 수 있다.

pieces = dict(list(df.groupby('key1')))

pieces['b']

4.

grouped = df.groupby(df.dtypes, axis=1)

dict(list(grouped))

3. GroupBy - 색인 : 칼럼 또는 칼럼의 일부만 선택하기.

- df[['data2']].groupby([df['key1'],df['key2']]).mean()

- df.groupby(['key1', 'key2'])[['data2']].mean() : 포맷이 데이터프레임이다.

- s_grouped = df.groupby(['key1', 'key2'])['data2'] : 포맷이 시리즈이다.

s_grouped.mean()

4. GroupBy - 색인 : 사전과 Series에서 묶기.

- 사전

people = DataFrame(np.random.randn(5, 5), columns=['a', 'b', 'c', 'd', 'e'], index=['Joe', 'Steve', 'Wes', 'Jim', 'Travis'])

people.ix[2:3, ['b', 'c']] = np.nan # Add a few NA values

mapping = {'a': 'red', 'b': 'red', 'c': 'blue', 'd': 'blue', 'e': 'red', 'f' : 'orange'}

by_column = people.groupby(mapping, axis=1)

by_column.sum()

- Series

map_series = Series(mapping)

people.groupby(map_series, axis=1).count()

5. GroupBy - 색인 : 함수로 묶기

people.groupby(len).sum()

key_list = ['one', 'one', 'one', 'two', 'two']

people.groupby([len, key_list]).min()

6. GroupBy - agg

=> 자신만의 데이터 집계 함수를 사용하려면 배열의 agg나 aggregate 메서드에 해당 함수를 넘기면 된다.

df = DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'], 'key2' : ['one', 'two', 'one', 'two', 'one'], 'data1' : np.random.randn(5), 'data2' : np.random.randn(5)})

1.

def peak_to_peak(arr):

return arr.max() - arr.min()

grouped = df.groupby('key1')

grouped.agg(peak_to_peak)

2.

grouped.describe()

7. GroupBy - 칼럼에 여러 가지 함수 적용하기

=> 칼럼에 따라 다른 함수를 사용해서 집계를 수행하거나 여러 개의 함수를 한 번에 적용

grouped = tips.groupby(['sex', 'smoker'])

1. 기본

grouped_pct = grouped['tip_pct']

grouped_pct.agg('mean')

2. 여러 개의 함수 하나의 칼럼에 적용

grouped_pct.agg(['mean', 'std', peak_to_peak])

3. 여러 개의 함수 하나의 칼럼에 적용 - 이름 바꾸기

grouped_pct.agg(['mean', 'std', peak_to_peak])

4. 여러 개의 함수 여러 칼럼에 적용

functions = ['count', 'mean', 'max']

result = grouped['tip_pct', 'total_bill'].agg(functions)

result

result['tip_pct']

5. 여러 개의 함수 여러 칼럼에 적용 - 이름 바꾸기

ftuples = [('Durchschnitt', 'mean'), ('Abweichung', np.var)]

grouped['tip_pct', 'total_bill'].agg(ftuples)

6. 여러 개의 함수 각 칼럼 마다 다르게 적용

=> 사전 이용

grouped.agg({'tip' : np.max, 'size' : 'sum'})

grouped.agg({'tip_pct' : ['min', 'max', 'mean', 'std'], 'size' : 'sum'})

7. 색인되지 않은 형태로 집계된 데이터 반환

tips.groupby(['sex', 'smoker'], as_index=False).mean()

=> as_index = False

8. GroupBy - 그룹별 연산 APPLY

=> 분리 - 적용 - 병합

=> 객체를 여러 조각으로 나누어 전달된 함수를 각 조각에 일괄적으로 적용한 후 이를 다시 합치게 된다.

def top(df, n=5, column='tip_pct'):

return df.sort_index(by=column)[-n:]

tips.groupby('smoker').apply(top)

tips.groupby(['smoker', 'day']).apply(top, n=1, column='total_bill')

tips.groupby('smoker', group_keys=False).apply(top)

=> gruoup_keys=False : 그룹 색인 생략하기

9. 피벗테이블 - GroupBy를 편리하게

1.

tips.pivot_table(index=['sex', 'smoker'])

2.

tips.pivot_table(['tip_pct', 'size'], index=['sex', 'day'], columns='smoker')

3. margins = True 는 합산값 구하기

tips.pivot_table(['tip_pct', 'size'], index=['sex', 'day'], columns='smoker', margins=True)

4. aggfunc=len 은 len 함수 적용하기, 디폴트는 mean이다

tips.pivot_table('tip_pct', index=['sex', 'smoker'], columns='day', aggfunc=len, margins=True)

5. fll_value = 0 비어 있는 곳은 0 집어 넣기.

tips.pivot_table('size', index=['time', 'sex', 'smoker'], columns='day', aggfunc='sum', fill_value=0)

[Python, 정리] Pandas - 데이터 처리

냉철한 욱 — Mon, 28 Mar 2022 08:05:21 +0900

1. 데이터베이스처럼 DataFrame 합치기. - merging (병합)

df1 = pd.DataFrame({"key" : list("bbacaab"), "data1":range(7)})

df2 = pd.DataFrame({"key" : list("abd"), "data1":range(3)})

pd.merge(df1,df2,on="key")

pd.merge(df1,df2,on="key",how="outer")

pd.merge(df1,df2,on="key",how="left")

pd.merge(df1,df2,on="key",how="right")

pd.merge(df1,df2,on="key",how="inner")

pd.merge(left, right, on='key', suffixes=('_left', '_right'))

-> suffixes인자는 각각의 key열 이름 뒤에 붙는다.

- 기준 열 이름이 다를 때.

df3 = pd.DataFrame({"lkey":list("bbacaab"),"data1:range(7)})

df4 = pd.DataFrame({"rkey":list("abd"),"data2:range(3)})

pd.merge(df3,df4,left_on="lkey",right_on = "rkey")

- 한 쪽 데이터프레임은 index 기준.

left1 = pd.DataFrame({"key" : ["a","b","a","a","b","c"], "value" : range(6)})

right1 = pd.DataFrame({"group_val" : [3.5,7]}, index=["a","b"])

pd.merge(left1,right1,left_on = "key",right_index=True)

pd.merge(right1,left1,left_index = True, right_on = "key")

pd.merge(left2, right2, how="outer", left_index = True, right_index = True)

2. 데이터베이스처럼 DataFrame 합치기

- concatenating : 연결, 이어붙이기

s1 = pd.Series([0,1], index = ["a","b"])

s2 = pd.Series([2,3,4],index=["c","d","e"])

s3 = pd.Series([5,6],index=["f","g"]

pd.concat([s1,s2,s3]) : Series로 출력

pd.concat([s1,s2,s3],axis=1) : DataFrame으로 출력

s4 = pd.concat([s1*5,s3])

- 컬럼의 이름을 지정 할 때

pd.concat([s1,s2,s3],axis=1,keys=["one","two"three"])

- 데이터프레임일 경우

df1 = pd.DataFrame(np.arange(6),reshape(3,2),index=["a","b","c"],columns=["one","two"])

df2 = pd.DataFrame(5+np.arange(4),reshape(2,2),index=["a","c"],columns=["three","four"])

pd.concat([df1,df2],axis=1)

df3 = pd.DataFrame(np.random.randn(3,4),columns=["a","b","c","d"])

df4 = pd.DataFrame(np.random.randn(2,3),columns=["b","d","a"])

pd.concat([df3,df4], ignore_index=True) : 인덱스 무시하고 인덱스 다시 부여해준다.

- 그 밖의 인자

join = "inner" : 공통된 인덱스만 남긴다

join_axes = [df1.index] : df1의 인덱스에 맞춘다.

3. 계층적 인덱싱 이해하기

- 시리즈

s = pd.Series(np.random.randn(10), index =[["a","a","a","b","b","b","c","c","d","d"],[1,2,3,1,2,3,1,2,2,3]])

s.index

s["b"]

s["b":"c"]

s[("b",3)] : b계층의 3번째 값

s[:,2] : 모든 계층의 2번째 값

- 데이터프레임

df = pd.DataFrame(np.arange(12).reshape((4,3)),index=[["a","a","b","b"],[1,2,1,2]],columns=[["Seoul","Seoul","Busan"],["Green","Red","Green"]]) => 인덱스와 칼럼 모두 2차원 설정으로 계층 표현

df.index.names = ["key1","key2"]

df.columns.names=["city","color"]

df["Seoul"] : 서울에 해당하는 하위계층만 나온다.

df[("Seoul","Green")] : 시리즈형태로 하위계층 표현

df.loc["a"]

df.loc[("a",1)] : 행을 2차원으로 표현

df.loc["b",("Seoul","Red")] : 열을 2차원으로 표현

df.loc[("b",2),"Busan"]

df.loc[("b",1),("Seoul","Green")]

- 데이터프레임 정렬

df.sort_index(axis = 0, level =0) : 행방향으로 key1기준으로 정렬

df.sort_index(axis = 0, level = 1) : 행방향으로 key2기준으로 정렬

df.sort_index(axis = 0, level = "key2") : 행방향으로 key2 기준으로 정렬

df.sort_index(axis=1,level=0)

df.sort_index(axis=1,level=1)

df.sort_values(by=("Busan","Green")) : 부산의 그린 값 기준

- 데이터프레임 계산

df.sum(axis=0, level=0) : ab로 나누어 합을 구한다.

df.sum(axis=0, level=1) : 1,2로 나누어 합을 구한다.

df.mean(axis=1,level="color") : color 열로 나누어 열방향으로 평균 구한다.

- 계층으로 변환

df2 = pd.DataFrame({"a" : range(7), "b" : range(7,0,-1), "c" : ["one","one","one","two","two","two","two"],"d":[0,1,2,0,1,2,3]})

df3 = df2.set_index(["c","d"]) : c,d가 계층적 인덱스가 된다.

df2.set_index(["c","d"],drop=False) : c,d 열 그대로 있는다.

df3

df3.reset_index() : 원위치

4. 계층적 색인으로 재형성하기

stack : 데이터의 칼럼을 로우로 피벗 또는 회전시킨다.

unstack : 로우를 칼럼으로 피벗시킨다.

df4 = pd.DataFrame(np.arange(6),reshape((2,3)).index=["Seoul","Busan"],columns=["one","two","three"])

df4.index.name = "city"

df4.columns.name = "number"

df5 = df4.stack() : 컬럼을 열의 하위계층 인덱스로 변환

df5.unstack() : 최하위 인덱스를 컬럼으로 올려준다.

df5.unstack(level=0) : 0번 인덱스에 해당하는 최상위계층 인덱스를 컬럼으로 올려준다.

df5.unstack(level="city")

a1 = pd.Series([0,1,2,3],index = ["a","b","c","d"])

a2 = pd.Series([4,5,6], index = ["c","d","e"])

a3 = pd.concat([a1,a2],keys=["one","two"])

=> 계층적

a3.unstack()

df6 = pd.DataFrame({"left":df5, "right" : df5+5},columns=["left","right"])

df6.columns.name = "side"

df6

df6.unstack() : 최하위에서 최하위로 간다.

df6.unstack(level="city")

df6.unstack(level="city").stack(level="side")

- stack은 누락된 데이터 자동으로 걸러낸다.

s1 = Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])

s2 = Series([4, 5, 6], index=['c', 'd', 'e'])

data2 = pd.concat([s1, s2], keys=['one', 'two'])

data2.unstack()

data2.unstack().stack() : 자동으로 걸러낸다.

data2.unstack().stack(dropna=False) : na를 삭제하지 않는다.

5. 데이터프레임 데이터 변형하기 - 중복 제거하기

df = pd.DataFrame({"k1" : ["one"] * 3 + ["two"] * 4, "k2" : [1, 1, 2, 3, 3, 4, 4]})

df.duplicated() : 중복된 행들을 마스크로 표현해준다.

df.drop_duplicates() : 중복된 행들을 제거해준 데이터프레임 도출

df["v1"] = np.arange(7)

df.drop_duplicates() : 아무것도 삭제되지 않는다. , v1으로 인하여 다 독립적이기 때문에

df.drop_duplicates(["k1"])

df.drop_duplicates(["k1","k2"],keep = "last") : 남길 때 맨 처음 것을 남길지 맨 마지막 것을 남길지 선택이 keep

df.drop_duplicates(["k1","k2"])

6. 데이터프레임 데이터 변형하기 - 맵핑해서 새로운 열 추가

- 함수 적용과 맵핑, NumPy의 유니버설 함수처럼 적용

apply : 각 로우나 칼럼의 1차원 배열에 함수를 적용

applymap : 배열의 각 원소에 함수를 적용

map : Series가 각 원소에 함수를 적용

1. apply

frame = DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])

f = lambda x: x.max() - x.min()

frame.apply(f)

frame.apply(f, axis=1)

def f(x):

return Series([x.min(), x.max()], index=['min', 'max'])

frame.apply(f)

2. applymap

format = lambda x: '[%.2f]' % x

frame.applymap(format)

3. map

frame['e'].map(format)

- 새로운 열 추가

df2 = pd.DataFrame({"food" : ["bacon","pulled pork","bacon","Pastrami","corned beef","Bacon","pastrami","honey ham","nava lox"], "ounces" : [4,3,12,6,7.5,8,3,5,6]})

=> 대소문자 차이 존재

meat_to_animal = { "bacon" : "pig", "pulled pork" : "pig", "pastremi" : "cow" , "corned beef" : "cow" , "honey ham" : "pig", "nava loc" : "salmon"}

df2["animal"] = df2["food"].apply(lambda x: meat_to_animal[x.lower()]) : lower은 소문자로 치환

7. 데이터프레임 데이터 변형하기 - 값 치환하기

data = pd.Series([1.,-999.,2.,-999.,-1000.,3.])

data2 = data.replace(-999,np.nan)

data2.replace(np.nan, 0)

data2.fillna(0)

data.replace([-999, -1000], np.nan) : -999, -1000 모두 np.nan으로 치환

- -999를 np.nan로 치환, -1000을 0으로 치환

data.replace([-999, -1000], [np.nan, 0])

data.replace({-999: np.nan, -1000: 0})

8. 데이터프레임 데이터 변형하기

- 개별화와 양자화(카테고리, 범주형 데이터)

-> 카테고리 자료형 : 사회과학 서베이 데이터셋에서 자주 보인다

df3 = pd.DataFrame({"id" : [1,2,3,4,5,6], "raw_grade":["a","b","c","a","a","a","e"]})

df3["grade"] = df3["raw_grade"].astype("category")

df3["grade"] : 확인할 수 있다.

- 카테고리 값 변경

df3["grade"].cat.categories

df3["grade"].cat.categories = ["very good","good","very bad"]

- 카테고리 값 추가

df3["grade] = df3["grade"].cat.set_categories(["very bad","bad","medium","good","very good"])

- 정렬

df3.sort_values(by = "grade") : 카테고리화에서 정의된 순서대로 오름차순으로 정렬된다.

- 숫자데이터를 카테고리화 : 조건을 부여하여 카테고리화 x -> 판다스에서는 더 편리한 방법

ages= [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]

bins = [18,25,35,60,100]

cats = pd.cut(ages, bins)

cats = pd.cut(ages, bins, right=False) : 괄호와 대괄호 위치 변경

group_names = ["Youth","YoungAdult","MiddleAged","Senior"]

cats = pd.cut(ages, bins, labels=group_names) : 그룹의 이름 직접 넘겨 줄 수 있다.

cats.categories : 객체, 그룹 이름이 담긴 배열

cats.codes : 속성,

cats.value_counts() : 개수 확인

- 숫자데이터를 카테고리화 : 그룹의 경계값을 넘기지 않고 그룹의 개수를 넘겨준다

=> 최소 값과 최대 값을 기준으로 균등한 길이의 그룹을 자동으로 계산한다.

data = np.random.rand(20)

pd.cut(data,4, precision = 2) :

- 숫자데이터를 카테고리화 : 그룹의 경계값을 넘기지 않고 그룹의 개수를 넘겨준다

=> 분위수로 나눈다.

data2 = np.random.randn(1000)

cats = pd.qcut(data2, 4)

pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.]) : 분위수를 직접 지정할 수도 있다.

9. 데이터프레임 데이터 변형하기 - 특이값 찾아내고 제외하기

np.random.seed(12345)

data = DataFrame(np.random.randn(1000, 4))

data.describe()

col = data[3]

col[np.abs(col) > 3]

data[(np.abs(data) > 3).any(1)] : 3을 초과하는 값이 들어있는 모든 로우 선택한다. any메소드 사용

data[np.abs(data) > 3] = np.sign(data) * 3

data.describe()

-> -3이나 3을 초과하는 값을 -3 혹은 3으로 지정할 수 있다.

np.sign은 유니버설 함수, 주어진 값이 부호에 따라 1이나 -1이 담긴 배열을 반환한다.

[Python] pandas 사용하기

냉철한 욱 — Mon, 28 Mar 2022 07:58:38 +0900

Series

1. pandas, numpy 라이브러리 추출하기.

import pandas as pd

import numpy as np

2. series 만들기, 속성

obj = pd.Series([4,7,-5,3])

obj.values : 시리즈의 값만을 array로 표현

obj.index : 인덱스 값만을 표현

obj.dtypes : int라는 것을 확인

-원하는 인덱스 대입할 수 있다.

obj2 = pd.Series([4,7,-5,3],index=["d","b","a","c"])

- 딕션어리 형태로도 만들 수 있다.

sdata = {"charles" : 35000, "kilho" : 71000, "hayoung" : 16000, "sangjae":5000}

obj3 = pd.Series(sdata)

- 시리즈 자체와 시리즈 인덱스 자체에만 이름 지정 가능

obj3.name = "Salary"

obj3.index.name = "names"

obj3

- 인덱스 값 변경

obj3.index = ["A","B","C","D"]

3. 인덱싱

obj2['a']

obj2['d']

obj2[['c','a','d']]

obj[[1, 3]]

obj2[obj2>0]

obj['b':'c']

obj['b':'c'] = 5

obj2 * 2

np.exp(obj2)

'b' in obj2

'e' in obj2

4. null 확인

sdata = {'ohio':35000,'texas':71000,'oregon':16000,'utah':5000}

states = ['clifornia','ohio','oregon','texas']

obj4 = Series(sdata,index=states]

pd.isnull(obj4), obj4.isnull()

pd.notnull(obj4)

dataframe

1. dataframe 의미

시리즈의 집합이다. 각 칼럼은 서로 다른 종류의 값(숫자, 문자열, 불리언)을 담을 수 있다.

=> 인덱스 유무가 array와 리스트와 핵심적인 차이

2. dataframe 생성 및 기본.

data = {"names" : ["kilho","kilho","kilho","charles","charles","charles"] , "year" : [2014,2015,2016,2015,2016],"points" : [1.5,1.7,3.6,2.4,2.9]}

df = pd.DataFrame(data)

df.index : 행

df.columns : 열

df.values : 2차원 array 값으로 표현

df.index.name = "Num"

df.columns.name = "Info"

columns는 정확하게 columnsindex이지만, columns라고 부른다.

index는 정확하게 rowindex지만, index라고 부른다.

df2 = pd.DataFrame(data, columns = ["year","name","points","penalty"], index=["one","two","three","four","five"])

df2.index

df2.columns

df2.values

df2.describe() : 계산 가능한 값들을 자동으로 계산해서 표현

df.rename(columns={df.columns[0] : "year"},inplace=True) : 열의 이름을 변경한다.

df.set_index("year",inplace=True) : year열을 인덱스로 사용한다.

3. 열 호출

data = {"names" : ["kilho","kilho","kilho","charles","charles"], "year":[2014,2015,2016,2015,2016], "points":[1.5,1.7,3.6,2.4,2.9]}

df = pd.DataFrame(data,colums=["year","names","points","penalty"],index=["one","two","three","four","five"])

- 1개 열 가져오기

df["year"] : year에 해당하는 값 표현 , index 이름과 함께 표현, 시리즈와 똑같다.

df.year

-복수 개의 열 가져오기

df[["year","points"]] : 중괄호를 두번 쓴다.

- 열 생성

df["penalty"] = 0.5

df["penalty"] = [0.1 ,0.2,0.3,0.4,0.5]

df[df < 5] = 0 : 전체

df["zeros"] = np.arange(5)

val = pd.Series([-1.2,-1.5,-1.7), index=["two","four","five"])

df["debt"]=val

df["new_points"] = df["points"] - df["penalty"]

df["high_points"] = df["net_points"]>2.0

- 열 삭제

del df["high_points"]

del df["net_points"]

del df["zeros"]

- 확인

df.columns : 보고 확인한다.

df.index.name = "order"

df.columns.name = "Info"

4. 행을 선택하고 조작하는 방법 : 인덱싱 및 슬라이싱

=>행을 인덱싱하는 방법 무수히 많다 .

df[0:3]

df["two":"four"]

=> 열하고 헷갈린다. 그래서 비추한다.

- loc사용 : loc : label에 대한 슬레이싱은 마지막 설정값도 범주에 포함시킨다.

df.loc["two"] : 인덱스가 two인 값의 행의 모든 값을 모두 가져온다.

df.loc["two":"four"]

df.loc["two":"four","points"]

df.loc[:,"year"]

df.loc[:,["year","names"]]

df.loc["three":"five","year":"penalty"]

df.loc["six",:] = [2013,"Hayoung",4.0,0.1,2.1]

- iloc 사용 : 값이 location이기 때문에 마지막 설정값을 포함하지 않는다.

df.iloc[3]

df.iloc[3:5,0:2] : 5하고 2에 해당하는 값 포함시키지 않는다. 이 숫자는 label이 아닌 location 값

df.iloc[[0,1,2],[1,2]]

df.iloc[:,1:4]

df.iloc[1,1]

- ix 사용 : 문자와 숫자 전부 활용.

data = DataFrame(np.arange(16).reshape((4, 4)), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['one', 'two', 'three', 'four'])

data.ix['Colorado', ['two', 'three']]

data.ix[['Colorado', 'Utah'], [3, 0, 1]]

data.ix[2]

data.ix[data.three > 5, :3]

- 불리언 인덱싱 - 마스크

df["year"] > 2014

df.loc[df["year"]>2014,;]

df.loc[df["names"] == "kilho",["names","points"]]

df.loc[(df["points"]>2) &(df["points"]<3),:]

df.loc[ df["points"]>3, "penalty" ] = 0

- 3가지 비교

data.ix[['Colorado','Utah'],[3,0,1]]

data.loc['Colorado':'Utah',['four','one','two']]

data.iloc[1:3,[3,0,1]]

data.ix[data.three>5,:3]

data[data.three>5].iloc[:,:3]

data[data.three>5].loc[:,'one':'three']

5. reindexing

1. 0을 채운다.

obj = Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])

obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])

obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)

2. 앞의 값을 채운다.

obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])

obj3.reindex(range(6), method='ffill')

3. row 재색인

frame = DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'], columns=['Ohio', 'Texas', 'California'])

frame2 = frame.reindex(['a', 'b', 'c', 'd'])

4. columns 사용

states = ['Texas', 'Utah', 'California']

frame.reindex(columns=states)

6. 결측치값 및 이상치 조정

df = pd.DataFrame(np.random.randn(6,4))

df.coloumns = ["A","B","C","D"]

df.index = pd.data_range("20160701",periods=6) : 데이터타임 형태 인덱스 중요 , 시계열에 사용 가능

df["F"] = [1.0,np.nan,3.5,6.1,np.nan,7.0] : F열 새롭게 정의,np.nan 인위적으로 포함 시키도록 할때

df.dropna(how="any") : nan가 포함된 행 제거

df.dropna(how="all") : 한 행의 모든 값이 nan일 경우 삭제

df.fillna(value = 5.0) : nan 대신 5.0 대입

df.isnull()

df.loc[df.isnull()["F"],:]

- 특정 행, 열 삭제

Series

obj = Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])

obj.drop('c')

obj.drop(['d', 'c'])

data = DataFrame(np.arange(16).reshape((4, 4)), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['one', 'two', 'three', 'four'])

data.drop(['Colorado', 'Ohio'])

data.drop('two', axis=1) : 열 삭제, del로도 가능

data.drop(['two', 'four'], axis=1)

*다른 예

df.drop([26],inplace = True) : 26번행 제거

del df["열 이름"] : 열 이름 제거

7. 기술통계(통계함수, 분석함수)사용

data = [[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]]

df = pd.DataFrame(data,columns=["one","two"],index=["a","b","c","d"])

- 행, 열 계산

df.sum(axis=0) : 행방향 합을 구한다, 각 열의 합 산출

df.sum(axis=1) : 열방향 합을 구한다. 각 행의 합 산출

=> nan 배제하고 계산한다.

- 특정 열, 특정 열만 계산

df["one"].sum() : one이라는 열만 계산

df.loc["b"].sum() : b라는 행만 계산

- nan 감안해서 계산

df.mean(axis=1,skipna=False)

- NaN에 그 열의 평균값, NaN 그 열의 최소값 넣는다.

one_mean = df.mean(axis=0)["one"]

two_min = df.min(axis=0)["two"]

df["one"] = df["one"].fillna

df["one"] = df["one"].fillna(value=one_mean) : 전체로 사용하지 않을 것

df["two"] = df["two"].fillna(value=two_mean)

- 상관계수, 공분산

df2 = pd.DataFrame(np.random.rand(6.4), columns ["A","B","C","D"],index=pd.data_range("20160701",periods=6))

df2["A"],corr(df2["B"])

df2["B"].cov(df2["C"])

df2.corr() : 모든 열에 관해서 알아서 계산

df2.cov()

8. 정렬함수

인덱스 기준

dates=df2.index

random_dates = np.random.permutation(dates)

df2 = df2.reindex(index=random_dates,columns=["D","B","C","A"])

- 인덱스 오름차순

df2.sort_index(axis=0) : 인덱스 기준, 행방향

df2.sort_index(axis=1) : 칼럼기준, 열방향

- 인덱스 내림차순

df2.sort_index(axis=0,ascending = False)

df2.sort_index(axis=1,ascending = True)

- 값 기준

df2.sort_values(by="D")

df2.sort_values(by="B")

- 동시에 값 기준

df2["E"] = np.random.randint(0,6,size=6)

df2["F"] = ["alpha","beta","gamma","gamma","alpha","gamma"]

df2.sort_values(by=("E","F"])

9. 순위함수

obj = Series([7, -5, 7, 4, 2, 0, 4])

obj.rank()

obj.rank(method='first')

obj.rank(ascending=False, method='max')

frame = DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1], 'c': [-2, 5, 8, -2.5]})

frame.rank(axis=1)

10. 유일 값, 값 세기,포함 여부

df2["F"].unique() : 유일값

df2["F"].value_counts() : 값 세기

df2["F"].isin(["alpha","beta"]) : 포함 여부

df2.loc[df2["F].isin(["alpha","beta"]),:] : 포함 여부 응용

11. 사용자가 직접 정의한 함수 적용

df3 = pd.DataFrame(np.random.randn(4,3),columns=["b","d","e"],index=["Seoul","Incheon","Busan","Daegu"])

func = lambda x: x.max() - x.min()

df3.apply(func, axis=0) : 각 열의 최대에서 최소 값 뺀 값 도출

df3.apply(func, axis=1) : 각 행의 최대에서 최소 값 뺀 값 도출

12. 누락된 데이터 처리

=> NA처리 메서드 - dropna, fillna, isnull, notnull

1. isnull

string_data = Series(['aardvark', 'artichoke', np.nan, 'avocado'])

string_data.isnull()

string_data[0] = None

2. dropna - how, axis 인자

from numpy import nan as NA

data = Series([1, NA, 3.5, NA, 7])

data.dropna()

data[data.notnull()]

data.dropna(how='all')

data.dropna(axis=1, how='all')

3. dropna - thresh 인자

df = DataFrame(np.random.randn(7, 3))

df.ix[:4, 1] = NA; df.ix[:2, 2] = NA

df.dropna(thresh=3) : 몇 개 이상의 값이 들어있는 로우만 살펴보기.

4. fillna

인자 : value, method, axis, inplace, limit

df.fillna(0) : 비어 있는 곳에 0 대입

df.fillna({1:0.5,3:-1}) : 사전 값을 넘겨서 각 칼럼마다 다른 값 대입

df.fillna(method='ffill') : 열의 끝 자리 값을 그대로 대입

df.fillna(method='ffill', limit=2) : 열의 끝 자리 값을 2개 까지만 대입

data = Series([1., NA, 3.5, NA, 7])

data.fillna(data.mean()) : 비어 있는 곳에 평균 값 대입

[Python, 정리] Numpy 사용하기

냉철한 욱 — Mon, 28 Mar 2022 07:48:33 +0900

1 .NumPy, ndarray

- NumPy에는 N차원의 배열 객체인 ndarray가 있고 파이썬에서 사용할 수 있는 대규모 데이터 집합을 담을 수 있는 빠르고 유연한 자료구조이다.

- 모든 원소는 같은 자료형

2. NumPy 객체 만드는 방법 및 함수

- import numpy as np : numpy 라이브러리를 호출

- data = np.arrange(10) : 파이썬의 range 함수의 배열 버전이다. 리스트 대신 ndarray를 반환한다.

- data = [[1,2,3,4],[5,6,7,8]]

arr = np.array[data]

- data = np.zeros(10) : 0 반환, 0으로 초기화 하는 것이다. , 누적합 구할 때 자주 사용.

data = np.zeros((3,6))

- data = np.empty((2,3,2))

zeros와 다르게 값의 메모리에 이미 값이 있으면 0이 아닌 그 값을 반환한다.

- 난수 생성

data = np.random.randn(2,3) : 표준편차 1, 평균 0인 정규분포에서 표본 추출

data = np.random.normal(size=(4,4)) : size는 튜플, 정규분포에서 표본 추출

data = np.random.randint(0,1) : 주어진 최소,최대 범위 안에서 난수 생성

data = np.random.rand(2,3) : 균등분포에서 표본 추출

3. NumPy 객체 속성

shape : 각 차원의 크기를 알려줌

- data.shape

ndim

dtype : 배열에 저장된 자료형을 알려줌

- data.dtype

size

4. NumPy 배열 원소 접근 방법 : 뷰로 생성됨

1) Indexing

- 여러 개의 데이터들의 집합인 뭉탱이에서 색인(요소들을 지칭하는 것)하는 것이다.

- arr[5]

- arr[0][2]

- arr[0,2]

2) Slicing

- 부분범위를 지정하는 것이다.

- arr_slice = arr[5:8]

- 리스트와의 차이점은 배열조각이 원본 배열의 뷰라는 점이다. 뷰에 대한 변경은 원본 배열에 반영한다.

이유 : 대용량 데이터 처리를 염두에 두고 설계되었기 때문에 데이터 복사를 남발한다면 성능과 메모리 문제에 직면할 것이다.

arr_slice[1] = 12345

arr 결과값 : array([0,1,2,3,4,12,12345,12,8,9])

- arr.copy() 함수 사용하면 원본값 유지 할 수 있다.

- 축(axis)이란? : 차원의 개수

벡터는 1차원 배열이기 때문에 축이 1개이면 차원도 1개이다.

[1,2,3,4,5,6,7] -> axis = 0

슬라이싱의 첫번째 기준은 0번축이다.

arr2d[:2], arr2d[:2, 1:] -> 결과값은 2차원배열. 첫번째 기준은 0번축

arr2d[1,:2] -> 결과값은 1차원 배열

* Boolean Indexing

- true, false를 통해 인덱싱, 슬라이싱 할 수 있다.

- 반복기능을 통해 비교해야 하지만 array 같은 경우는 가능하다.

names = ['bob','job','will','bob'] : 리스트

names == 'bob' -> for 문을 돌려야 비교가능하다.

np.array(names)

names == 'bob' -> 한 번에 비교 가능하다.

- 스칼라는 0 아닌 값은 전부 True이다.

- 공백, 문자는 true이다. 문자 없는 경우는 false이다.

Fancy Indexing

- 순서 개념을 입혔다.

- arr[[4,3,0,6]] -> 0번축 기준으로 숫자는 순서를 의미한다.

arr[[1,5,7,2],[0,3,1,2]] -> 좌표라고 생각

- 1 2 3

4 5 6

7 8 9

10 11 12

arr[[3,1,2]][:0:1] : 범위의 값 순서대로 출력

-> 10 11 12

4 5 6

7 8 9

5. Numpy : Brodadcating

- (4,3) + (3) = (4,3)

0 0 0 1 2 3 1 2 3

1 1 1 1 2 3 2 3 4

2 2 2 1 2 3 3 4 5

3 3 3 1 2 3 4 5 6

- 차원 수가 다르면 차원이 적은 쪽에 차원을 추가하는데 이 때 차원 수는 1

- 차원 수가 같으면 차원의 크기가 모두 같거나 한 쪽의 차원의 크기가 1이여지만 브로드 캐스팅이 가능하다

- 차원이 1인 쪽은 상대방 차원의 수와 일치시킨다. - 복제

- R 같은 경우는 제한 없이 복제해서 계산한다.

6. Python : List Comprehension

- names = ['bob','job','will','bob']

result = [name=='bob' for name in names]

- for문 보다 빠르다

7. Python : Generator & Generator Expression

8. NumPy : Universal Function

- 데이터 원소별로 연산을 수행하는 함수.

- 하나 이상의 스칼라 값을 받아서 하나 이상의 스칼라 결과 값을 반환하는 간단한 함수를 고속으로 수행할 수 있는 벡터화된 래퍼 함수라고 생각하면 된다.

- np.sqrt(), np.modf() 등등..

9. np.where() : 조건

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

np.where(arr>0,2,-2)

np.where(arr>0,2,arr)

10. ndarray.sort() vs. numpy.sort()

- ndarray.sort() : in-place operation(직접 데이터를 수정한다.)

- numpy.sort() : returning

[Python, 정리] 데이터 타입 이해하기

냉철한 욱 — Mon, 28 Mar 2022 07:43:50 +0900

1. 데이터 분석을 위해 파이썬을 왜 배우는가?
-  interpreter 언어로 분석과정의 결과를 빠르게 확인 할 수 있다.
- 다양한 데이터 분석 라이브러리를 제공한다.
- 다양한 목적으로 범용적 사용이 가능하며 확장성이 좋다.
- R보다 더 대용량 데이터를 빠르게 다룰 수 있다.
- 버젼마다 사용할 수 있는 패키지가 다른 R보다 편리하다.
- 무료이다.

2. Python 특징
- 반복 : 반복문을 사용하지 않고 내부에서 반복연산을 하게 해주는 언어 (vecterization)
- 배정 : Python의 데이터타입은 동적변수로서 매번 바뀐다.
- 뭉탱이(데이터를 집어넣는 공간) 사용 :
   tuple, list, dictionary, set
   뭉탱이 안에 뭉탱이를 집어 넣을 수 있다.
   가변형태이며 뭉탱이 안에 뭉탱이는 다 다른 데이터 타입이다.

3. 뭉탱이 1 - list
- 데이터 분석에서 사용목적 : 데이터베이스에서 데이터 가지고 올 때 한 개의 리스트 타입으로 처리한다.
- 뭐든지 다 담을 수 있는 공간이다. 문자, 숫자, 참, 거짓 전부 담을 수 있다.
- 공간을 여러 개 붙여놓은 것

4. 뭉탱이 2 - tuple (튜플)
- 데이터 분석에서 사용목적 : 데이터베이스에서 데이터 가져왔는데 실수로 데이터 삭제하면 어떻게 할까?
삭제를 못하게 하는 뭉탱이가 튜플이다.
- 튜플은 수정하지 못하는 것이 아니라 관련 속성이 없는 것이다. 튜플이라는 속성에서는 추가, 삽입, 삭제 라는 메소드가 없다.
- 데이터를 프로그램 시작해서 끝낼 때까지 그대로 유지하고 싶으면 사용해라!

5. 뭉탱이 3 - dictionary
- 데이터 분석에서 사용목적 : 웹에서 데이터를 가져왔다. 보통이 반구조형 데이터타입인 json 타입이며 이것은 key와 value 형태로 되어 있는 dictionary를 사용한다.
- dictionary 안에다가 다른 뭉탱이를 집어넣을 수 있다.

6. 뭉탱이 4 - set
- 그냥 만들면 dictionary 형태
- 중복허가 하지 않는다.

7. numpy - ndarray

8. pandas - series

9. pandas - dataframe
- pandas 라이브러리를 사용한 데이터프레임 타입이다.
- 기본적으로 데이터 가져올 때 리스트, 튜플, 딕션어리를 사용해서 가져온다.
- 인덱스 옵션이 있다.

[딥러닝 기본] Hyperparameter tuning : 하이퍼파라미터 튜닝

냉철한 욱 — Mon, 28 Mar 2022 07:40:13 +0900

* 출저

1. Tuning process

1) 일반적인 우선순위

1. a(학습률)

2. b(모멘텀 값), hidden units(은닉층 유닛수), mini-batch size(미니배치 크기)

* Adam 최적화 알고리즘 사용시 : b1[0.9], b2[0.99], 앱실론[10-8] 초기화

3. layers(층 개수), learning rate decay(학습속도감쇠법) 등

2) Hyperparameters 서칭 방법

1. 그리드서치

그리드서치는 매개변수 적을 때 유용하다.

중요한 파라미터를 다양하게 서칭하기 어렵다.

2. 랜덤서치

랜덤서치가 딥러닝에서는 더 유용하다.

왜냐하면 중요도가 다른 하이퍼파라미터의 최적의 값 후보가 다양하기 때문이다.

랜덤서치는 이러한 후보 값들을 광범위하게 서칭 할 수 있다.

3. Coarse to fine

최적의 값 후보 서칭 범위를 더 확대해서 찾는 방법이다.

2. Using an appropriate scale to pick hyperparameters

- Picking hyperparameters at random

- Appropriate scale for hyperparameters

1. 예시 : a (학습률)

균일한 방법으로 샘플링 할 경우 0.1~1에 90%가 집중된다.

하지만 많이 쓰이는 a값은 0.1 근처에 많이 있다.

그렇기 때문에 로그스케일을 이용한다.

-> 0.0001 – 0.001 – 0.01 – 0.1 – 1 사이는 균일해진다.

2. 예시 : b (모멘텀 매개변수)

b는 1로 갈수록 변경사항 민감해진다. (보통 0.9가 적정 초기값)

많은 이전 값들이 관여되어지기 때문에 변경사항이 많아진다.

즉 1로 갈수록 많이 사용되어야 하는 값들이 많다.

그렇기 때문에 로그스케일을 이용한다.

-> 0.9 – 0.99 – 0.999 사이는 균일해진다.

3. 실전에서 hyperparameter 서칭방식(Pandas vs Caviar)

1. babysit 방식 (panda approach)

아주 큰 데이터가 있고 산출 자원은 많이 없을 때 적용

* 산출 자원

산출자원이라 하면 CPU나 GPU같은것이 많이 없어 1가지 모델만 트레이닝할 여건일 경우

아주 작은 수의 모델만 한번에 트레이닝 시킬 수 밖에 없는 경우

* 이름 유래

panda가 아이를 갖는 경우, 굉장히 조금 갖음. 한번에 1명씩. 그 아기의 생존에 최선

2. parallel 방식(caviar approach)

여러 모델을 트레이닝 시키는 방법

충분히 많은 컴퓨터를 가지고 있어 여러개의 모델 학습 가능하면 적용

* 이름 유래

물고기는 1시즌에 1억개가 넘는 생선알 낳음

1억개 일일히 신경쓰지 않고 1억개 중 소수가 잘 되어 생존하기를 원함.

=> 얼마나 산출 자원을 가지고 있느냐에 따라 선택 달라짐.

[딥러닝 기본] Deep Learning 학습최적화 셋팅

냉철한 욱 — Mon, 28 Mar 2022 07:35:50 +0900

출저

1. Normalizing inputs

- normalize(표준화) 특징

신경망을 훈련시킬 때, 트레이닝의 속도를 높일 수 있는 방법.

- normalize(표준화) 를 하는 이유

표준화를 실행하여 모든 특성값들이 비슷한 범위 값을 가진다면 빠른 속도로 학습을 진행할 수 잇다.

2. Vanishing / Exploding gradients : 가중치 초기화를 적절하게 해야하는 이유

3. Weight Initialization for Deep Networks

1) 가중치 초기화 0으로 하면 안되는 이유

로지스틱 아닌 이상 모두 0으로 초기화하면 안 된다.

=> 학습이 진행되지 않는다.

왜냐하면 모든 노드가 똑같은 연산이기 때문에 하나 있는 것과 다를 바가 없다.

2) 어떻게 가중치 초기화 설정?

만약 입력 activation의 입력 특성이 대략적으로 평균 0 와 편차 1이면 이것은 z가 비슷한 scale을 갖게 할 것이고 문제해결이 되지 않을 것입니다. 하지만 확실히 vanishing과 exploding gradient 문제를 도와주기는 합니다. 왜냐면 w하는 비중 매트릭스를 세팅해서 1보다 너무 크지 않고, 1보다 너무 작지 않게 해서 너무 빨리 explode하거나 vanish하지 않게 하려는 것입니다

3). 가중치 초기화 종류

1. 가중치 초기화 : Xavier (세이비어 초기화)

- 개요

이 방법은 균등 분포(Uniform Distribution) 또는 정규 분포(Normal distribution)로 초기화 할 때 두 가지 경우로 나눈다.

이전 층의 뉴런 개수와 다음 층의 뉴런 개수를 가지고 식을 세웁니다.

이전 층의 뉴런의 개수를 n(in)

다음 층의 뉴런의 개수를 n(out)

- 균등분포

- 정규분포

평균 : 0

- 특징 및 문제점

Xavier 초기화는 여러 층의 기울기 분산 사이에 균형을 맞춰서 특정 층이 너무 주목을 받거나 다른 층이 뒤쳐지는 것을 막음.

그런데 Xavier 초기화는 시그모이드 함수나 하이퍼볼릭 탄젠트 함수와 같은 S자 형태인 활성화 함수와 함께 사용할 경우에는 좋은 성능을 보이지만, ReLU와 함께 사용할 경우에는 성능이 좋지 않음.

ReLU 함수 또는 ReLU의 변형 함수들을 활성화 함수로 사용할 경우에는 다른 초기화 방법을 사용하는 것이 좋은데, 이것이 He 초기화(He initialization)

그래서 HE가 거의 요즘 디폴트 값

2. 가중치 초기화 : HE

- 개요

이 방법은 균등 분포(Uniform Distribution) 또는 정규 분포(Normal distribution)로 초기화 할 때 두 가지 경우로 나눈다. 다만, He 초기화는 세이비어 초기화와 다르게 다음 층의 뉴런의 수를 반영하지 않음. 전과 같이 이전 층의 뉴런의 개수를 nin만 있음.

- 균등분포

- 정규분포

평균 : 0

- 특징

시그모이드 함수나 하이퍼볼릭탄젠트 함수를 사용할 경우에는 세이비어 초기화 방법이 효율적입니다.

ReLU 계열 함수를 사용할 경우에는 He 초기화 방법이 효율적입니다.

ReLU + He 초기화 방법이 좀 더 보편적.

욱이의 냉철한 공부

[딥러닝 기본] Transfer learning (전이 학습)

1. Transfer learning 개념

2. EX) 논문 리비전 할 때 Transfer learning 관련 답변서

[딥러닝 기본] ML Strategy 2

1. Error Analysis

1) Carrying out error analysis

- examples 확인

* 선택

- parallel 방식의 error analysis

- 요약

2) Cleaning up incorrectly labeled data

- 레이블이 잘못된 경우

- train set에서 레이블 수정이 가치가 있는 경우

- dev set, test set에서 레이블 수정이 가치가 있는 경우

- 레이블 수정에 고려 사항

3) Bulid your first system quickly, then iterate

- Build your first system quickly

- Build your first system quickly 절차

2. Mismatched training and dev/test set

1) Traning and testing on different distributions

2) Bias and Variance with mismatched data distributions

- 분석의 문제 2가지

- training-dev set 정의

- 오류의 차이에서 확인 할 것

3) 데이터 불일치 해결법(traing <-> dev, test 다른 분포)

1. traing <-> dev, test 차이를 이해하고 수동 오류 분석을 수행.

2. train 데이터를 dev, test와 유사하게 만든다.

또는 유사한 데이터를 더 수집한다.

3 Learning from multiple tasks

1) Transfer learning

- 개요

- 학습하는 방법 종류

- 성립하기 위한 조건 (업무A -> 업무B)

2) Multi-task learning

- 개요

- 언제 사용하는가?

1. shared low-level features로부터 이득을 볼 수 있는 업무들을 학습 시킬 때,

2. 업무마다 데이터양이 비슷할 때

3. 큰 신경망을 트레이닝 시키는 경우에만

3) 요점 정리

1. transfer learning

2. multi-task learning

4. End to end deep learning

1) What is end-to-end deep learning

- 개요

- 특성

- 장점

- 단점

- 결정 포인트

[딥러닝 기본] ML Strategy 1 (human-level performance)

1. Introduction to ML Strategy

1) Why ML Strategy?

2) Orthogonalization

2. Setting up your goal

1). Single number evaluation metric

- idea – code – experiment

- 다양한 평가지표

2). Satisficing and Optimizing metric

- Satisficing(최소한의 충족) + optimizing(최적화)

3) Train, dev, test distributions

- 무작위로 섞인 데이터 분포도 활용해야 한다.

- 같은 분포도를 가지는 Train, dev 활용

- 어떻게 트레이닝 세트를 설정하는가에 따라서 얼마나 잘 목표를 맞추는지 결정 가능.

4) Size of the dev and test sets.

- 많은 데이터 셋을 가지는 경우 : 98% 트레이닝 세트, 1% dev, 1% 테스트로 분배가 합리적.

- size of test set 유연하게 조절

5) When to change dev/test sets and metrics

- metric change 개요

- metric change 단계

- dev/test sets change 개요

3. Comparing to human-level performance

1). Why human level performance?

- 머신러닝 시스템 vs 인간레벨 시스템

- Bayes error (Bayes optimal error)

- 정확도는 인간레벨성능을 능가한 이후로 느려짐.

2) Avoidable bias

- 인간레벨오류를 Bayes error의 추정치로 생각

​- avoidable bias

3) Understanding human-lavel performance

- avoidable bias