Applied unsupervised learning with python 책을 기반으로 작성된 글입니다.

 

1) 차원 축소란 무엇인가?

1.1) 차원이란?

- 차원은 데이터 샘플과 관련된 치수, 형상 또는 변수의 수를 말한다.

- 스프레드시트의 열의 수로 생각하면 편하다.

 

1.2) 차원 축소

- 차원 축소는 해결 중인 문제 또는 데이터 셋의 종류에 따라 제공된 정보를 잃지 않으면서도 차원은 줄이고자 한다.

- 차원 축소를 사용하면 불필요한 노이즈를 상당 부분 제거할 수 있고, 이는 데이터에 적용하는 알고리즘 성능을 높여주고 데이터의 크기를 줄여줘서 하드웨어 요구 사항을 낮추는 데 기여할 수 있다.

 

2) 차원 축소가 적용되는 사례

 a. 사전 처리/ 기능 엔지어링 : 가장 일반적인 사례 가운데 하나는 사전 처리 또는 머신 러닝 솔류션의 개발 단계에서의 초기 기능 구현 단계로, PCA을 통해 가장 중요한 정보 구성 요소를 데이터에서 분리하고 이를 모델에 제공해 가장 관련성이 높은 정보만 제공하게 된다.

 b. 노이즈 감소 :  차원 축소는 효과적인 노이즈 감소/ 필터링 기법으로도 사용할 수 있다. 예를 들면 아래 그림처럼 왼쪽 사진의 중요한 요소들이 오른쪽 사진으로도 보아도 눈에 보이는 것을 확인할 수 있다.

 c. 신뢰 가능한 인공 데이터셋 생성 : PCA가 데이터셋을 정보의 구성 요소로 나눔에 따라 우리는 각 구성 요소의 영향을 조사하거나 고윳값 사이의 비율을 조정해 새로운 데이터셋 샘플을 만들 수 있고 이러한 데이터의 모야을 통계적 형태 모델링이라고 한다.

 d. 재무 모델링 / 위험 분석 : 차원 축소는 다수의 개별 시장 지표 또는 신호를 더 적은 수의 구성 요소로 통합할  수 있으므로 금융 산업에 유용한 더 빠르고 효율적인 도구를 제공할 수 있다. 마찬가지로 위험도가 높은 제품이나 회사를 찾아내기 위해 사용된다.

3) 차원 저주

- 일반적으로 특징 공간에 많은 수의 차원을 가진 데이터를 갖고 작업해야 할 때 흔히 사용하며, 데이터 셋에 둘러싼 공간이 넓고 밀도가 낮아진 데이터 셋을 보고 차원 저주라고 한다.

3.1) 차원 축소를 하는 이유

- 데이터 셋의 밀도 문제를 해결하지 않고선 아무리 추가 기능에 관한 feature 정보를 얻을 수 있더라고 통계적인 상관관계를 만들기가 어려워서 성능을 개선하지 못한다. 하지만 차원 축소를 하면 유용한 정보는 유지하면서도 밀도에 따른 부정적인 영향을 최소화를 시켜 모델의 성능을 개선하는데 강력하게 만든다.

4) 차원 축소 기법 개요

4.1) 차원 축소는?

- 유용한 정보는 유지하면서 데이터세의 밀도를 관리하는 것이므로 차원 축소는 일반적으로 분류 단계 전에 사용되는 중요한 사전 처리 단계를 차지한다.

4.2) 차원 축소 기법

 a. 데이터 밀도를 높이기 위해 더 높은 차원 공간의 데이터를 낮은 차원의 공간으로 저정하는 형상 투영 프로세스를 사용해 작업을 한다.

4.3) 차원 축소에 고려 해야할점

- 항상 낮은 차원의 공간으로 투명해 발생하는 정보 손실의 균형을 유지하도록 노력해야한다.

5) 차원 축소와 비지도 학습

5.1) 차원 축소 기법들

a. 선형 판별 분석(LDA, Linear Discriminant Analysis) : 차원 축소 뿐만 아니라 분류에도 사용할 수 있는 꽤 편리한 기법이다.

b. 음수 미포함 행렬 분해(NNMF, Non-negative matrix factorization) : 다양한 차원 축소 기법처럼 데이터셋의 특징 수를 줄이기 위해 사용되며 선형 대수의 특성을 활용한다.

c. 특이값 분해(SVD, Singular Value Decomposition) : PCA와 관련 깊으며 행렬을 분해하는 과정이다.

d. 독립 성분 분석(ICA, Independent Component Analysis) : 주성분을 이용한다는 점에서 PCA와 비슷하지만 데이터의 독립적인 축을 찾는다.

 

6) PCA

- 차원 축소의 기법 중 하나이다.

- 데이터를 일련의 구성 요소(데이터 내에서 표현되는 정보)로 분리해 데이터 셋의 밀도 문제를 개선할 수 있다.

 

6.1) PCA를 알아보기 전에 기초 통계개념 알아보기

a. 평균 : 단순히 모든 값을 더한 후 집합의 수로 나눈 값

b. 표준 편차 : 평균에 근접한 데이터의 양을 측정한것으로 데이터 집합에서 데이터 집합 약68%의 값들이 평균에서 양쪽 1 표준편차 범위에 존재한다. 또한 분산은 표준  편차의 제곱을 한 값이다.

c. 공분산 : 2개의 확률 변수의 상관정도를 나타내는 값이며, 확률 변수 X의 증감에 따른 확률 변수 Y의 증감의 경향에 대한 측도이다. 

   Cov(X, Y) = E[(X - E(X))(Y - E(Y))] = E(XY) - E(X)E(Y)

  * Cov(X,Y ) > 0 : X ↑⇒Y ↑          ex) X :height, Y :weight

  * Cov(X,Y ) < 0 : X ↑⇒Y ↓          ex) X :age, Y : eyesight

  * Cov(X,Y ) = 0 : no relationship    ex) X :age, Y : eye size

d. 공분산 행렬 : 각 데이터의 분산과 공분산을 이용해 만드는 행렬

 

 

 

 

 

'비지도 학습 (Unsupervised Learning) > Applied Unsupervised Learning with Pytho' 카테고리의 다른 글

장바구니 분석( Apriori 알고리즘 )  (0) 2020.02.05
7장 토픽 모델링(LDA)  (0) 2020.01.11
3장 이웃 접근과 DBSCAN  (0) 2020.01.06
2장 계층적 클러스터링(Hierarchical Clustering)  (0) 2019.12.28

Applied unsupervised learning with python 책을 기반으로 작성된 글입니다.

 

우리가 배우는 지도 학습 분야에서 특성 데이터는 제공 되지만 특성 변수가 무엇인지 설명하는 라벨은 제공되지 않는다. 대상 라벨이 구체적으로 무엇인지에 대해서는 정보를 얻을 수 없지만 비슷한 그룹을 함께 클러스터링함으로써 데이터의 구조를 얻을 수 있고 그룹 내에 어떤 유사성이 존재하는지 알아낼수 있다. 1장 2장에서 비슷한 데이터를 묶기 위해 처음으로 K- 평균을 사용하였다. 

하지만 K-평균은 연산 부담이 크지 않지만 차원 수가 많은 데이터 셋이면 다룰 때 문제가 생기기도 한다. 또한 찾고자 하는 클러스터의 수가 몇개인지 모르는 상황이면 K-평균은 이상적인 해답은 아니다.

그래서 2장에서 계층적 클러스터링을 배웠다. 여기서 집적 방식과 분산 방식으로 동작 할 수 있다.

 집적 방식은 상향식 접근 방식으로 동작하며, 각 데이터 지점을 자체 클러스터로 처리하고 링크 기준을 사용해 재귀적으로 그룹화 한다.

 분산 방식은 하향식으로 접근하며, 모든 데이터 지점을 하나의 대규모 클래스로 처리하고 이를 반복적으로 더 작은 클러스터로 분할하는 형태로 동작한다.

>> 위 방식은 전체 데이터 분포를 완전히 이해하는 장점이 있지만 복잡도가 올라가기 때문에 잘 사용하지 않는다. 그래서 계층적 클러스터링 방식은 데이터에 사전 정보가 부족한 경우 좋은 대안이 될 수 있다. 왜냐면 덴드로그램을 사용하면 데이터 분할을 시각적으로 확인할 수 있으며 이를 통해 몇개의 클러스터로 나누는 것이 합리적인지 결정할 수 있기 때문이다.

또 다른 접근 방식은 밀집된 데이터를 다룰 때 높은 성능을 보이는다고 알려져있는 DBSCAN 이다.

 

1. 이웃으로서의 클러스터 

1.1) 거리만 사용하는 클러스터링

- 서로 가까운 거리에 존재하는 데이터 지점일수록 유사성이 높고 멀수록 유사성이 낮다고 보는 개념을 사용한다.

- 특이한 데이터가 있는 경우 클러스터링이 별로 의미가 없다. 왜냐면 K-평균과 계층적 클러스터링 모두 남아 있는 데이터 지점이 하나도 없을 때까지 모든 데이터를 그룹에 포함시키기 때문이다.

 1.2) 거리 개념과 밀도 개념을 함께 사용하는 클러스터링

- 인접 밀도의 개념을 통합함으로써 런타임에  선택한 하이퍼파라미터에 기반해 특이한 데이터를 클러스터 밖에 둘 수 있고, 인접한 데이터 지접만 동일 클러스터의 구성원으로 간주하고 멀리 떨어진 데이터 지점은 클러스터에 포함하지 않고 외부에 둘 수 있다.

 

2. DBSCAN 소개

2.1) DBSCAN가 클러스터링을 하는 원리

- 이웃의 반경의 크기와 클러스터로 간주되는 인접 지역에서 발견된 최소 지점의 수를 종합적으로 고려해 밀도를 평가한다. 

 

2.2) DBSCAN가 고려해야하는 파라미터들

 a. 이웃반경 

 a.1) 극단적으로 이웃 반경이 크다면

- 아마도 경계를 넘어가 모든 지점이 결국 하나의 큰 클러스터에 포함되게 될것이다.

 a.2) 극단적으로 이웃 반경이 작다면

- 지점들이 모이지 못해 단일 지점만 포함하는 작은 클러스터만 잔뜩 생길 것이다.

 

b. 최소 지점의 수

- 이웃 반경의 크기를 보조하는 수단으로 볼수 있다.

 b.1) 데이터의 밀도가 희박하면

- 이웃 반경 못지 않게 최소 지점의 수도 중요해진다.

 b.2) 데이터의 밀도가 충분하면

- 최소 지점의 수는 별로 큰 영향을 주는 요소는 되지 않을 것이다.

 

>> 가장 좋은 옵션은 여전히 데이터 셋의 모양에 따라 달라진다. 그래서 하이퍼파라미터에가 너무 작지 않고 너무 크지않은 완벽한 골디락스 영역을 찾기를 원한다. 

                                                                                                                        * 골디락스 : 이상적인 값

 

3) DBSCAN 구현

 DBSCAN(eps = 0.5, min_samples = 10, metric = 'euclidean')

     * eps : 이웃(주변) 반경

     * min_samples : 최소 지점의 수(최소 포인트 수)

     * metric : 거리 측정 방식

 

3.1) 속성 - 이웃 반경(eps)

- DBSCAN에서 아주 중요한 파라미터이다. 왜냐하면 너무 작으면 모든 데이터가 클러스터 되지 않은 채로 남겨지는 문제가 생기며, 너무 크면 모든 데이터가 비슷하게 하나의 클러스터로 그룹화돼 어떠한 가치도 제공하지 않기 때문이다.

- eps는 엡실론의 약자로, 이웃을 검색할 때 알고리즘이 사용하는 거리이다.

- 엡실론 값은 특정 데이터 지점을 순환 할때 인점 여부를 판단하는 반지름으로 사용된다.

// 이웃 탐색에 의해 형성된 모양은 2차원에서는 원 3차원에서는 구라는 것이다. 이는 데이터의 구조에 따라 모델의 성능이 영향을 받을 수 있음을 의미한다. 

 

3.2) 속성 - 최소 지점 수( min_sample )

- 기능 공간에서 무작위로 놓인 소수의 지점들을 노이즈로 분류할 것인지 아니면 클러스터로 분류할것 인지를 따질 때 최소 지점의 수는 중요한 역할을 한다.

 

4) 활용 5: DBSCAN과 K-평균 그리고 계층적 클러스터링 비교

< 연습 문제 >

만약 당신은 상점 재고를 관리하며 많은 양의 와인을 받고 있다. 하지만 운송 중 브랜드 라벨이 병에서 떨어졌다. 다행히 공급업체가 각각의 일련 번호와 함께 각 병에 관한 화학적인 수치를 제공했다. 하지만 와인 병을 일일이 열고 그 차이를 시험할 수가 없다. 라벨이 부착되지 않은 병을 화학 물질 측정치에 따라 다시 묶을 수 있는 방법을 찾아야 한다. 주문 목록에서 3가지 유형의 와인을 주문했고, 와인 유형을 다시 그룹화하기 위해 2가지 와인 속성만(X_feature) 제공 받았다고 하자

//필요한 모듈 임포트

from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN
from sklearn.metrics import silhouette_score
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

// 와인 데이터 셋 로드

wine_df = pd.read_csv("wine_data.csv")

 

//시각화

plt.scatter(wine_df.values[:,0], wine_df.values[:,1])
plt.title("Wine Dataset")
plt.xlabel("OD Reading")
plt.ylabel("Proline")
plt.show()

// 와인 데이터 셋의 지표를 산포도로 시각화

// K-평균 클러스터링

km = KMeans(3)
km_clusters = km.fit_predict(wine_df)

// 응집 계층적 클러스터링

ac = AgglomerativeClustering(3, linkage='average')
ac_clusters = ac.fit_predict(wine_df)

 

// DBSCAN 클러스터링 

db_param_options = [[20,5],[25,5],[30,5],[25,7],[35,7],[35,3]]   // 최적의 실루엣 점수 파라미터 찾기

for ep,min_sample in db_param_options:
    # Generate clusters using DBSCAN
    db = DBSCAN(eps=ep, min_samples = min_sample)
    db_clusters = db.fit_predict(wine_df)
    print("Eps: ", ep, "Min Samples: ", min_sample)
    print("DBSCAN Clustering: ", silhouette_score(wine_df, db_clusters))

// 가장 좋은 파라미터를 가진 DBSCAN으로 클러스터링

db = DBSCAN(eps=35, min_samples = 3)
db_clusters = db.fit_predict(wine_df)

// 모든 클러스터링 시각화

plt.title("Wine Clusters from K-Means")
plt.scatter(wine_df['OD_read'], wine_df['Proline'], c=km_clusters,s=50, cmap='tab20b')
plt.show()

plt.title("Wine Clusters from Agglomerative Clustering")
plt.scatter(wine_df['OD_read'], wine_df['Proline'], c=ac_clusters,s=50, cmap='tab20b')
plt.show()


plt.title("Wine Clusters from DBSCAN")
plt.scatter(wine_df['OD_read'], wine_df['Proline'], c=db_clusters,s=50, cmap='tab20b')
plt.show()

// 각각의 클러스터의 실루엣 점수

print("Silhouette Scores for Wine Dataset:\n")
print("K-Means Clustering: ", silhouette_score(wine_df, km_clusters))
print("Agg Clustering: ", silhouette_score(wine_df, ac_clusters))
print("DBSCAN Clustering: ", silhouette_score(wine_df, db_clusters))

// 보면 DBSCAN이 항상 최고의 선택이 될 수 없다. 하지만 다른 알고리즘과 구별되는 특징은 노이즈를 잠재적 클러스터링으로 사용한다는 사실이다. 어떤 경우에는 특이한 지점을 제거하기에 훌륭하지만 때로는 많은 지점을 노이즈로 분류하는 문제를 만들기도 한다. 그럼 하이퍼파라미터 튜닝을 통해 실루엣 점수를 높일 수 있을까?

'비지도 학습 (Unsupervised Learning) > Applied Unsupervised Learning with Pytho' 카테고리의 다른 글

장바구니 분석( Apriori 알고리즘 )  (0) 2020.02.05
7장 토픽 모델링(LDA)  (0) 2020.01.11
4장 차원 축소와 PCA  (0) 2020.01.06
2장 계층적 클러스터링(Hierarchical Clustering)  (0) 2019.12.28

wine_data.csv
0.00MB

Applied unsupervised learning with python 책을 기반으로 작성된 글입니다.

 

1. 클러스터링

1.1)클러스터링이란?

하나의 데이터를 여러개의 부분집합 (clusters) 으로 분할하는 것을 의미한다.

1.2) 클러스터링을 하는 이유?

데이터 셋에 존재하는 데이터의 유사성을 찾을 수 있다는 것은 근복적인 의미를 찾을려고 할때 상당히 유용해서

 

2. 계층적 클러스터링

-트리 기반의 데이터 구조이다.

 

 

2.1) 계층적 클러스터링의 접근 방식

a. 응집 계층적 클러스터링 방식(Agglomerative)

- 위에서 아래로 접근하는 방식

- 응집은 탐욕적인 특성 때문에 가끔은 잘못된 이웃을 선택해 잘못된 클러스터를 구성한다.

- 각 데이터 지점에서 시작해 유사한 지점들을 함께 결합해 클러스터를 형성한다.

 

b. 분산 계층적 클러스터링 방식(Divisive)

- 아래에서 위로 접근하는 방식

- 전체 데이터를 하나로 보고 출발하면서 최선의 방식을 찾아 클러스터를 나눈다는 장접을 가진다.

- 시간 복잡도가 높아서 응집에 비해 시간 소요가 크다. 그렇지만 정확도를 높일 수 있다.

 

// 두 방식의 성능은 서로 달라서, 전체 데이터셋이 무엇인지 아는 것은 좀더 정확하게 클러스터를 구분해내는 능력으로 이어진다. 그리고 일반적인 경우 응집 방식을 오히려 선호하는게 일반적이고 결과가 마음에 들지 않으면 분산 방식을 시도하는게 합리적인 선택이 된다.

 

2.2) 연결 기준

-연결은 클러스터 간의 거리를 계산할 수 있는 방법을 결정하는 개념이다.

a. 중심 연결

- K평균에서 사용햇던 중심점 탐색 방식과 같다.

- 데이터에 노이즈가 많고 중심점이 명확하지 않으면 잘 동작하지 않는다는 단점이 있다.

 

b. 단일 연결

- 연결기준으로 두 클러스터 사이의 점 쌍 사이의 최소 거리를 찾아낸다.

- 즉, 두 클러스터 사이의 가장 가까운 점에 기반해 클러스터를 결합한다

 

b.1) 단일 연결을 선택하는 이유?

- 기본적으로 데이터 간의 유사성이 높기 때문이며, 만일 이때 차이점이 존재한다면 데이터가 극도로 달라지기 때문에 가장 가까운 지점을 찾아 동작하기 때문에 먼 거리에 있는 이상한 데이터에 영향을 받지 않아서.

 

c. 완전 연결

- 연결 기준으로 두 클러스터 사이의 점 쌍 사이의 최대 거리를 찾아낸다.

- 즉, 두 클러스터 사이의 가장 먼 점을 기준으로 클러스터를 결합한다

 

c.1) 완전 연결을 선택하는 이유?

- 데이터가 클러스터 간에 멀리 떨어져 있고 클러스터 내부의 밀집도는 매우 높을때 좋은 결과를 보여줘서.

 

// 그래서  일반적으로 가장 좋은 접근법은 몇가지 연결 옵션을 시도해보고 목적에 가장 맞는 방법을 선택하는 것이다.

 

<예제 하기전 알아야 할것은 >

AgglomerativeClustering 함수의  파라미터(매개변수)

* n_clusters : 클러스터의 개수

* affinity : 거리 함수의 정의

* linkage : 연결기준 옵션

 

< 연습문제 >

만약 당신은 상점 재고를 관리하며 많은 양의 와인을 받고 있다. 하지만 운송 중 브랜드 라벨이 병에서 떨어졌다. 다행히 공급업체가 각각의 일련 번호와 함께 각 병에 관한 화학적인 수치를 제공했다. 하지만 와인 병을 일일이 열고 그 차이를 시험할 수가 없다. 라벨이 부착되지 않은 병을 화학 물질 측정치에 따라 다시 묶을 수 있는 방법을 찾아야 한다. 주문 목록에서 3가지 유형의 와인을 주문했고, 와인 유형을 다시 그룹화하기 위해 2가지 와인 속성만(X_feature) 제공 받았다고 하자

 

//필요한 모듈 임포트

from sklearn.cluster import KMeans
from sklearn.cluster import AgglomerativeClustering
from sklearn.metrics import silhouette_score
import pandas as pd
import matplotlib.pyplot as plt

// 와인 데이타 pandas로 로드

wine_df = pd.read_csv("wine_data.csv")

// 와인데이타 시각화

plt.scatter(wine_df.values[:,0], wine_df.values[:,1])
plt.title("Wine Dataset")
plt.xlabel("OD Reading")
plt.ylabel("Proline")
plt.show()

 

//K평균으로 클러스터링

km = KMeans(3)     // 클러스터링 할 갯수 3개 설정
km_clusters = km.fit_predict(wine_df)  // K평균으로 클러스터링 예측

 

//응집 계층적 클러스터링으로 클러스터링

ac = AgglomerativeClustering(3, linkage='average')   //클러스터링 할 갯수 3개 설정및 연결지점 중심연결로 설정
ac_clusters = ac.fit_predict(wine_df)      //응집 클러스터링으로 예측

 

//  k평균 클러스터링 그림 산포도로 시각화

plt.scatter(wine_df.values[:,0], wine_df.values[:,1], c=km_clusters)
plt.title("Wine Clusters from Agglomerative Clustering")
plt.xlabel("OD Reading")
plt.ylabel("Proline")
plt.show()

// 응집 계층적 클러스터링 그림으로 시각화

plt.scatter(wine_df.values[:,0], wine_df.values[:,1], c=ac_clusters)
plt.title("Wine Clusters from Agglomerative Clustering")
plt.xlabel("OD Reading")
plt.ylabel("Proline")
plt.show()

// 위에 예측된 클러스터링에 대한 평가를 실루엣 점수로

print("Silhouette Scores for Wine Dataset:\n")
print("K-Means Clustering: ", silhouette_score(wine_df, km_clusters))
print("Agg Clustering: ", silhouette_score(wine_df, ac_clusters))

 

3. 실루엣 점수

- 얼마나 클러스터에 잘 맞는지를 분석해주는 지표

- 1에서 -1까지 숫자로 나타낸다.

- 만약 1이면 완벽하게 클러스터가 구분돼 전혀 혼란이 없는 상태를 의미한다.

'비지도 학습 (Unsupervised Learning) > Applied Unsupervised Learning with Pytho' 카테고리의 다른 글

장바구니 분석( Apriori 알고리즘 )  (0) 2020.02.05
7장 토픽 모델링(LDA)  (0) 2020.01.11
4장 차원 축소와 PCA  (0) 2020.01.06
3장 이웃 접근과 DBSCAN  (0) 2020.01.06

skt develope 공모전을 준비하면서

Flask는 웹서버를 만들수있습니다 그러면서 전 skt 플랫폼과 통신 할수있게 구현을 했습니다

이번에 제가 기획한건 기차와 국내선항공기 정보를 skt 기술과 점목시켜서 한번의 음성으로 알려주는 것을 기획하였습니다 

아래 코드는 서버와 연결하는 코드 입니다

 

< 실시간으로 항공기 정보를 가져와서 알려주는 코드입니다 >

 

이런 방식으로 기능을 구현하엿습니다

그리고 이렇게 만들어진 함수들을 불러와서 서버 router에 들어갈수있게 아래 코드 방식으로 구성되었습니다

 

 

 

 

app.run을 사용하여 서버를 실해하는 코드입니다

'프로젝트' 카테고리의 다른 글

제조 공정의 AI 기반 이상 탐지를 위한 알고리즘 및 플랫폼 개발 (3)  (0) 2021.11.17
제조 공정의 AI 기반 이상 탐지를 위한 알고리즘 및 플랫폼 개발 (1)  (0) 2021.11.17
제조 공정의 AI 기반 이상 탐지를 위한 알고리즘 및 플랫폼 개발 (2)  (0) 2021.11.16

요번에 제가 공부한거는 영상 화질 개선 쪽 관심을 갖게되어

한번 공부 하고 다른곳에 접목 시켜봐야겟다라는 취지로 공부하게 되엇고

이 공부를 하면서 처음으로 난관이엇던게 다른 딥러닝 과정과 다르게 이미지 처리 과정인 전처리 과정에서 꽤 애먹엇습니다

왜냐면 patch 사이즈가 잇는데 그것에 조건이 맞아야 되고 그 patch가 과연 어떤 저화질인가 원본이가 등등 생각을 하면서

알게된게 원본사진을  저화질 사진을 만들고 그리고 이미지를 patch 사이즈만큼 크롭 합니다 그리고 그 크롭된 이미지 바탕으로 학습시키는 것엿습니다

전 optimizer를 SGD 모멘트를 사용하엿고 단순한 SRCNN모델 구조 9-1-5 과정을 하엿습니다

                    변환 >>>          





코드를 보시면


필요한 패키지들 import










학습데이터셋 정리



patch  정보




 이미지 정보 사진으로 출력해보기



데이터 전처리 과정






























torch 데이터셋을 만들기위한 과정





















# 모델 정의

























SRCNN(
  (layer1): Sequential(
    (0): Conv2d(3, 64, kernel_size=(9, 9), stride=(1, 1))
    (1): ReLU()
  )
  (layer2): Sequential(
    (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))
    (1): ReLU()
  )
  (layer3): Sequential(
    (0): Conv2d(32, 3, kernel_size=(5, 5), stride=(1, 1))
  )
)


손실함수 optimizer 등 정리




Train 부분 학습하기













91 tensor(0.0007, grad_fn=<MeanBackward1>)
92 tensor(0.0007, grad_fn=<MeanBackward1>)
93 tensor(0.0007, grad_fn=<MeanBackward1>)
94 tensor(0.0007, grad_fn=<MeanBackward1>)
95 tensor(0.0007, grad_fn=<MeanBackward1>)
96 tensor(0.0007, grad_fn=<MeanBackward1>)
97 tensor(0.0007, grad_fn=<MeanBackward1>)
98 tensor(0.0007, grad_fn=<MeanBackward1>)
99 tensor(0.0007, grad_fn=<MeanBackward1>)


아무 사진이나 test 해보기
















원본 사진


원본사진을 저화질로 강제 변환


강제로 저화질로 된 사진을 고화질로 변환





'이미지 처리' 카테고리의 다른 글

대학생 1학년이 이해하는 Opencv 와 deel learning을 이용한 영상속에 나를 찾아서 주는 모델  (0) 2019.01.15
대학생 1학년이 이해하는 kaggle Art Images 이미지 분류  (1) 2019.01.08

이번에는 파이썬 코드 기반으로 싱글 레이어로 보스턴 집값을 예측하는 코드를 작성하겟습니다


 이런 식으로 보스턴 집값을 예측한다


제일 처음으로 할것은 




보스턴 Features들은 

  * **CRIM**: 자치 시(town) 별 1인당 범죄율

  * **ZN**: 25,000 평방피트를 초과하는 거주지역의 비율

  * **INDUS**: 비소매상업지역이 점유하고 있는 토지의 비율

  * **CHAS**: 찰스강의 경계에 위치해 있으면 1, 그렇지 않으면 0

  * **NOX**: 10ppm당 농축 일산화질소

  * **RM**: 주택 1가구당 평균 방의 개수

  * **AGE**: 1940년 이전에 건축된 소유주택의 비율

  * **DIS**: 5개의 보스턴 직업센터까지의 접근성 지수

  * **RAD**: 방사형 도로까지의 접근성 지수

  * **TAX**: 10,000 달러 당 재산세율

  * **PTRATIO**: 자치 시(town)별 학생/교사 비율

  * **B**: 1000(Bk-0.63)^2, 여기서 Bk는 자치시별 흑인의 비율을 말함.

  * **LSTAT**: 모집단의 하위계층 비율(%)

  * **MEDV**: 본인 소유의 주택가격(중앙값) (단위: $1,000)

  

보스턴  데이터 셋 들고오기



보스턴 데이터 셋을 X, Y로 구분여 데이터 셋을 만들 준비를 한다

데이터 프레임 형태로 변환





<output>

CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTATMEDV
00.0063218.02.310.00.5386.57565.24.09001.0296.015.3396.904.9824.0
10.027310.07.070.00.4696.42178.94.96712.0242.017.8396.909.1421.6
20.027290.07.070.00.4697.18561.14.96712.0242.017.8392.834.0334.7
30.032370.02.180.00.4586.99845.86.06223.0222.018.7394.632.9433.4
40.069050.02.180.00.4587.14754.26.06223.0222.018.7396.905.3336.2





X의 Features을 다 구분 해두엇기에  x1~x13가지 데이터 X가 잇으며 이 데이터 X에 1대1로 배치되는 W 값을 만든다 random.uniform형태로

그리고 보스턴 집값예측 가격을 예측하는것이기때문에 output이 한개이므로 식은

y = w1*x1+w2*x2+w3*x3+w4*x4+w5*x5+w6*x6+w7*x7+w8*x8+w9*x9+w10*x10+w11*x11+w12*x12+w13*x13+b 이며,

손실 함수는 loss function은 0.5*Σ(y-y_predict)**2이며 이것을 미분하면 아래 공식이 탄생된다

(y-y_predict)*w 이 공식이 weight를 업데이트 하며 트레이닝 할수가 잇다

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


    0 error = 328.18781
10000 error = 5.81798
20000 error = 5.34306
30000 error = 5.05000
----------------------------------------
32292 error = 4.99999


에측하기







<output>                                                                                                                                원래가격   예측한 가격

CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTATMEDVMEDV(predict)
00.0063218.02.310.00.5386.57565.24.09001.0296.015.3396.904.9824.030.115258
10.027310.07.070.00.4696.42178.94.96712.0242.017.8396.909.1421.624.928269
20.027290.07.070.00.4697.18561.14.96712.0242.017.8392.834.0334.727.318432
30.032370.02.180.00.4586.99845.86.06223.0222.018.7394.632.9433.426.550113
40.069050.02.180.00.4587.14754.26.06223.0222.018.7396.905.3336.226.108157


이번에 소개할 프로젝트는

deep learing을 이용해서 채팅 로봇이 사람의 감정을 판단 해주는 프로젝트를 만들어 보앗습니다



코드로 넘어가면.......

첫번째로! 우리가 필요한 모듈을 가져왓습니다




저희가 딥러닝 모델을 사용하기 때문에 트레이닝된 딥러닝 모델의 틀을 가져옵니다




















































학습되 모델의 weight를 가져옵니다



chat Bot을 사용하기 위한 함수와 코드를 작성합니다























































































































채팅로봇 실행하기!












채팅 로봇이 봣을때와 사용자가 다를때 사용자가 봣을때  그 감정은 이 감정이야 라고 알려주면 나중에 업데이트 될수 잇게 csv 파일로 저장한다


































만든 계기:

공부할 목적도잇고 이러한 비슷한 유형의 오픈소스도 많지만 저는 참고를 안하고 이 것을 생각하게 된 계기가 미션 임파셔블 영화를 보고 거기서 주인공 톰크루즈가 범인을 찾을때 범인 사진을 주고 그 길거리에서 범인 찾는것을 보고 아 만들어 보자 재미겟다 하고 프로젝트를 시행햇고 그결과 나름 괜찮은 모델이 만들어 졋으며, 길거리에서 나를 찾아주는것을 하고 싶지만 다른사람의 개인 정보 노출인것 같아서 해보지 못햇습니다 그렇지만 나중에 기회가 되면 한번 해보고 싶은 테스트 입니다

첫번째로는 제 얼굴 데이터를 가져오는게 첫번쨰 엿고

그리고 두번쨰로는 제 이미지와 다른 이미지 얼굴을 비교할 이미지엿습니다

이때 제가 이미지를 가져올때 사용한 모듈은 openCV이고 이것을 활용해서  제 이미지와 유투브에 볼수잇는 사람 얼굴 이미지를 가져왓습니다

이미지를 가져왓다는 기준에서 이미지를 전처리하고 학습하는 과정입니다

















이미지 파일을 저장한 파일 이름

이미지 파일을 가져 코드 입니다





















이미지를 가져오고 그 이미지를 ToTensor 화를 시켜 데이터셋으로 만듭니다






[[1, 'train', 'image//train\\train_img98.jpg'], [1, 'train', 'image//train\\train_img99.jpg']]
5636

이 데이터 셋을 DataLoader를 통해 데이터 로드화를 시킵니다



<torch.utils.data.dataloader.DataLoader object at 0x0000022480D08EB8>

model 만들기



























































모델을 불러오고 이게 이진 분류이기떄문에 cross Entropy를 사용하엿습니다 

옵티마이저는 SGD 를 사용하엿고요





























tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
tensor([1, 0, 1, 1, 0, 0, 1, 1, 0, 0])
0 tensor([ 0.0280, -0.0438], grad_fn=<SelectBackward>) tensor(0.6926, grad_fn=<NllLossBackward>)
tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
tensor([1, 0, 1, 1, 0, 1, 1, 0, 1, 1])
3 tensor([ 0.0192, -0.0182], grad_fn=<SelectBackward>) tensor(0.6747, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 0, 1, 1, 0, 0, 0, 0])
tensor([0, 0, 1, 0, 1, 1, 0, 0, 0, 0])
6 tensor([ 0.1548, -0.1646], grad_fn=<SelectBackward>) tensor(0.6105, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 0, 1, 0, 1, 1, 0, 1])
tensor([1, 1, 1, 0, 1, 0, 1, 1, 0, 1])
9 tensor([-0.0842,  0.0758], grad_fn=<SelectBackward>) tensor(0.5047, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 0, 1, 0, 1, 1, 0, 1])
tensor([0, 1, 0, 0, 1, 0, 1, 1, 0, 1])
12 tensor([ 0.0621, -0.0692], grad_fn=<SelectBackward>) tensor(0.3295, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 0, 0, 0, 1, 0, 1, 0])
tensor([0, 1, 0, 0, 0, 0, 1, 0, 1, 0])
15 tensor([ 1.2586, -1.2573], grad_fn=<SelectBackward>) tensor(0.0666, grad_fn=<NllLossBackward>)
tensor([0, 0, 0, 0, 1, 1, 0, 0, 0, 1])
tensor([0, 0, 0, 0, 1, 1, 0, 0, 0, 1])
18 tensor([ 3.9662, -3.9760], grad_fn=<SelectBackward>) tensor(0.0190, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 0, 0, 1, 1, 1, 1, 1])
tensor([1, 1, 1, 0, 0, 1, 1, 1, 0, 1])
21 tensor([-4.7700,  4.5682], grad_fn=<SelectBackward>) tensor(0.1105, grad_fn=<NllLossBackward>)
tensor([1, 0, 1, 0, 0, 0, 0, 1, 1, 1])
tensor([1, 0, 1, 0, 0, 0, 0, 1, 0, 1])
24 tensor([-4.1996,  4.0406], grad_fn=<SelectBackward>) tensor(0.3424, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 0, 1, 1, 1, 0, 0, 0])
tensor([0, 1, 0, 0, 1, 1, 0, 0, 0, 0])
27 tensor([ 5.5803, -5.6217], grad_fn=<SelectBackward>) tensor(0.2072, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 1, 1, 1, 0, 1, 0, 0])
tensor([0, 0, 1, 1, 1, 1, 0, 1, 0, 0])
30 tensor([ 8.9125, -8.9570], grad_fn=<SelectBackward>) tensor(0.0434, grad_fn=<NllLossBackward>)
tensor([1, 0, 0, 0, 0, 1, 0, 1, 1, 0])
tensor([1, 0, 0, 0, 0, 1, 0, 1, 1, 0])
33 tensor([-2.5862,  2.4938], grad_fn=<SelectBackward>) tensor(0.0365, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 1, 1, 1, 0, 1, 1, 1])
tensor([0, 1, 0, 1, 1, 1, 0, 1, 1, 1])
36 tensor([ 5.4982, -5.4998], grad_fn=<SelectBackward>) tensor(0.0100, grad_fn=<NllLossBackward>)
tensor([0, 0, 0, 0, 0, 0, 0, 1, 0, 0])
tensor([0, 0, 0, 0, 0, 0, 0, 1, 0, 0])
39 tensor([ 6.5110, -6.5401], grad_fn=<SelectBackward>) tensor(0.0181, grad_fn=<NllLossBackward>)
tensor([1, 1, 0, 1, 0, 1, 1, 0, 0, 0])
tensor([1, 1, 0, 1, 0, 1, 1, 0, 0, 0])
42 tensor([-1.8054,  1.7288], grad_fn=<SelectBackward>) tensor(0.0623, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 0, 1, 0, 0, 1, 1, 0])
tensor([0, 0, 1, 0, 1, 0, 0, 1, 1, 0])
45 tensor([ 9.7148, -9.7983], grad_fn=<SelectBackward>) tensor(0.1400, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 1, 0, 0, 0, 0, 1, 1])
tensor([0, 1, 0, 1, 0, 0, 0, 0, 1, 1])
48 tensor([ 5.6560, -5.6685], grad_fn=<SelectBackward>) tensor(0.1142, grad_fn=<NllLossBackward>)
tensor([1, 0, 1, 0, 1, 1, 0, 0, 0, 1])
tensor([1, 0, 1, 0, 1, 1, 0, 0, 0, 1])
51 tensor([-3.2274,  3.1140], grad_fn=<SelectBackward>) tensor(0.0149, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 1, 1, 1, 1, 0, 0, 0])
tensor([1, 1, 1, 1, 1, 1, 1, 0, 0, 0])
54 tensor([-2.9067,  2.7908], grad_fn=<SelectBackward>) tensor(0.0314, grad_fn=<NllLossBackward>
C:\anaconda\envs\py36\lib\site-packages\torch\serialization.py:250: UserWarning: Couldn't retrieve source code for container of type Detect. It won't be checked for correctness upon loading.
  "type " + obj.__name__ + ". It won't be checked "

**************************************************************************************************************
0 tensor(0.9402)
**************************************************************************************************************
tensor([1, 0, 1, 0, 1, 1, 0, 1, 0, 0])
tensor([1, 0, 1, 0, 1, 1, 0, 1, 0, 0])
0 tensor([-4.0769,  3.9162], grad_fn=<SelectBackward>) tensor(0.0169, grad_fn=<NllLossBackward>)
tensor([1, 0, 1, 0, 1, 0, 1, 1, 0, 0])
tensor([1, 0, 1, 0, 1, 0, 1, 1, 0, 0])
3 tensor([-3.1147,  3.0043], grad_fn=<SelectBackward>) tensor(0.0201, grad_fn=<NllLossBackward>)
tensor([0, 1, 1, 0, 1, 1, 0, 1, 0, 0])
tensor([0, 1, 1, 0, 1, 1, 0, 1, 0, 0])
6 tensor([ 11.2800, -11.4009], grad_fn=<SelectBackward>) tensor(0.0050, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 1, 1, 1, 0, 0, 0, 0])
tensor([1, 1, 1, 1, 1, 1, 0, 0, 0, 0])
9 tensor([-3.1894,  3.0685], grad_fn=<SelectBackward>) tensor(0.0048, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 1, 0, 0, 1, 0, 0, 0])
tensor([1, 1, 1, 1, 0, 0, 1, 0, 0, 0])
12 tensor([-3.6513,  3.5146], grad_fn=<SelectBackward>) tensor(0.0027, grad_fn=<NllLossBackward>)
tensor([0, 1, 1, 1, 0, 1, 1, 0, 1, 1])
tensor([0, 1, 1, 1, 0, 1, 1, 0, 1, 1])
15 tensor([ 5.8190, -5.8288], grad_fn=<SelectBackward>) tensor(0.0011, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 1, 0, 0, 1, 0, 0, 0])
tensor([0, 1, 0, 1, 0, 0, 1, 0, 0, 0])
18 tensor([ 4.0300, -4.0859], grad_fn=<SelectBackward>) tensor(0.0059, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 1, 0, 0, 0, 0, 1, 0])
tensor([0, 0, 1, 1, 0, 0, 0, 0, 1, 0])
21 tensor([ 15.3868, -15.5231], grad_fn=<SelectBackward>) tensor(0.0003, grad_fn=<NllLossBackward>)
tensor([0, 0, 0, 0, 1, 1, 1, 1, 1, 1])
tensor([0, 0, 0, 0, 1, 1, 1, 1, 1, 1])
24 tensor([ 3.4316, -3.4660], grad_fn=<SelectBackward>) tensor(0.0004, grad_fn=<NllLossBackward>)
tensor([1, 0, 0, 1, 0, 1, 0, 0, 0, 0])
tensor([1, 0, 0, 1, 0, 1, 0, 0, 0, 0])
27 tensor([-4.5901,  4.4397], grad_fn=<SelectBackward>) tensor(0.0002, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 1, 0, 1, 1, 0, 0, 0])
tensor([0, 0, 1, 1, 0, 1, 1, 0, 0, 0])
30 tensor([ 8.0189, -8.0658], grad_fn=<SelectBackward>) tensor(0.0011, grad_fn=<NllLossBackward>)
tensor([1, 0, 0, 0, 0, 0, 1, 1, 1, 1])
tensor([1, 0, 0, 0, 0, 0, 1, 1, 1, 1])
33 tensor([-4.3459,  4.2037], grad_fn=<SelectBackward>) tensor(0.0026, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 1, 1, 0, 1, 1, 0, 1])
tensor([0, 0, 1, 1, 1, 0, 1, 1, 0, 1])
36 tensor([ 9.0171, -9.0800], grad_fn=<SelectBackward>) tensor(0.0010, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 0, 0, 0, 0, 1, 0, 0])
tensor([0, 0, 1, 0, 0, 0, 0, 1, 0, 0])
39 tensor([ 10.2416, -10.3436], grad_fn=<SelectBackward>) tensor(0.0002, grad_fn=<NllLossBackward>)
tensor([1, 1, 0, 0, 0, 0, 0, 1, 0, 0])
tensor([1, 1, 0, 0, 0, 0, 0, 1, 0, 0])
42 tensor([-5.2891,  5.1190], grad_fn=<SelectBackward>) tensor(0.0709, grad_fn=<NllLossBackward>)
tensor([1, 1, 0, 1, 0, 1, 1, 1, 1, 0])
tensor([1, 1, 0, 1, 0, 1, 1, 1, 1, 0])
45 tensor([-5.0690,  4.9150], grad_fn=<SelectBackward>) tensor(0.0007, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 1, 0, 0, 0, 1, 1, 0])
tensor([1, 1, 1, 1, 0, 0, 0, 1, 1, 0])
48 tensor([-5.1015,  4.9344], grad_fn=<SelectBackward>) tensor(0.0023, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 0, 1, 0, 0, 0, 0, 0])
tensor([1, 1, 1, 0, 1, 0, 0, 0, 0, 0])
51 tensor([-4.4345,  4.2825], grad_fn=<SelectBackward>) tensor(0.0002, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 0, 0, 0, 0, 0, 1, 0])
tensor([0, 1, 0, 0, 0, 0, 0, 0, 1, 0])
54 tensor([ 6.1383, -6.2095], grad_fn=<SelectBackward>) tensor(0.0002, grad_fn=<NllLossBackward>)
**************************************************************************************************************
1 tensor(0.9989)




















































'이미지 처리' 카테고리의 다른 글

SRCNN 저화질 화질 고화질로 변환  (0) 2019.03.15
대학생 1학년이 이해하는 kaggle Art Images 이미지 분류  (1) 2019.01.08

https://www.kaggle.com/thedownhill/art-images-drawings-painting-sculpture-engraving


이미지 데이터 :  https://www.kaggle.com/thedownhill/art-images-drawings-painting-sculpture-engraving

이미지 데이터를 가지고 Drawing/Painting/Sculptures/Engravings/Iconography 구별하기


첫번째. 필요한 모듈 가져오기



두번째, 파라미터 설정


셋번째, 폴더에 잇는 이미지 파일 torch화 하기





















# 이미지크기를 (120,120)으로 바꾸고 이미지값을 Normalize를 시키고 trainDataset으로 바꾼다









C:\anaconda\envs\py36\lib\site-packages\torchvision\transforms\transforms.py:188: UserWarning: The use of the transforms.Scale transform is deprecated, please use transforms.Resize instead.
  "please use transforms.Resize instead.")

7671

# 데이터 셋을 데이터 로더 형태로 변환해서 batch_size 만큰 데이터를 읽어들인다


<torch.utils.data.dataloader.DataLoader object at 0x000001B1FE41E9E8>

넷번째, 모델 생성

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54





layer1.0.weight
layer1.0.bias
layer1.1.weight
layer1.1.bias
layer1.2.weight
layer1.2.bias
layer1.2.running_mean
layer1.2.running_var
layer1.2.num_batches_tracked
layer2.0.weight
layer2.0.bias
layer2.1.weight
layer2.1.bias
layer2.2.weight
layer2.2.bias
layer2.2.running_mean
layer2.2.running_var
layer2.2.num_batches_tracked
layer3.0.weight
layer3.0.bias
layer3.1.weight
layer3.1.bias
layer3.2.weight
layer3.2.bias
layer3.2.running_mean
layer3.2.running_var
layer3.2.num_batches_tracked
layer4.0.weight
layer4.0.bias
layer4.1.weight
layer4.1.bias
layer4.2.weight
layer4.2.bias
layer4.3.weight
layer4.3.bias
layer4.3.running_mean
layer4.3.running_var
layer4.3.num_batches_tracked
fc.0.weight
fc.0.bias
fc.2.weight
fc.2.bias
fc.4.weight
fc.4.bias
fc.6.weight
fc.6.bias

# 손실함수 optimizer 생성


다섯번째, 학습하기


2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

0 Accursy : 46.74748992919922
1 Accursy : 67.48794555664062
2 Accursy : 75.1531753540039
3 Accursy : 79.03793334960938
4 Accursy : 81.81462860107422
5 Accursy : 83.47021484375
6 Accursy : 83.90040588378906
7 Accursy : 85.73849487304688
8 Accursy : 86.53369903564453
9 Accursy : 87.34193420410156
10 Accursy : 88.82804870605469
11 Accursy : 88.68465423583984
12 Accursy : 90.4706039428711
C:\anaconda\envs\py36\lib\site-packages\torch\serialization.py:250: UserWarning: Couldn't retrieve source code for container of type NNNNN1. It won't be checked for correctness upon loading.
  "type " + obj.__name__ + ". It won't be checked "

13 Accursy : 91.81332397460938
14 Accursy : 92.20440673828125
15 Accursy : 93.87303161621094
16 Accursy : 94.02946472167969
17 Accursy : 95.09842681884766
18 Accursy : 94.98109436035156
19 Accursy : 97.19723510742188
20 Accursy : 98.52691650390625
21 Accursy : 99.13961791992188
22 Accursy : 99.66105651855469
23 Accursy : 99.83053588867188
24 Accursy : 99.93482208251953
25 Accursy : 99.92178344726562
26 Accursy : 99.9869613647461
27 Accursy : 100.0
28 Accursy : 100.0

여섯번째, test 데이터 평가하기







850



<torch.utils.data.dataloader.DataLoader object at 0x000001B1FE41E9E8>

#이미지 데이터가 torch화 하면서 채널이 3이 아닌 애들이 발생하면 그 데이터를 제거 해줘야되기때문에 어느 데이터가 잘못되엇는지 확인하는 과정
2
3
4
5
# 평가하기

2
3
4
5
6
7
8
9
10
11
12

Accursy : 62.0







'이미지 처리' 카테고리의 다른 글

SRCNN 저화질 화질 고화질로 변환  (0) 2019.03.15
대학생 1학년이 이해하는 Opencv 와 deel learning을 이용한 영상속에 나를 찾아서 주는 모델  (0) 2019.01.15

그래프 그리기 필기.ipynb

http://localhost:8888/notebooks/%EA%B7%B8%EB%9E%98%ED%94%84%20%EA%B7%B8%EB%A6%AC%EA%B8%B0%20%ED%95%84%EA%B8%B0.ipynb

In [1]:

그래프 그리기

In [2]:
In [3]:
In [4]:
In [5]: 
[0.4359949  0.02592623 0.54966248 0.43532239 0.4203678  0.33033482
 0.20464863 0.61927097 0.29965467 0.26682728]

그래프 작성

In [6]: 


3차 함수 그래프 만들기

In [7]:
In [8]:
[-3.  -2.5 -2.  -1.5 -1.  -0.5  0.   0.5  1.   1.5  2.   2.5  3. ]
그래프 작성
In [9]:


그래프 좀더 자세하게 그리기

In [10]:

color : 색 이름

색상 종류: r:빨강 b:파랑 g:녹색 c:시안 m:마젠타 y:노랑색 k:검정 w:흰색

label = '문자열'
범례위치 loc : upper right(left):오른쪽 위 , lower right(left):오른쪽 아래

그래프 영역 정하기

plt.figure(figsize=(w,h)) >> 전체 영역의 크기를 정한다

w: 가로의 길이
h: 세로의 길이

색다른 그래프 만들기

In [11]:
In [12]:
In [13]:
In [14]:
In [15]:
[[0.  0.  0.  0.  0.1 0.  0.  0.  0. ]
 [0.  0.  0.1 0.2 0.2 0.2 0.1 0.  0. ]
 [0.  0.  0.1 0.3 0.4 0.3 0.1 0.  0. ]
 [0.  0.  0.2 0.4 0.2 0.4 0.2 0.  0. ]
 [0.  0.  0.3 0.3 0.  0.3 0.3 0.  0. ]
 [0.  0.  0.2 0.4 0.2 0.4 0.2 0.  0. ]
 [0.  0.  0.1 0.3 0.4 0.3 0.1 0.  0. ]
 [0.  0.  0.1 0.2 0.2 0.2 0.1 0.  0. ]
 [0.  0.  0.  0.  0.1 0.  0.  0.  0. ]]



1) pcolor 그래프 작성

In [16]:


2) surface 그래프

In [17]:

In [18]:
In [19]:


3)contour 그래프 그리기(등고선)

In [20]:
In [21]:
In [22]:


+ Recent posts

티스토리툴바