birdfoot

ensemble of trees

2024-07-29T00:00:00+00:00

ensemble learning(앙상블 학습)

더 좋은 예측 결과를 만들기 위해 여러 개의 모델을 훈련하는 머신러닝 알고리즘 정형 데이터를 다루는데 가장 뛰어난 성과를 나타내는 알고리즘으로 대부분 결정 트리 기반으로 만들어짐.

사이킷런의 앙상블 학습 알고리즘

랜덤 포레스트

대표적 인 결정 트리 기반의 앙상블 학습 방법으로 안정적인 성능 덕분에 많이 사용되고 있어서 앙상블 학습을 적용할 때 가장 먼저 시도해보길 권한다.

랜덤 포레스트는 결정 트리를 랜덤하게 만들어 결정 트리(나무)의 숲을 만든다. 결정 트리의 예측을 사용해 최종 예측을 만든다.

랜덤 포레스트는 각 트리를 훈련하기 위한 데이터를 랜덤하게 만드는데 입력한 훈련 데이터에서 랜덤하게 샘플을 추출하여 만든다. (중복된 샘플이 추출될 수 있다) 이렇게 만들어진 샘플을 부트스트랩 샘플이라고 하며 기본적으로 훈련 세트의 크기와 같게 만든다.

부트스트랩이란 데이터 세트에서 중복을 허용하여 데이터를 샘플링하는 방식을 의미한다.

또한 노드 분할시 전체 특성 중 일부 특성을 무작위로 골라 최선의 분할을 찾는다.

랜덤 포레스트 분류 모델은 전체 특성 개수의 제곱근만큼의 특성을 선택한다. (4개의 특성이 있다면 노드마다 2개를 랜덤하게 선택하여 사용) 랜덤포레스트 회귀 모델은 전체 특성을 사용한다

사이킷런의 랜덤 포레스트는 100개의 결정 트리를 이런 방식으로 훈련하고 분류일 때는 각 트리의 클래스별 확률을 평균하여 가장 높은 확률을 가진 클래스를 예측으로 회귀는 각 트리의 예측을 평균한다.

랜덤하게 선택한 샘플과 특성을 사용해서 훈련 세트 과대적합을 막아주고 안정적인 성능을 얻을 수 있어 기본 매개변수 설정만으로 좋은 결과를 내기도 한다

와인 데이터를 가져와서 화이트 와인을 분류하는 문제

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

wine = pd.read_csv('https://bit.ly/wine_csv_data')
data = wine[['alcohol','sugar','pH']].to_numpy()
target = wine['class'].to_numpy()
train_input, test_input, train_target,test_target = train_test_split(data, target, test_size=0.2,random_state=42)

100개의 결정 트리를 사용하기 때문에 모든 cpu 코어를 사용하는 것이 좋다

n_jobs = -1 : 모든 cpu 코어를 사용 return_train_score = True : 검증 점수와 훈련 세트 점수 같이 반환 (기본값은 False)

결과를 보면 훈련 세트에 과대 적합된 것을 확인할 수 있다

from sklearn.model_selection import cross_validate
from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_jobs=-1,random_state=42)
scores = cross_validate(rf, train_input, train_target,return_train_score=True,n_jobs=-1)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))

-> 0.9973541965122431 0.8905151032797809

feature_importance : 랜덤포레스트 모델을 훈련 후 특성 중요도
각 [알코올 도수, 당도, pH] 이다.

rf.fit(train_input,train_target)
print(rf.feature_importances_)

-> [0.23167441 0.50039841 0.26792718]

oob_score: 부트스트랩 샘플에 포함되지 않고 남는 샘플(OOB)로 모델을 평가한 점수

rf=RandomForestClassifier(oob_score=True, n_jobs=-1,random_state=42)
rf.fit(train_input,train_target)
print(rf.oob_score_)

-> 0.8934000384837406

엑스트라 트리

랜덤 포레스트와 비슷하게 결정 트리를 사용하여 앙상블 모델을 만들지만 부트스트랩 샘플을 사용하지 않고 전체 훈련 세트를 사용하지만 대신 랜덤하게 노드를 분할해 성능은 낮지만 과대적합을 감소시키고 검증 세트의 점수를 높인다. 엑스트라 트리는 무작위성이 더 커서 랜덤 포레스트보다 더 많은 결정 트리를 훈련 시켜야 하지만 랜덤 노드 분할로 인해 빠른 계산 속도를 갖는다.

교차 검증 점수를 확인해본 결과 아까 랜덤 포레스트와 비슷한 결과를 얻었다. 특성이 많지 않아서 두 모델의 차이가 크지 않다.

from sklearn.ensemble import ExtraTreesClassifier

et = ExtraTreesClassifier(n_jobs=-1,random_state=42)
scores = cross_validate(et,train_input, train_target,return_train_score=True,n_jobs=-1)
print(np.mean(scores['train_score']),np.mean(scores['test_score']))

-> 0.9974503966084433 0.8887848893166506

엑스트라 트리 모델에서의 특성 중요도

et.fit(train_input,train_target)
print(et.feature_importances_)

-> [0.20183568 0.52242907 0.27573525]

그레이디언트 부스팅

깊이가 얕은 결정 트리를 사용하여 이전 트리의 오차를 보완하는 방식으로 앙상블하는 방법
깊이가 얕은 결정 트리를 사용하기 때문에 과대적합에 강하고 일반적으로 높은 일반화 성능 기대할 수 있지만 순서대로 트리를 추가하기 때문에 속도가 느리다

경사하강법을 사용해서 트리를 앙상블에 추가하고 분류는 로지스틱 손실 함수, 회귀는 평균 제곱 오차 함수 사용

과대적합에 가능해서 결정 트리의 개수를 늘려도 과대적합이 되지 않는다
트리의 개수를 늘리면 성능이 더 향상될 수 있다

from sklearn.ensemble import GradientBoostingClassifier

gb = GradientBoostingClassifier(random_state=42)
scores=cross_validate(gb, train_input, train_target, return_train_score=True,n_jobs=-1)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))

-> 0.8881086892152563 0.8720430147331015

결정 트리 개수를 5배 늘렸지만 과대적합을 잘 억제하고 있다

gb = GradientBoostingClassifier(n_estimators=500, learning_rate=0.2,random_state=42)
scores = cross_validate(gb,train_input,train_target,return_train_score=True,n_jobs=-1)
print(np.mean(scores['train_score']),np.mean(scores['test_score']))

-> 0.9464595437171814 0.8780082549788999

특성 중요도를 보면 랜덤 포레스트보다 당도에 더 집중된 것을 확인할 수 있다

gb.fit(train_input,train_target)
print(gb.feature_importances_)

-> [0.15872278 0.68010884 0.16116839]

히스토그램 기반 그레이디언트 부스팅

정형 데이터를 다루는 머신러닝 알고리즘 중 가장 인기가 높다

입력 특성을 256개 구간으로 나누고 노드를 분할할 때 최적의 분할을 매우 빠르게 찾을 수 있다

과대적합을 잘 억제하면서 그레이디언트 부스팅보다 조금 더 높은 성능을 제공한다

from sklearn.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import HistGradientBoostingClassifier

hgb = HistGradientBoostingClassifier(random_state=42)
scores = cross_validate(hgb,train_input,train_target,return_train_score=True)
print(np.mean(scores['train_score']),np.mean(scores['test_score']))

-> 0.9321723946453317 0.8801241948619236

훈련세트의 특성 중요도
각 순서대로 특성 중요도, 특성 평균, 표준 편차를 담고 있다

그레이디언트와 비슷하게 당도에 집중하고 있다

from sklearn.inspection import permutation_importance

hgb.fit(train_input,train_target)
result = permutation_importance(hgb, train_input, train_target, n_repeats=10,random_state=42,n_jobs=-1)
print(result.importances)
print(result.importances_mean)
print(result.importances_std)

-> [[0.08793535 0.08350972 0.08908986 0.08312488 0.09274581 0.08755051 0.08601116 0.09601693 0.09082163 0.09082163] [0.22782374 0.23590533 0.23936887 0.23436598 0.23725226 0.23436598 0.23359631 0.23398114 0.23994612 0.22724649] [0.08581874 0.08601116 0.08062344 0.07504329 0.08427939 0.07792957 0.07234943 0.07465846 0.08139311 0.08466423]] [0.08876275 0.23438522 0.08027708] [0.00382333 0.00401363 0.00477012]

테스트 세트로 성능 점수

약 87퍼의 정확도를 얻은걸 보아 앙상블 모델은 단일 결정 트리보다 더 좋은 결과를 얻을 수 있다

result = permutation_importance(hgb, test_input,test_target,n_repeats=10,random_state=42,n_jobs=-1)
hgb.score(test_input,test_target)

-> 0.8723076923076923

사이킷런 라이브러리

RandomForestClassifier(랜덤 포레스트 분류 클래스)
n_estimators : 앙상블 구성 트리 개수 기본값 100
criterion : 불순도 기본값 ‘gini’
max_depth : 트리 최대 깊이 기본값 None
min_sample_split : 노드를 나누기 위한 최소 샘플 개수 기본값 2
max_features : 최적희 분할을 위한 탐색할 특성 개수 기본값 auto(특성 개수의 제곱근)
bootstrap : 부트스트랩 샘플 사용 여부 기본값 True
oob_score : OOB 샘플로 훈련 모델 평가 여부 기본값 False
n_jobs : 사용할 CPU 코어 수 기본값 1, -1은 모든 코어 사용

ExtraTreesClassifier(엑스트라 트리 분류 클래스) : 랜덤 포레스트와 동일

GradientBoostingClassifier(그레이디언트 부스팅 분류 클래스)
loss : 손실 함수 지정 기본값 ‘deviance’ 로지스틱
learning_rate : 트리가 앙상블에 기여하는 정도 기본값 0.1
n_estimators : 부스팅 단계를 수행하는 트리의 개수 기본값 100
subsample : 훈련 세트의 샘플 비율 기본값 1.0
max_depth : 개별 회귀 트리의 최대 깊이 기본값 3

HistGradientBoostingClassifier(히스토그램 기반 그레이디언트 부스팅 분류 클래스)
learning_rate : 학습률 기본값 0.1, 1.0이면 감쇠가 없다
max_iter : 부스팅 단계를 수행하는 트리의 개수 기본값 100
max_bins : 입력 데이터를 나눌 구간의 개수 기본값 255

사이킷런 말고도 그레이디언트 부스팅 알고리즘을 XGBoost, LightGBM 라이브러리도 사용할 수 있다

필요한 도구들

2024-07-08T00:00:00+00:00

1. OpenCV

컴퓨터로 이미지나 영상을 읽고, 이미지의 사이즈 변환이나 회전, 선분 및 도형 그리기, 채널 분리 등의 연산을 처리할 수 있도록 만들어진 오픈 소스 라이브러리로 이미지 처리 분야에서 가장 많이 사용됨.

OpenCV 라이브러리는 구글 코랩이 아닌 로컬 컴퓨터 기준으로 만들어져서 구글 코랩에서는 모든 기능을 사용할 수 없다. 코랩에서는 ‘cv2.imshow’를 사용할 수 없고 ‘cv2_imshow’를 대신 사용한다

파이썬 기본 자료형 리스트는 연산할 때 느리다는 단점이 있어서 이미지와 같이 연산량이 많아진다면 리스트가 아닌 numpy를 사용하면 속도가 빨라지고 더 적은 메모리 공간을 차지한다.

import cv2 #OpenCV 사용하기 위해
from google.colab.patches import cv2_imshow #이미지 출력을 위해
import numpy as np #바이트를 넘파이로 변환해주기 위해
import urllib.request #url에서 이미지 불러오기

resp = urllib.request.urlopen('https://raw.githubusercontent.com/Cobslab/imageBible/main/image/like_lenna224.png')
image = np.asarray(bytearray(resp.read()), dtype='uint8')
image = cv2.imdecode(image, cv2.IMREAD_COLOR)

cv2_imshow(image) #이미지 출력

각 픽셀 수로 가로 224, 세로 224, 3차원

print(f"이미지 배열 형태: {image.shape}")

-> 이미지 배열 형태: (224, 224, 3)

이미지 사이즈 변환
cv2.resize 함수로 이미지의 사이즈 가로, 세로 100, 100으로 수정했다

image_small = cv2.resize(image,(100,100))
cv2_imshow(image_small)

이미지의 배율을 변환한다

image_big = cv2.resize(image, dsize=None, fx=2,fy=1)
cv2_imshow(image_big)

대칭 변환
cv2.flip 함수를 사용하여 이미지 대칭, 변환할 수 있다 0 : 수평축 반전, 1 : 세로축 반전

image_fliped = cv2.flip(image,0)
cv2_imshow(image_fliped)

image_fliped = cv2.flip(image,1)
cv2_imshow(image_fliped)

회전 변환
cv2.warpAffine 함수는 이미지를 원하는 각도로 회전한다

height, width = image.shape[:2]
matrix = cv2.getRotationMatrix2D((width/2,height/2),90,1)
result = cv2.warpAffine(image,matrix,(width,height))
cv2_imshow(result)

matrix = cv2.getRotationMatrix2D((width/2,height/2),30,1)
result = cv2.warpAffine(image,matrix,(width,height),borderValue=200)
cv2_imshow(result)

자르기
슬라이싱은 원본 객체의 값을 그대로 참조해서 자른 이미지에 다른 값을 할당시키면 원본 사진 자체가 변한 것을 확인할 수 있다.

croped_image = image[50:150,50:150]
croped_image[:]=200
cv2_imshow(image)

원본 이미지에 영향을 미치고 싶지 않을 때는 깊은 복사를 사용해야 한다 copy 메서드 사용

resp = urllib.request.urlopen('https://raw.githubusercontent.com/Cobslab/imageBible/main/image/like_lenna224.png')
image = np.asarray(bytearray(resp.read()), dtype='uint8')
image = cv2.imdecode(image, cv2.IMREAD_COLOR)

croped_image = image[50:150, 50:150].copy()
croped_image[:]=200
cv2_imshow(image)

도형 그리기
OpenCV는 이미지에 도형을 그릴 수 있는 기능을 제공한다

선 그리기 : cv2.line
원 그리기 : cv2.circle
직사각형 그리기 : cv2.rectangle
타원 그리기 : cv2.ellipse
다각형 그리기 : cv2.polylines, cv2.fillPoly
2. TensorFlow

구글 브레인 팀에서 개발되어 공개된 오픈 소스 머신 러닝 라이브러리로 다차원 배열을 기반으로 하는 연산을 수행하며 병렬 처리와 지연 실행을 쉽게 수행할 수 있다.

편의성

고수준 API 지원, 사전 빌드된 층 및 모델 제공, 즉시 실행 모드 등
고수준 API에 Keras(케라스)가 있다. 케라스 API는 모든 표준 모델을 정의해서 선형 회귀부터 복잡한 심층 신경망까지 몇 줄의 코드만으로 모델을 설정하고 컴파일할 수 있다. 또한 모델 아키텍처를 자유롭게 정의할 수 있는 기능도 제공한다. Model 클래스 API를 사용하면 층 그래프를 정의하는데 사용돼서 다중 출력 모델, 방향성 비순환 그래프, 공유 층이 있는 모델을 만들 때 유용하다.

확장성

행렬 및 벡터 연산에 더 효율적인 GPU와 TPU에서 모델을 훈련할 수 있기 때문에 CPU만 사용할 때보다 더 복잡한 모델 빠르게 처리 가능
분산 컴퓨팅도 지원해서 여러 머신에서 동시에 모델을 훈련할 수 있다.
모델 학습 후 대규모 모델 배포 도구 제공

유연성

모델 아키텍처 설계를 넘어 데이터 전처리부터 배포까지
텐서플로 저수준 API는 특정 문제에 따라 고유한 층을 제작할 수 있는 기능 제공
맞춤형 손실 함수 생성 도구 제공
tf.data API는 효율적인 데이터 파이프라인을 구축 제공, tf.data는 모든 데이터를 처리할 수 있을 만큼 다용도로 사용할 수 있다

이미지란

2024-07-08T00:00:00+00:00

1. 디지털 이미지의 구조

픽셀

픽셀은 picture(그림)과 element(요소)의 합성어
단일 픽셀 값은 흑백 이미지에서 밝기를 나타내는 숫자, 컬러 이미지에서 픽셀은 빨강, 녹색, 파랑 등 서로 다른 색상을 채널을 나타내는 여러 픽셀 값을 가질 수 있다.

해상도는 이미지가 보유하고 있는 픽셀의 양
해상도 1920x1080는 이미지의 1920픽셀 너비와 1080픽셀 높이를 가지고 있다. 카메라 센서 사이즈에 의해 주로 결정된다. 4k는 가로 픽셀이 4000 이상을 뜻함

픽셀밀도는 (pixel per inch)인치당 픽셀 수, 센티미터당 픽셀 수로 측정되며 픽셀이 얼마나 촘촘하게 배열되어 있는지 척도이다. 픽셀밀도가 높을 수록 텍스트와 그래픽이 더 부드럽고 선명해지기에 더 현실감있게 느껴질 수 있다. 이로 인해 VR과 AR 같은 증강 현실에 중요하다

서브 픽셀은 본질적으로 화면의 픽셀을 구성하는 작은 컬러 요소
RGB 서브 픽셀에서 방출되는 빛의 강도를 조작해서 색상을 구현한다. 더 밝고 에너지 효율적인 디스플레이는 흰색 서브 픽셀이 추가된 RGBW를 사용한다. 흰색 서브 픽셀을 사용하면 RGB를 모두 활성화하지 않고도 흰색을 표현할 수 있어 에너지를 절약할 수 있다.

무손실 압축과 손실 압축

이미지 압축으로 빠른 훈련과 전송 속도, 컴퓨터 비전 모델 성능 향상이라는 장점이 있다. 압축으로 인한 이미지의 왜곡은 품질이 저하된 이미지에서도 모델이 인식할 수 있도록 학습시킬 수 있다.

무손실 압축
portable network graphics의 약자인 PNG 형식은 무손실 압축을 사용한다. 디플레이트 알고리즘을 사용하는데 LZ77과 허프만 코딩이다.

LZ77 : 반복 시퀀스를 효과적으로 축소
허프만 코딩 : 빈도가 높은 패턴을 짧은 코드로 변환

손실 압축
원본 데이터가 일부 손실되는 압축으로 시각으로 인지하기 어려운 특징 데이터를 제거한다. 무손실 압축보다 높은 압축률을 달성할 수 있다. joint photogrephic experts group(JPEG)는 손실 압축으로 그림이나 글자처럼 가장자리가 날카롭고 대비가 있는 이미지에는 아티팩트가 생성되기 때문에 적합하지 않다. 변환, 양자화 및 엔트로피 코딩의 조합을 사용

RGB에서 YCbCr로 변환(서브 샘플링) : Y는 휘도(밝기), Cb와 Cr은 색상을 나타낸다
양자화 : 어려운 픽셀의 패턴은 인간의 시각으로 모두 확인하기 어렵기 때문에 단순화하는데 이 단계에서 손실이 발생한다
엔트로피 코딩 : 데이터 심볼이 발생할 확률에 따라 심볼을 적절한 길이로 부호화하여 표한하는 것으로 종류로는 허프만 코딩, 산술 부호화, LZW 부호화가 있다

2. 색 공간

그레이 스케일

색상 스펙트럼은 없고 밝기값만 주어진다. 0(검정)~255(흰색)으로 이런 단순성 덕분에 계산 저장 공간을 줄이고 처리 속도를 높일 수 있다. 가장자리 감지나 텍스처 분석과 같은 특정 이미지 처리 작업의 경우 색상이 방해되는 경우가 있기에 그레이 스케일이 더 적합하다

RGB

red, green, blue에서 첫 글자를 딴 이름으로 세 가지 색상으로 모든 색을 표현할 수 있다. 세 가지 색상은 채널이라는 이름으로 표현되는데 채널은 색상의 정보를 담고 있는 저장공간으로 빨간색 정보를 담고 있는 빨간색 채널, 초록색 채널, 파란색 채널로 구성된다. 빛의 강도를 조절하여 색상을 조합하여 구현한다

CMYK

인쇄물에는 빛과 달리 다른 접근 방식이 필요해서 생긴 방법으로 청록색, 자홍색, 노란색 잉크로 결합하여 색상을 구현한다. 하지만 잉크의 불완전성으로 인해 완벽한 검은색이 나오지 않은 경우가 많아 검정 잉크가 따로 포함된다.

HSV

HSV는 색상을 세 가지 요소로 나눈다.

Hue(색조) : 색상을 말한다. 빨강, 파랑, 초록 등
Saturation(채도) : 색조의 선명도로 채도가 낮을 수록 색이 바랜 것처럼 보인다
Value(값, 밝기) : 색상의 밝기로 값이 낮을수록 어둡고 칙칙해보인다

비트

1비트 : 두 가지 가능한 값(0과 1)을 제공한다. 그레이 스케일에서 회색 음영이 없는 흑백 이미지
8비트 : 0(검정)부터 255(흰색)까지 색으로 표현 가능한 이미지
16비트 : 0부터 65,535까지 색으로 표현 가능 이미지
24비트(채널당 8비트) : 256x256x256 = 16,777,216개의 색으로 표현 가능한 이미지
48비트(채널당 16비트)

비트 심도의 중요성
색상, 그레이 스케일 음영을 표현하고 구분할 수 있는 정밀도를 결정한다.

이미지 품질 : 비트 심도가 높을수록 그라데이션이 더 부드러워져서 아티팩트가 줄어든다
파일 사이즈 : 비트 심도가 높을수록 파일 사이즈가 커진다
편집의 유연성 : 비트가 높을수록 이미지 품질 저하 없이 편집할 수 있다
특수 이미징 : 천체 사진, 의료 영상과 같은 이미지를 디테일 손실 없이 모든 데이터를 캡쳐하기 위해 특정 비트 심도가 필요하다

3. 이미지에서의 텐서 이해하기

텐서의 이미지 표현

256x256 사이즈의 그레이 스케일 이미지 (256, 256)
256x256 사이즈의 RGB 컬러 이미지 (256, 256, 3)
이미지 배치로 작업할 때나 영상의 경우 4차원 텐서를 사용하는데 여기서 첫 번째 차원 값은 배치에 포함된 이미지 수이다
100개의 이미지 배치의 256x256 사이즈의 컬러 이미지 (100, 256, 256, 3)

이미지 불러오기

tf.keras.utils.get_file : url 이미지를 다운로드하고 저장된 로컬 경로를 반환한다
tf.io.read_file : 경로에서 이미지 파일을 바이너리 문자열로 읽어온다
tf.image.decode_jpeg : 바이너리 문자열을 숫자 텐서로 디코딩한다

import tensorflow as tf

url = 'https://cobslab.com/wp-content/uploads/2022/02/ai-009-1.jpg'
image_path = tf.keras.utils.get_file('/content/image.jpg', origin=url)
image = tf.io.read_file(image_path)
image = tf.image.decode_jpeg(image, channels=3)
image

결과 분석

tf.Tensor : 출력물이 데이터를 캡슐화하는데 사용되는 텐서플로의 핵심 데이터 구조인 텐서 객체
shape=(952,1048,3) : 텐서 사이즈
dtype=unit8 : dtype은 텐서 내 요소의 데이터 유형으로 unit8은 값이 0에서 255 사이의 8비트 부호 없는 정수로 효시된다는 의미
numpy=array : 이미지의 실제 픽셀 값

import matplotlib.pyplot as plt

plt.imshow(image)

plt.axis('off')

plt.show()

다양한 색 공간으로 작업하기

랜덤 텐서 생성

tf.random.uniform을 사용하여 랜덤한 값을 가진 텐서를 생성할 수 있다. 랜덤 텐서는 알고리즘 성능을 평가하거나 색상 패턴 실험에서 사용된다.

rgb_image = tf.random.uniform([100,100,3],maxval=255,dtype=tf.float32)

plt.imshow(rgb_image)
plt.title('RGB Image')
plt.axis('off')
plt.show()

그레이 스케일로 변환

rgb_to_grayscale를 사용해서 RGB 이미지를 그레이 스케일로 바꿀 수 있다. 그레이 스케일은 하나의 채널만 같기에 squeeze 를 사용해서 RGB에 해당하는 차원을 삭제한다.

grayscale_image = tf.image.rgb_to_grayscale(rgb_image)

plt.imshow(grayscale_image.numpy().squeeze(),cmap='gray')
plt.title('Grayscale Image')
plt.axis('off')
plt.show()

RGB 이미지를 그레이 스케일로 변경하는 공식(grayscale = R x 0.299 + G x 0.587 + B x 0.114)으로 코드로 구현할 수 있다

R = rgb_image[0][0][0]*0.299
G = rgb_image[0][0][1]*0.587
B = rgb_image[0][0][2]*0.114
Y=R+G+B

print('그레이 스케일 값 :'+ str(grayscale_image[0][0]))
print('공식으로 구한 그레이 스케일 값 :'+str(Y))

-> 그레이 스케일 값 :tf.Tensor([123.073326], shape=(1,), dtype=float32)
공식으로 구한 그레이 스케일 값 :tf.Tensor(123.076744, shape=(), dtype=float32)

결과 분석
이미지의 RGB 채널값을 각각 처리해주고 합쳐서 그레이 스케일로 변경한 값과 실제 그레이 스케일 이미지의 값이 비슷한 것을 확인할 수 있다. 동일하지 않은 이유는 컴퓨터의 부동 소수점 연산이나 텐서플로 함수의 최적화과정 차이 등으로 인한 차이가 발생한다

HSV로 변환

rgb_to_hsv는 RGB 이미지를 HSV로 변환하는데 사용한다. HSV에서 색소 채널만 추출해서 시각화 시키면서 cmap을 hsv 인수로 사용하면 이미지가 색조 색상 맵으로 렌더링 되어 빨간색(낮은 색조 값)부터 무지개의 모든 색을 거쳐 다시 빨간색(높은 색조 값)까지의 색상을 표시한다

hsv_image = tf.image.rgb_to_hsv(rgb_image)

hue_channel = hsv_image[:,:,0]

plt.imshow(hsv_image, cmap='hsv')
plt.title('Hue Channel of HSV Image')
plt.axis('off')
plt.colorbar(label='Hue Value')
plt.show

결과 분석
무작위 랜덤 이미지여서 색도 채널도 무작위인 것을 확인할 수 있다

픽셀 값의 정규화와 표준화

모델의 성능과 수렴 속도를 위해 픽셀 값의 사이즈를 조정한다

정규화
픽셀 값을 [0,1] 범위로 스케일링 하는 것을 말한다. 픽셀값이 0에서 255 사이인 8비트 이미지라면 255로 나누기만 하면 된다

표준화
이미지의 픽셀 값을 평균 0, 표준 편차 1이 되도록 스케일링하는 과정을 말한다. 표준화는 학습 과정을 가속화할 수 있으므로 머신 러닝 알고리즘에서 중요한 전처리 단계이다. 표준화를 하면 [0,255] 범위 였던 픽셀 값이 [-1, 1] 범위에 속하게 되어서 훈련에 좀 더 일관된 데이터 세트를 제공할 수 있다

#reduce_mean 함수는 텐서의 평균 값을 계산한다. 모든 픽셀의 평균 값을 계산한다. 이는 표준화 과정에서 픽셀 값을 0을 중심으로 정렬하는데 사용
mean = tf.reduce_mean(rgb_image)
#reduce_std 함수는 텐서의 표준 편차를 계산한다. 표준 편차는 픽셀 값의 확산 또는 분산을 측정한다
stddev = tf.math.reduce_std(rgb_image)
#앞서 구한 평균과 표준 편차로 표준화를 진행
normalized_image = (rgb_image-mean)/stddev
rgb_image[0][0], normalized_image[0][0]

-> (,
)

이미지 처리와 컴퓨터 비전

2024-07-03T00:00:00+00:00

이미지 처리와 컴퓨터 비전 둘 다 이미지를 다루지만 접근 방식과 목표는 다르다.

1. image processing(이미지 처리)

analog image processing(아날로그 이미지 처리)
사진 촬영 시 필름에 다양한 화학 처리를 하거나 카메라로 촬영한 이미지를 조작하거나 편집하는 것

digital image processing(디지털 이미지 처리)
수학적 알고리즘과 계산 기술에 의존하며 이미지 향상, 이미지 복원, 특징 추출 등이 포함됨.

디지털 이미지 처리 단계

image acquisition(이미지 획득) : 이미지 캡처 장치를 통해 획득한 이미지를 디지털 형식으로 최대한 품질을 보존하면서 변환하여 컴퓨터에서 처리할 수 있도록 함. 이 과정에서 다양한 이미지 센서와 변환 알고리즘 사용
image enhancement(이미지 개선) : noise reduction(노이즈 제거), contrast adjustment(명암 조절), color correction(색상 보정) 등으로 이미지의 품질을 향상시키는데 초점을 맞춤. 이 과정에서 다양한 필터링 기법, histogram equalized(히스토그램 평활화), sharpening(샤프닝) 등의 기술 사용
image analysis(이미지 분석) : feature extraction(특징 추출), pattern recognition(패턴 인식), object detection(객체 감지) 등으로 이미지의 구조와 패턴을 파악하고 중요한 특징을 식별하여 이미지를 분석함. 이 과정에서 edge detection(에지 검출), corner detection(코너 검출), texture analysis(텍스트 분석) 등의 기술 사용.
image interpretation and understanding(이미지 해석 및 이해) : image classification(이미지 분류), image retrieval(이미지 검색), image recognition(이미지 인식) 등으로 이미지에서 얻은 데이터를 분석하고 이용하여 이미지 분류, 특정 패턴 인식, 이미지 객체 식별 등 여러 방식으로 데이터를 사용함. 이 과정에서 pattern matching(패턴 매칭), machine learning(머신 러닝), deep learning(딥 러닝) 등의 기술 사용.

2. computer vision(컴퓨터 비전)

컴퓨터 비전은 기계가 시각적 데이터를 이해하고 분석하는 능력을 개발하는 과학 분야로 이미지 처리는 주로 디지털 이미지 향상, 복원, 변형에 중점을 두고 컴퓨터 비전은 이미지의 분석과 해석에 초점을 둠. 그래서 컴퓨터 비전은 더 높은 수준의 이해를 필요로 하며 객체 인식, 패턴 분석, 이미지 분류 등의 작업을 포함.

컴퓨터 비전은 디지털 이미지를 통해 우리가 세상을 인식하고 이해하는 방식을 모방하고 이미지로부터 의미있는 정보를 추출하는 것. 즉, 컴퓨터가 사람처럼 볼 수 있도록 하는 것

낮은 수준 비전 작업

노이즈 제거
대비 향상
채도 향상
에지 검출

중간 수준 비전 작업

이미지 영역 분할
이미지 객체로 분할
이미지 광학 흐름 추정

높은 수준 비전 작업

객체 인식
장면 재구성
이미지 학습 및 추론

원본 이미지 -> 이미지 처리 -> 컴퓨터 비전

텍스트에서 키워드 추출하기

2024-06-09T00:00:00+00:00

저번에 추출해온 텍스트에서 키워드를 추출했다

과정

키워드 빈도수 탑 100을 보고 필요없는 키워드들을 불용어 처리 후 다시 탑 100을 봤다 점점 순위가 내려갈수록 필요없는 키워드들이 나오는 것을 보고 그 이후 키워드들을 다 자르고 53개의 키워드가 남았다.

코드

저장해놓은 데이터 불러오기

# CSV 파일 읽기
olive = pd.read_csv('..//올리브영 데이터//oliveyoung_text.csv')
coupang = pd.read_csv('..//쿠팡 데이터//coupang_text.csv')

# 띄어쓰기 변환 함수
def correct_spacing(text):
    okt = Okt()
    tokens = okt.morphs(text)
    corrected_text = ' '.join(tokens)
    return corrected_text

#텍스트 형태소 분석하기 쉽게 처리
docs=olive
for i in range(len(docs)):
    docs['text'][i] = str(docs['text'][i]).replace("\r","")
    docs['text'][i] = str(docs['text'][i]).replace("\n"," ")
    docs['text'][i] = correct_spacing(docs['text'][i])
    docs['text'][i] = re.sub("[0-9]", '', str(docs['text'][i]))

#형태소 분석
title_token_list = [] # 제목의 형태소를 담아낼 리스트
title_token_noun = [] # 제목의 명사를 담아낼 리스트
for i in tqdm(range(len(docs))):
    # komoran.pos() 메서드를 사용하여 형태소 분석 실시
    try:
        pos = komoran.pos(u'{}'.format(docs['text'][i]))
    except Exception as e:
        print(i)
        print(e)
    # komoran.nouns() 메서드를 사용하여 길이가 2이상인 명사를 추출라고 리스트에 저장
    try:
        noun = list(term for term in komoran.nouns(u'{}'.format(docs['text'][i])) if len(term) >1)
    except Exception as e:
        print(i)
        print(e)
    title_token_list.append(pos) # 형태소 분석결과를 리스트에 추가
    title_token_noun.append(noun) # 추출한 명사를 리스트에 추가

#불용어 사전 불러오기
f = open("stopwords-ko.txt", "r", encoding="UTF-8")
st = f.readlines()
f.close()
stw = []
for i in range(0, len(st)):
    stw.append(st[i].rstrip('\n')) # st리스트에서 '\n' 제거

# 사용자가 불용어 추가
user_stopwords = ['크림', '아토', '베리','라마', '이드','피부', '크림',
                  '사용', '쇼핑', '이드','제품', '화장품','글리','도움',
                  '레이', '효과', '부위','라마', '폴리','경우','기능',
                  '뷰티', '로켓', '사항', '상품','씨드', '세린', '명품',
                  '라이', '관리', '주의', '용량', '원료', '광선', '유지',
                  '알코올', '공급', '상담', '완료', '기준','아크릴', '적용',
                  '스킨', '개월', '알란', '프릴', '소비자', '보관', '필요',
                  '로에베', '티코', '다이올', '외부','제수','고민','인체',
                  '사이드','특성', '얼굴', '발라', '이나', '에센스', '아마이드',
                  '폴리머', '오스', '당량', '해결', '에탄올','기한', '에이트',
                  '취급', '증상','상처','개인','결과', '올리브', '만족', '도포',
                  '부문','센터', '라스트', '판매', '성인', '브랜드', '연구원', '베리',
                  '기술', '원료', '마스크', '기획','기간', '리프', '전체', '확인', '워드',
                  '비교', '데카', '파트', '코스', '기관', '반응', '청규', '아토','무도','설문',
                  '토너','랭킹','온라인', '김정문', '수다','라보', '지오', '증가', '방법','페이',
                    '집중', '물질', '리얼','직후','세계','경과','증정','이미지', '페이스',
                  '롤라이','대비','키스', '카프', '증정', '티에', '일리', '반점', '녹차', '가지',
                  '고시', '방법', '자제', '어린이', '이지','고객', '밸런스', '베타', '트리', '공정',
                  '제조', '책임', '에도', '왁스', '토인', '레시틴', '거래', '위원회', '분쟁', '판매업',
                  '프로', '나무', '다이', '번호', '충전', '글로리', '여과', '페이', '보상', '형성', '리페', '에이치','비탄']

stw.extend(user_stopwords)
import csv
with open('불용어.csv','w') as file :
    write = csv.writer(file)
    write.writerow(stw)

#불용어 제거
for word in stw:
    for i in range(0, len(title_token_noun)):
        # 리스트에 불용어가 있을 경우 제거
        try:
            while word in title_token_noun[i]:
                title_token_noun[i].remove(word)
        except:
            pass

# 키워드 저장
raw_data = pd.DataFrame()
raw_data['keyword'] = title_token_noun

raw_data.to_csv("oliveyoung_keyword.csv")

#키워드 빈도수 탑
noun = list(itertools.chain(*title_token_noun)) # 리스트 접합
count = Counter(noun)
top = dict(count.most_common(53))
keyword=list(top.keys())

#최종 키워드 저장
raw_data = pd.DataFrame()
raw_data['top53'] = top
raw_data.to_csv("oliveyoung_top.csv")

#제품에 키워드가 최소 하나 이상 들어가있는지 확인하기
for i in range(len(olive)):
    for j in keyword:
        if olive['text'][i].find(j)!=-1:
            break
        else:
            if keyword==keyword[-1]:
                print(i)

올리브영 이미지에서 텍스트 추출하기

2024-06-04T00:00:00+00:00

화장품마다 광고 키워드를 가져오기 위해 광고 사진에서 텍스트를 추출했다

과정

tesseract를 사용했다가 영어는 괜찮은데 한글이 너무 추출이 안 되고 깨졌다.
우린 한국에서의 마케팅 분석이기 때문에 영어보다 한글이 중요한 만큼 tesseract를 포기하고 다른 방법을 찾아봤다.

다음으로는 구글의 cloud vision api를 사용해봤다.
한글도 문제없이 잘 추출됐다. 하지만 안되는 이미지들이 엄청 많았다. 찾아보니까 다른 사람들도 겪고 있는 문제였지만 해결됐다는 말이 없었다.

그래서 다음으로는 이미지 추출 사이트에서 동적으로 돌리고 추출된 텍스트를 가져오는 코드로 바꿨다. 이 방법은 사실상 완성된 다른 사이트를 이용하는거여서
대부분 문제없이 돌아갔지만 용량이 큰 몇몇 gif들은 프리미엄을 사라고 나왔다. 안 되는 gif들만 확인해보니까 중요한 텍스트가 따로 없어서 안 되는 것들은 버렸다. 이번에는 최종 방법에 대해서만 올리겠다.

저장했던 데이터 불러오기

저장해놓은 데이터 불러오기

# CSV 파일 읽기
img_df = pd.read_csv('..//올리브영 제품 링크//oliveyoung_img_link.csv')


# 이미지 링크 열 이름 수정 ('img_link'로 가정)
image_links1 = img_df['img_link'].tolist()

# URL 확인 및 정리 - 리스트 요소를 문자열로 변환
image_links2 = [url.strip("[]") for url in image_links1 if isinstance(url, str)]
image_links2 = [url.replace("\'","") for url in image_links2 if isinstance(url, str)]

links=[[] for i in range(len(image_links2))]

for i in range(len(image_links2)):
    for j in image_links2[i].split(','):
        j=j.strip()
        links[i].append(j)

사이트 추출해서 최종으로 저장하는 코드

    def text_get(x,y):
    # if links[x][y][-3:]=='gif':
    #     return
    driver.get(links[x][y])
    links[x][y]=driver.current_url
    driver.back()
    driver.find_element(By.CLASS_NAME, 'enterUrl ').click()
    driver.execute_script("window.scrollTo(0,500)")
    time.sleep(0.5)
    try:
        driver.find_element(By.CSS_SELECTOR, "#uploadfile > div > div.col-xl-9 > div.col-12.image_back.toolColor.text-center.m-0-auto.d-block.br_10.p-3 > div > div.col-12.urlArea.d_none.mt-3 > div > input").send_keys(links[x][y])
        driver.find_element(By.CLASS_NAME, 'urlBtn ').click()
        driver.execute_script("window.scrollTo(0,800)")
        time.sleep(1)
        clickable_element = WebDriverWait(driver, 10).until(
            EC.element_to_be_clickable((By.CLASS_NAME, 'convertFiles'))
        )
        time.sleep(10)
        clickable_element.click()
        # driver.find_element(By.CLASS_NAME, 'convertFiles').click()
        driver.execute_script("window.scrollTo(0,700)")
        #가능해질 때까지 기다리기
        clickable_element = WebDriverWait(driver, 10).until(
            EC.element_to_be_clickable((By.CLASS_NAME, 'copyData'))
        )
        time.sleep(25)
        clickable_element.click()
        driver.execute_script("window.open('{}')".format('https://n.lrl.kr/'))
        driver.switch_to.window(driver.window_handles[1])
        # driver.find_element(By.CLASS_NAME, 'copyData').click()
        time.sleep(1)
        a=driver.find_element(By.CLASS_NAME, 'note-editable')
        a.click()
        a.send_keys(Keys.CONTROL, 'v')
        time.sleep(1)
        html=driver.page_source
        soup=BS(html,'html.parser')
        result=soup.find("div",attrs={"class":"note-editable"})
        if result.text!='':
            if len(text[x])>=y:
                text[x][y]=result.text
            else:
                text[x].append(result.text)
    except Exception as e:
        print(str(x)+"-"+str(y))
        print(e)
    finally:
        driver.close()
        time.sleep(1)

        driver.switch_to.window(driver.window_handles[0])
        driver.execute_script("window.scrollTo(0,1200)")
        time.sleep(1)
        driver.find_element(By.CLASS_NAME, 're_convert').click()

driver = webdriver.Chrome()
driver.get('https://www.cardscanner.co/ko/image-to-text')
for i in re_index:
    text_get(int(i.split("-")[0]),int(i.split("-")[1]))

raw_data = pd.DataFrame()
raw_data['text'] = plus_text
raw_data.to_csv("oliveyoung_text.csv")

올리브영 제품 링크 가져오기

2024-06-01T00:00:00+00:00

화장품 키워드 마케팅 분석 전 올리브영에서 제품 링크 가져오기

소감

이번에는 데이터를 가져오기 전에 관련된 링크를 다 가져왔다. 시간에 쫓기느라 코드를 예쁘게 짜기보단 실행되기만 하면 된다라는 생각으로 짜서 나도 한 번에 이해하기 힘들 정도로 코드가 더럽다.

모든 링크 가져오기

크림 카테고리 제품이 총 27페이지였다 url에서 페이지 수를 바꿔가면서 데이터를 가져왔다

driver = webdriver.Chrome()
driver.get('https://www.oliveyoung.co.kr/store/display/getMCategoryList.do?dispCatNo=100000100010015&isLoginCnt=0&aShowCnt=0&bShowCnt=0&cShowCnt=0&gateCd=Drawer&trackingCd=Cat100000100010015_MID&trackingCd=Cat100000100010015_MID&t_page=드로우_카테고리&t_click=카테고리탭_중카테고리&t_2nd_category_type=중_크림')

link=[]

for i in range(1,27):
    url ='https://www.oliveyoung.co.kr/store/display/getMCategoryList.do?dispCatNo=100000100010015&fltDispCatNo=&prdSort=01&pageIdx='+str(i)+'&rowsPerPage=24&searchTypeSort=btn_thumb&plusButtonFlag=N&isLoginCnt=0&aShowCnt=&bShowCnt=&cShowCnt=&trackingCd=Cat100000100010015_Small&litudePageGubun=&t_page=&t_click=&midCategory=%ED%81%AC%EB%A6%BC&smallCategory=%EC%A0%84%EC%B2%B4&checkBrnds=&lastChkBrnd='
    driver.switch_to.window(driver.window_handles[0]) # 첫 번째 탭으로 이동
    driver.execute_script("window.open('{}')".format(url)) # URL 실행
    driver.switch_to.window(driver.window_handles[1]) # 두 번째 탭으로 이동
    time.sleep(2)
    html = driver.page_source  # 현재 페이지의 HTML 코드를 가져옴
    soup = BS(html, 'html.parser')
    list = soup.find_all("div", attrs={"class": "prd_info"})
    for i in range(len(list)):
        a=list[i].find("a", attrs={"class":"prd_thumb goodsList"}).attrs['href']
        link.append(a)
    driver.close()
    time.sleep(0.3)

리뷰가 2000개 이상인 제품만 링크 따로 저장하기

아까 가져왔던 전체 제품 링크에 들어가서 리뷰 데이터가 2000개 이상이라면 링크를 저장했다 = 샘플 링크

from selenium.common.exceptions import TimeoutException
review=[]

for i in range(len(raw_data)):
    url = raw_data['link'][i]
    try:
        driver.switch_to.window(driver.window_handles[0]) # 첫 번째 탭으로 이동
        driver.execute_script("window.open('{}')".format(url)) # URL 실행
        driver.switch_to.window(driver.window_handles[1]) # 두 번째 탭으로 이동
        time.sleep(0.5)
        html = driver.page_source  # 현재 페이지의 HTML 코드를 가져옴
        soup = BS(html, 'html.parser')
        review_count = soup.find("a", attrs={"class": "goods_reputation"})
        num=int(re.sub(r'[^0-9]', '', review_count.find("span").text))
        if (num>=2000):
            link.append(url)
            review.append(num)
    except TimeoutException as e:
        println(url)
    finally:
        driver.close()
        time.sleep(0.3)
        if(i%10==0):
            print(str(i)+"/"+str(len(raw_data)))

리뷰가 2000개 이상인 제품의 광고 이미지 링크 가져오기

샘플 링크에 들어가서 제품 설명 이미지를 다 가져왔다 제품마다 이미지가 한 개 인 곳도 여러개인 곳도 있어서 2차원 사용

img_link=[[] for i in range(len(link))]
wo
for i in range(len(link)):
    url = link[i]
    try:
        driver.switch_to.window(driver.window_handles[0]) # 첫 번째 탭으로 이동
        driver.execute_script("window.open('{}')".format(url)) # URL 실행
        driver.switch_to.window(driver.window_handles[1]) # 두 번째 탭으로 이동
        time.sleep(0.5)
        html = driver.page_source  # 현재 페이지의 HTML 코드를 가져옴
        soup = BS(html, 'html.parser')
        driver.close()

        group = soup.find("div", attrs={"class": "iPrdViewimg"})
        if(group==None):
            group=soup.find_all("picture")
        img=[]
        for j in group:
            if isinstance(j, NavigableString):
                continue
            img.append(j.find_all("img"))
        for j in img:
            for m in j:
                if(m["src"][0:8]!="https://"):
                    img_link[i].append(m["data-src"])
                else:
                    img_link[i].append(m["src"])
    except Exception:
        println(url)
    finally:
        time.sleep(0.3)
        if(i%10==0):
            print(str(i)+"/"+str(len(link)))

올리브영 제품 리뷰 가져오기

2024-06-01T00:00:00+00:00

올리브영 샘플 리뷰 가져오기

소감

리뷰가 url 차이도 없이 클릭으로만 나와서 동적 크롤ㄹ을 사용할 수 밖에 없었다. 올리브영 사이트 내에 제품이니까 다 양식이 같을 줄 알고 XPATH로 클릭을 했더니 몇몇 링크가 다른 양식이라서 다른 방법으로 바꿨다. 또 너무 오래 걸리다보니까 켜놓고 잠들었다가 화면이 꺼져서 날라가서 다시 처음부터 여러번 시작했다. 스크롤 내려가는 정도를 애매하게 해놨다가 넘어간 페이지도 여럿이었다. 마지막날엔 안 된 페이지만 다시 가져오려고 처리하다가 코드를 반대로 써서 필요한 11만개 데이터가 다 날라가고 필요없는 6개 데이터만 남기도 했다. 진짜 저때는 세상에서 사라지고 싶었다 저장하고 했어야 하는데 너무 안일했다 4일동안 제대로 못 자고 자다가 몇 시간 간격으로 일어나서 확인했는데 오히려 잠을 제대로 못 자느라 머리가 잘 안 돌아가서 4일이나 걸린 것 같기도 하다

리뷰가 다 있는줄 알았는데 올리브영에서 제품당 1000개만 보이게 해놔서 약 11만개의 리뷰를 가져왔다. 1000개만이라서 차라리 다행인 것 같기도ㅎ..

샘플 리뷰 데이터 가져오기

저장해놓은 데이터 불러오기

#샘플 제품 링크
link = pd.read_csv('올리브영 제품 링크//oliveyoung_sample_link.csv')
link=link['link']
#그나마 저장해놨던 데이터
data=pd.read_csv('oliveyoung_reviews.csv')

데이터가 이상하게 저장되어 있어서 원래대로 분리 해주는 함수

def str_out(st):
    return_text=[]
    t=""
    input_ok=0
    for i in st:
        if input_ok==1:
            if i=="\'":
                input_ok=0
                return_text.append(t)
                t=""
            else:
                t+=i
        else:
            if i=="\'":
                input_ok=1
    return return_text

데이터 세팅

#별점
star=[]

for i in range(len(data['star'])):
    star.append(list(filter(lambda a: a.isdigit()==True,data['star'][i])))

star[26]=[]
#피부 타입
skin_type=[]
for i in range(len(data['skin_type'])):
    a=str_out(data['skin_type'][i])
    skin_type.append(a)
skin_type[26]=[]

#리뷰 내용
reviews=[]
for i in range(len(data['review'])):
    a=str_out(data['review'][i])
    reviews.append(a)
reviews[26]=[]

페이지 양식에 맞춰서 가져오는 함수

def info_get(index):
    html = driver.page_source
    soup = BS(html, 'html.parser')

    info = soup.find_all("div", attrs={"class":"user clrfix"})
    for i in range(len(info)):
        #피부타입
        try:
            sk=info[i].find("p", attrs={"class":'tag'})
            type=""
            for k in sk.find_all("span"):
                type+=k.text+","

            type=type[:-1]
            skin_type[index].append(type)
        except:
            skin_type[index].append("")

    review = soup.find_all("div", attrs={"class":"review_cont"})
    for i in range(len(review)):
        #리뷰내용
        try:
            re=review[i].find("div", attrs={"class": "txt_inner"}).text
            reviews[index].append(re)
        except:
            reviews[index].append("")
         #별점
        try:
            st=review[i].find("span", attrs={ "class":"point"}).text
            st=st.split("5점만점에 ",1)[1]
            star[index].append(st)
        except:
            star[index].append("")

모든 링크 리뷰 가져오기

driver = webdriver.Chrome()
driver.get('https://www.oliveyoung.co.kr/store/display/getMCategoryList.do?dispCatNo=100000100010015&isLoginCnt=0&aShowCnt=0&bShowCnt=0&cShowCnt=0&gateCd=Drawer&trackingCd=Cat100000100010015_MID&trackingCd=Cat100000100010015_MID&t_page=드로우_카테고리&t_click=카테고리탭_중카테고리&t_2nd_category_type=중_크림')

for index in range(26, len(star)):#check_index:
    page_num=1
    url = link[index]
    try:
        driver.switch_to.window(driver.window_handles[0]) # 첫 번째 탭으로 이동
        driver.execute_script("window.open('{}')".format(url)) # URL 실행`
        driver.switch_to.window(driver.window_handles[1]) # 두 번째 탭으로 이동
        time.sleep(1)
        driver.execute_script("window.scrollTo(0, 1500)")
        driver.find_element(By.ID, 'reviewInfo').click()
        time.sleep(1)
        driver.find_element(By.ID, 'searchType_1').click()
        driver.find_element(By.ID, 'searchType_3').click()
        driver.find_element(By.XPATH, '//*[@id="gdasSort"]/li[3]/a').click()
        time.sleep(1)
        driver.execute_script("window.scrollTo(0, 2500)")
        time.sleep(1)

        while True:
            try:
                time.sleep(1)
                driver.execute_script("window.scrollTo(0, 4000)")
                time.sleep(1.5)
                err=0
                for i in range(10):
                    if page_num==100:
                        info_get(index)
                        break
                    if page_num>10:
                        i+=1
                    page_num+=1
                    try:
                        info_get(index)
                        driver.execute_script("window.scrollTo(0, 4000)")
                        time.sleep(1)
                        page=driver.find_element(By.CLASS_NAME, 'pageing')
                        page=page.find_elements(By.TAG_NAME, 'a')
                        time.sleep(1)
                        page[i].click()
                        time.sleep(1)
                    except Exception as e:
                        print(e)
                        err=1
                        break
                if page_num==100:
                    break
                if err==1:
                    break
            except Exception as e:
                print(e)
                break
    except Exception as e:
        print("페이지 이상: link "+str(index))
    finally:
        driver.close()
        time.sleep(0.3)
        if(index%10==0):
            print(str(index)+"/"+str(len(link)))

데이터 제대로 못 가져온 링크 인덱스 따로 저장

check_index=[]

for i in range(len(star)):
    if len(skin_type[i])==len(star[i])==len(reviews[i])==1000:
        print(reviews[i])
    else:
        skin_type[i]=[]#None
        star[i]=[]#None
        reviews[i]=[]#None
        check_index.append(i)

K nearest neighbors regression

2024-05-24T00:00:00+00:00

지도 학습 알고리즘

분류 : 샘플을 몇 개의 클래스 중 하나로 분류하는 문제
회귀 : 정해진 클래스가 아닌 임의의 수치를 예측하는 문제

k-최근접 이웃

분류 : 가까운 k개 중에 제일 많은 클래스가 샘플의 클래스가 된다
회귀 : 가까운 k개의 평균이 샘플의 수치가 된다

‘회귀’의 탄생

WHO? 19세기 통계학자이자 사회학자인 프랜시스 골턴
HOW? 그는 키가 큰 사람의 아이가 부모보다 더 크지 않다는 사실을 관찰하고 이를 ‘평균으로 회귀한다’라고 표현했다. 그 후 두 변수 사이의 상관관계를 분석하는 방법을 회귀라고 불렀다.

k-최근접 이웃 회귀 모델

데이터준비

import numpy as np
perch_length = np.array([8.4, 13.7, 15.0, 16.2, 17.4, 18.0, 18.7, 19.0,
       19.6, 20.0, 21.0, 21.0, 21.0, 21.3, 22.0, 22.0, 22.0, 22.0, 22.0,
       22.5, 22.5, 22.7, 23.0, 23.5, 24.0, 24.0, 24.6, 25.0, 25.6, 26.5,
       27.3, 27.5, 27.5, 27.5, 28.0, 28.7, 30.0, 32.8, 34.5, 35.0, 36.5,
       36.0, 37.0, 37.0, 39.0, 39.0, 39.0, 40.0, 40.0, 40.0, 40.0, 42.0,
       43.0, 43.0, 43.5, 44.0])
perch_weight = np.array([5.9, 32.0, 40.0, 51.5, 70.0, 100.0, 78.0, 80.0,
       85.0, 85.0, 110.0, 115.0, 125.0, 130.0, 120.0, 120.0, 130.0,
       135.0, 110.0, 130.0, 150.0, 145.0, 150.0, 170.0, 225.0, 145.0,
       188.0, 180.0, 197.0, 218.0, 300.0, 260.0, 265.0, 250.0, 250.0,
       300.0, 320.0, 514.0, 556.0, 840.0, 685.0, 700.0, 700.0, 690.0,
       900.0, 650.0, 820.0, 850.0, 900.0, 1015.0, 820.0, 1100.0, 1000.0,
       1100.0, 1000.0, 1000.0])

데이터의 형태 파악을 위한 시각화 (x축: 특성 데이터인 길이, y축: 타깃 데이터인 무게)

농어 길이와 무게가 비례하는 것을 확인할 수 있다

import matplotlib.pyplot as plt
plt.scatter(perch_length, perch_weight)
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

결과 »

데이터를 모델에 사용하기 전에 테스트와 훈련 세트 나누기

from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target
= train_test_split(perch_length, perch_weight, random_state=42)

perch_length가 1차원 배열이기 때문에 이를 나눈 train_input과 test_input도 1차원이다

print(train_input.shape)

결과 » (42,)

사이킷런에서 훈련을 하기 위해 reshape 함수를 사용해서 2차원으로 바꾸기
ex) [1,2,3] -> [ [1],[2],[3] ] , 크기 (3, ) -> 크기(3, 1)

reshape() 함수는 지정한 크기가 원소 개수와 다르면 에러가 발생한다

train_input.reshape(2,3)

결과 » cannot reshape array of size 42 into shape (2,3)

크기에 -1을 지정하면 나머지 원소 개수로 모두 채워준다

# train_input.reshape(42,1)도 가능
train_input = train_input.reshape(-1,1)
test_input=test_input.reshape(-1,1)
print(train_input.shape)

결과 » (42, 1)

객체 생성과 회귀 모델 훈련하기

k-최근접 이웃 분류에서 사용한 클래스 KNeighborsClassfier과 비슷한 KNeighborsRegressor을 k-최근접 이웃 회귀에서 사용한다

from sklearn.neighbors import KNeighborsRegressor
knr = KNeighborsRegressor()
knr.fit(train_input, train_target)

테스트 세트의 테스트 점수 확인

분류: 정확도 (샘플을 정확하게 분류한 개수의 비율)
회귀: 결정계수 (정확하게 맞히는 것은 불가능하기에 정확도가 아닌 결정계수)

결정계수 = 1- (타깃-예측)^2의 합/ (타깃- 평균)^2의 합

분자와 분모가 비슷해지면(예측이 타깃의 평균가 비슷해지면) 결정계수는 0에 가까워지고 타깃과 예측이 비슷해지면 결정계수는 1에 가까운 값이 된다

print(knr.score(test_input, test_target))

결과 » 0.992809406101064

타깃과 예측의 절댓값 오차 평균

이 외에도 타깃과 예측한 값 사이를 구해서 예측이 어느정도 벗어났는지 확인할 수 있다

예측값이 평균적으로 19g 정도 타깃값과 다르다는 것을 알 수 있다

from sklearn.metrics import mean_absolute_error
test_prediction = knr.predict(test_input)
mae = mean_absolute_error(test_target, test_prediction)
print(mae)

결과 » 19.157142857142862

훈련 세트의 테스트 점수 확인

훈련세트로 훈련을 했기에 훈련 점수가 더 높아야 함에도 불구하고 테스트 세트의 점수가 더 높다.
이는 과소적합 됐다고 볼 수 있다

과대적합: 훈련세트 점수는 좋지만 테스트 세트의 점수가 굉장히 안 좋다
과소적합: 테스트 세트의 점수가 더 좋거나 두 점수 모두 너무 낮다

과소 적합은 훈련, 테스트 세트의 크기가 매우 작거나 모델이 단순해서 훈련이 제대로 되지 않았을 때 일어난다

print(knr.score(train_input,train_target))

결과 »0.9698823289099254

과소 적합을 해결하기 위해 모델을 조금 더 복잡하게 만들겠다

k-최근접 이웃 알고리즘 모델은 k의 개수를 줄이면 더 복잡하게 만들 수 있다
이웃의 개수를 줄이면 훈련 세트에 잇는 국지적인 패턴에 민감해지고 이웃의 개수를 늘리면 데이터 전반의 일반적인 패턴을 따를 것이다

knr.n_neighbors=3

knr.fit(train_input, train_target)

테스트와 훈련 세트의 점수 확인

테스트 세트의 점수가 더 낮아졌으니 과소적합 문제가 해결됐다

print(knr.score(train_input, train_target))
print(knr.score(test_input, test_target))

결과 » 0.9804899950518966 0.9746459963987609

birdfoot

ensemble of trees

ensemble learning(앙상블 학습)

사이킷런의 앙상블 학습 알고리즘

사이킷런 라이브러리

필요한 도구들

1. OpenCV

2. TensorFlow

이미지란

1. 디지털 이미지의 구조

픽셀

무손실 압축과 손실 압축

2. 색 공간

그레이 스케일

RGB

CMYK

HSV

비트

3. 이미지에서의 텐서 이해하기

텐서의 이미지 표현

이미지 불러오기

다양한 색 공간으로 작업하기

랜덤 텐서 생성

그레이 스케일로 변환

HSV로 변환

픽셀 값의 정규화와 표준화

이미지 처리와 컴퓨터 비전

1. image processing(이미지 처리)

2. computer vision(컴퓨터 비전)

텍스트에서 키워드 추출하기

저번에 추출해온 텍스트에서 키워드를 추출했다

올리브영 이미지에서 텍스트 추출하기

화장품마다 광고 키워드를 가져오기 위해 광고 사진에서 텍스트를 추출했다

올리브영 제품 링크 가져오기

화장품 키워드 마케팅 분석 전 올리브영에서 제품 링크 가져오기

올리브영 제품 리뷰 가져오기

올리브영 샘플 리뷰 가져오기

K nearest neighbors regression

지도 학습 알고리즘

k-최근접 이웃

‘회귀’의 탄생

k-최근접 이웃 회귀 모델