<!doctype html>
๋ฌธ์์ ์ฌ๋
0. Base
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ด ๋ฌธ์๊ฐ ์๊ณ , ๋ฌธ์๋ฅผ feature space์ ๋๋๋ค๊ณ ์๊ฐํด๋ณด์
๊ฐ์์ง | ๊ท์ฝ๋ค | ๋งค์ฐ | |
---|---|---|---|
๊ฐ์์ง๊ฐ ๊ท์ฝ๋ค | 1 | 1 | 0 |
๊ฐ์์ง๊ฐ ๋งค์ฐ ๊ท์ฝ๋ค | 1 | 1 | 1 |
๊ณ ์์ด๊ฐ ๋งค์ฐ ๊ท์ฝ๋ค | 0 | 1 | 1 |
๊ฐ ๋จ์ด ‘๊ฐ์์ง’, ‘๊ณ ์์ด’, ‘๋งค์ฐ’๋ฅผ ์ถ์ผ๋ก ํ๋ ํน์ฑ๊ณต๊ฐ(feature space)์์ ๋ค์ ๋ฌธ์๋ค์ ํ๋์ ์ขํ๋ก ์๊ฐํ ์ ์์
- ‘๊ฐ์์ง๊ฐ ๊ท์ฝ๋ค’ --> (1,1,0)
- ‘๊ฐ์์ง๊ฐ ๋งค์ฐ ๊ท์ฝ๋ค’ --> (1,1,1)
- ‘๊ณ ์์ด๊ฐ ๋งค์ฐ ๊ท์ฝ๋ค’ --> (0,1,1)
๋ ๋จ์ด ํน์ ๋ฌธ์ฅ์ด ์ฃผ์ด์ก์ ๋, ์ ์ฌ๋๋ฅผ ์ธก์ ํ๋ ๋ฐฉ๋ฒ์ ์ฌ๋ฌ๊ฐ์ง๊ฐ ์๋ค
- cosine similarity
- jaccard similarity
- euclidean distance
- manhattan distance
๐ -
- jaccard ์ ์ฌ๋๋ ์ค๋ณต์ ๊ณ ๋ คํ์ง X, cosine ์ ์ฌ๋๋ ์ค๋ณต ๊ณ ๋ ค O
1. cosine ์ ์ฌ๋
cosine ์ ์ฌ๋๋ vector๋ก ํํ๋ ๋ ๋ฌธ์ฅ์ด ์ด๋ฃจ๋ ๊ฐ๋์ cosine๊ฐ์ด๋ค. ๋ฐ๋ผ์ cosine ์ ์ฌ๋๋ฅผ ๊ณ์ฐํ๊ธฐ ์ํด์๋ ๋ฌธ์ฅ์ vector๋ก ๋ณํํ๋ ์์ ํ์
โ๏ธ ๊ณต์
** ์์ )**
‘๊ฐ์์ง ๊ท์ฌ์. ๊ฐ์์ง ๊ท์ฌ์’ ์ ‘๊ณ ์์ด ๊ท์ฌ์’ ๋ ‘๊ฐ์์ง ๊ท์ฌ์’ ์ ๋๊ฐ์ ๊ฑฐ๋ฆฌ์ ์์
(2,0,2) (0,1,1) (1,0,1)
‘๊ฐ์์ง ๊ท์ฌ์. ๊ฐ์์ง ๊ท์ฌ์’ ์ ๊ฐ์์ง ๊ท์ฌ์’ == ‘๊ณ ์์ด ๊ท์ฌ์’ ์ ‘๊ฐ์์ง ๊ท์ฌ์’
๊ฐ์์ง | ๊ณ ์์ด | ๊ท์ฝ๋ค | |
---|---|---|---|
๊ฐ์์ง ๊ท์ฌ์. ๊ฐ์์ง ๊ท์ฌ์ | 2 | 0 | 2 |
๊ณ ์์ด ๊ท์ฌ์ | 0 | 1 | 1 |
๊ฐ์์ง ๊ท์ฌ์ | 1 | 0 | 1 |
๋ฌธ์ฅ์ vector๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ
- TF-IDF๋ฅผ ์ด์ฉํ bag of words โ๏ธ
- word2vec
doc์ vector๋ก ๋ณํํ๊ฒ ๋๋ฉด vector์ ๊ธธ์ด๋ ์ด ๋ฌธ์ ๋ด ๋จ์ด ์๊ฐ ๋๋ค
๊ณผ์
- ๋จผ์ tf-idf matrix๋ฅผ ์์ฑํ์ฌ ๋ฌธ์๋ฅผ ๋ฒกํฐํ
- cosine_similarity/linear_kernel ํจ์๋ฅผ ์ด์ฉํ์ฌ cosine similarity matrix ์์ฑ
from sklearn.feature_extraction.text import TfidfVectorizer
โ
tfidf = TfidfVectorizer()
# title์ ๋ํด์ tf-idf ์ํ
tfidf_matrix = tfidf.fit_transform(df['title_token'])
print(tfidf_matrix.shape)
sklearn์์ ์ ๊ณตํ๋ ํจํค์ง ์ค linear_kernel
์ ์ฌ์ฉํ์ฌ cosine similarity ๊ณ์ฐ
from sklearn.metrics.pairwise import cosine_similarity
# scikit-learn cosine similarity API๋ ํฌ์ํ๋ ฌ, ๋ฐ์งํ๋ ฌ ๋ชจ๋ ๊ฐ๋ฅ + ๋ฐฐ์ด, ํ๋ ฌ ๋ชจ๋ ๊ฐ๋ฅ
โ
from sklearn.metrics.pairwise import linear_kernel
# cosine_similarity๋ณด๋ค ๋น ๋ฆ
โ
# ์์ ๋ง๋ tf-idf matrix๋ก cosine similarity ๊ณ์ฐ
cos_sim = linear_kernel(tfidf_matrix,tfidf_matrix)
# ์ ์ฌ๋๋ฅผ ์ด์ฉํ ์ถ์ฒ
# ๋ณด๊ณ ์ํ๋ index์ ๊ฐ์ฅ ์ ์ฌํ ๋ฌธ์ 10๊ฐ์ index ์ฐพ๊ธฐ
# sim score๋ฅผ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ์ฌ top10๊ฐ์ index์ score ๋ฐํ
def top10(idx, sim_pair) :
sim_score = list(enumerate(sim_pair[idx]))
sim_score = sorted(sim_score, key = lambda x:x[1], reverse=True)
# ์์ 100๊ฐ ํญ๋ชฉ ๊ฐ์ ธ์ด
top10score = sim_score[1:11]
tag_indices = [i[0] for i in top10score]
score = [i[1] for i in top10score]
return tag_indices, score
2. jaccard ์ ์ฌ๋
- ๋ ๋ฌธ์ฅ์ ๊ต์งํฉ๊ณผ ํฉ์งํฉ์ ํฌ๊ธฐ๋ฅผ ํตํด ๊ตฌํ๋ ๋ฐฉ์
โ๏ธ ๊ณต์
์์ )
๋ค์ ๋ ๋ฌธ์ฅ์ด ์ฃผ์ด์ง๋ค๊ณ ๊ฐ์
โป ์ ์์์์๋ ์ ์ฌ๋ ๊ณ์ฐ ์ ์ lemmatization ๊ณผ์ ์ ๊ฑฐ์นจ (lemmatization์ ๋จ์ด์ ๋ฟ๋ฆฌ๋ ์ฐพ๋ ๊ณผ์ . ์ : had์ has์ ๋ฟ๋ฆฌ๋ have)
๋ค์ด์ด๊ทธ๋จ์ ํตํด ๋ ๋ฌธ์ฅ์ ๊ต์งํฉ์ ๋จ์ด๊ฐ์๋5๊ฐ, ํฉ์งํฉ์ 10๊ฐ โก๏ธ jaccard similarity = 0.5
python code
xxxxxxxxxx
def get_jaccard_sim(str1, str2):
a = set(str1.split())
b = set(str2.split())
c = a.intersection(b)
return float(len(c)) / (len(a) + len(b) - len(c))
*jaccard ์ ์ฌ๋๋ set์ ์ฌ์ฉ โก๏ธ ์ค๋ณต์ ๊ณ ๋ คํ์ง ์์
*
3. Euclidean ๊ฑฐ๋ฆฌ
๋ฌธ์๋ฅผ ์ขํ๋ก ํํํ๊ณ ๋ ์ขํ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ์ฌ ์ ํด๋ฆฌ๋ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐ. ์ด๋, ๋ฌธ์์ ์ขํ๋ ๊ฐ ๋จ์ด์ ์ถํ ๋น๋์ด๋ฏ๋ก CountVectorizer์ฌ์ฉ
๋จ์ด์ ์ถํ๋น๋๋ก ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๋จ์ด์ ๋น๋๊ฐ ๋์ด๋๊ฑฐ๋ ์ค์ด๋ค๋ฉด ์๋ฏธ์ ์ฐจ์ด๊ฐ ์๋๋ผ๋ ๊ฑฐ๋ฆฌ๊ฐ ๋ฉ์ด์ง
์์ )
‘๊ฐ์์ง ๊ท์ฌ์. ๊ฐ์์ง ๊ท์ฌ์’ ์ ‘๊ณ ์์ด ๊ท์ฌ์’ ๋ ‘๊ฐ์์ง ๊ท์ฌ์’ ์ ๋๊ฐ์ ๊ฑฐ๋ฆฌ์ ์์
(2,0,2) (0,1,1) (1,0,1)
‘๊ฐ์์ง ๊ท์ฌ์. ๊ฐ์์ง ๊ท์ฌ์’ ์ ๊ฐ์์ง ๊ท์ฌ์’ == ‘๊ณ ์์ด ๊ท์ฌ์’ ์ ‘๊ฐ์์ง ๊ท์ฌ์’
๊ฐ์์ง ๊ณ ์์ด ๊ท์ฝ๋ค ๊ฐ์์ง ๊ท์ฌ์. ๊ฐ์์ง ๊ท์ฌ์ 2 0 2 ๊ณ ์์ด ๊ท์ฌ์ 0 1 1 ๊ฐ์์ง ๊ท์ฌ์ 1 0 1
xxxxxxxxxx
from sklearn.metrics.pairwise import euclidean_distances
# 0๋ฒ ๋ฌธ์์ 1๋ฒ ๋ฌธ์ ์ฌ์ด์ ๊ฑฐ๋ฆฌ
print(euclidean_distances(tdm[0], tdm[1]))
๋ฌธ์ฅ์ vector๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ
- TF-IDF๋ฅผ ์ด์ฉํ bag of words
- word2vec
๋ ๋ฐฉ๋ฒ์ ํฐ ์ฐจ์ด...
- tf-idf๋ ํ ๋จ์ด๋น ํ ์ซ์๋ฅผ ๋ง๋ค์ด๋ / word embedding์ ํ ๋จ์ด๋น ํ vector๋ฅผ ๋ง๋ค์ด๋
- tf-idf๋ ์ ์ฒด์ ์ผ๋ก ๋ฌธ์๋ฅผ ๋ถ๋ฅํ๋๋ฐ ์ ์๋ / word embedding์ ๋ฌธ๋งฅ์ ์ธ ๋ด์ฉ์ ํ์ธํ๋๋ฐ ์ ์๋
1) TF-IDF๋ฅผ ์ด์ฉํ bag of words
2) word2vec
reference
https://simonezz.tistory.com/45
https://leo-bb.tistory.com/18 : ๋ฌธ์๊ฐ ์ฝ์ฌ์ธ ์ ์ฌ๋์ ๊ธฐ๋ฐํ '์ ์ฌ ๊ฒ์๋ฌผ ์ถ์ฒ์์คํ '
http://doc.mindscale.kr/km/unstructured/04.html : ์ฃผ์ ๋ถ์ - ๋ฌธ์์ ์ฌ๋, ํด๋ฌ์คํฐ๋ง, ํ ํฝ๋ชจ๋ธ๋ง
๋ฌธ์ ๊ตฐ์งํ - KMeans
์ ๋ฐ์ดํฐ ์ฌ์ฉ
x
title_token_doc = df['title_token_doc'].values
โ
from sklearn.feature_extraction.text import TfidfVectorizer
โ
tfidf = TfidfVectorizer()
# title์ ๋ํด์ tf-idf ์ํ
tfidf_matrix = tfidf.fit_transform(title_token_doc)
print(tfidf_matrix.shape)
x
from sklearn.cluster import KMeans
km = KMeans(n_clusters=4, random_state=1234)
cluster_label = km.fit_transform(tfidf_matrix)
์ต์ K ์ ํ๊ธฐ
- elbow ๊ธฐ๋ฒ
- silhouette ๊ธฐ๋ฒ
- dunn index
- DB
1. elbow ๊ธฐ๋ฒ
kmeans clustering์ ๊ตฐ์ง ๋ด SSE(์ค์ฐจ์ ๊ณฑํฉ)์ด ์ต์๊ฐ ๋๋๋ก cluster์ ์ค์ฌ์ ๊ฒฐ์ ํด๋๊ฐ
๋ฐ๋ผ์, k=1์ผ๋๋ณด๋ค k=2์ผ๋์ SSE๊ฐ ์๋ค๋ฉด k=2๊ฐ ๋ ์ ํฉํ๋ค๋ ๊ฒ์ ์ ์ ์์
์ด๋ฐ์์ผ๋ก cluster์ ๊ฐ์๋ฅผ ๋๋ ค๋๊ฐ๋ฉด SSE๋ฅผ ๊ณ์ฐํ๊ณ ์ด๋ฅผ ๊ทธ๋ํ๋ก ํํ
SSE๊ฐ์ด ์ ์ ์ค๋ค๊ฐ ์ค์ด๋๋ ๋น์จ์ด ๊ธ๊ฒฉํ๊ฒ ์์์ง๋ ๋ถ๋ถ์ด ์๊น. ์ด๋ ๊ทธ๋ํ ๋ชจ์์ด ํ๊ฟ์น ๊ฐ๋ค๊ณ ํ์ฌ elbow๋ผ๋ ์ด๋ฆ์ด ๋ถ์
๊ทธ๋ฆฌ๊ณ ์ด ํ๊ฟ์น์ ํด๋นํ๋ ๋ถ๋ถ์ด ์ฐ๋ฆฌ๊ฐ ๊ตฌํ๊ณ ์ํ๋ ์ต์ ์ cluster ๊ฐ์
xxxxxxxxxx
# cluster๊ฐ์์ ๋ฐ๋ฅธ ๋ฐ์ดํฐ X์ SSE๊ฐ์ ๊ทธ๋ํ๋ก ๊ทธ๋ ค์ฃผ๋ ํจ์
def elbow(X) :
sse = []
for i in range(1,11) :
km = KMeans(n_clusters=i, init='k-means++', random_state=1234)
km.fit(X)
sse.append(km.inertia_) # km.inertia_ : kmeans ํด๋ฌ์คํฐ๋ง์ผ๋ก ๊ณ์ฐ๋ SSE๊ฐ
plt.plot(range(1,11),sse,marker='o')
plt.xlabel('cluster #n')
plt.ylabel('SSE')
plt.show()
๐ K=3์ผ๋๊ฐ ํ๊ฟ์น ๋ถ๋ถ! ์ต์ ์ cluster ๊ฐ์๋ 3
2. silhouette ์ค๋ฃจ์ฃ ๊ธฐ๋ฒ
- clustering์ ํ์ง์ ์ ๋์ ์ผ๋ก ๊ณ์ฐํด์ฃผ๋ ๋ฐฉ๋ฒ
- dunn index์ ๊ฒฝ์ฐ clustering์ ์ ํจ์ฑ์ ๊ฒ์ฆํ๊ธฐ ์ํ ํ๋์ ๊ฐ์ด ์๋๋ฐ, silhouette์ ๊ฒฝ์ฐ
๊ฐ์ฒด๋ณ(๋ฐ์ดํฐ๋ณ)๋ก ๊ทธ ์ ํฉ์ฑ์ด ํ๊ฐ๋จ
- ์ฆ, ๋ชจ๋ ๊ฐ์ฒด์ silhouette๊ฐ์ ํ์ธํ๊ณ , cluster๋ณ๋ก ๊ทธ ๊ฐ์ ๋ถํฌ์ ๋ฌธ์ ๊ฐ ์๋์ง ํ์ธํ๋ ๋ฐฉ์
โ๏ธ ๊ณต์ : i๋ฒ์งธ ๋ฐ์ดํฐ x(i)์ ๋ํ ์ค๋ฃจ์ฃ ๊ณ์ s(i)
- a(i) : ๊ตฐ์ง ๋ด ์์ง๋(cohesion), ๋ฐ์ดํฐ x(i)์ ๋์ผํ ๊ตฐ์ง ๋ด์ ๋๋จธ์ง ๋ฐ์ดํฐ๋ค๊ณผ์ ํ๊ท ๊ฑฐ๋ฆฌ
- ์์ ์๋ก ์์ง๋๊ฐ ๋๋ค --> ์ข์
- b(i) : ๊ตฐ์ง ๊ฐ ๋ถ๋ฆฌ๋(separation), ๋ฐ์ดํฐ x(i)์ ๊ฐ์ฅ ๊ฐ๊น์ด ๊ตฐ์ง ๋ด์ ๋ชจ๋ ๋ฐ์ดํฐ๋ค๊ณผ์ ํ๊ท ๊ฑฐ๋ฆฌ
- ํด์๋ก ์ข๋ค
๐ a(i)๋ ์์์๋ก, b(i)๋ ํด์๋ก ์ข์, ๋ฐ๋ผ์ s(i)๋ 1์ ๊ฐ๊น์ธ์๋ก ๊ตฐ์ง์ด ์ ์์ฑ๋์๋ค๋ ์๋ฏธ ↔๏ธ ๋ฐ๋๋ก ๊ตฐ์งํ๊ฐ ์ ์๋๋ฉด s(i)๊ฐ์ 0์ ๊ฐ๊น์
๐ ์ผ๋ฐ์ ์ผ๋ก ๋ชจ๋ ๊ฐ์ฒด์ silhoutte๊ฐ์ด 0.5๋ณด๋ค ํฌ๋ฉด clustering์ด ์ ๋์๋ค๊ณ ํ๊ฐ
sklearn silhouette score
- silhouette score์ ๊ฒฝ์ฐ ๊ฐ๋ณ ๊ฐ์ฒด์ ๋ํด์ ๊ฐ์ ๋์ถํ ์ ์์
- sklearn์ ๊ฐ sample์ ๋ํด์ ๊ณ์ฐํ ์์๊ฒ๋ํ๊ณ , ํ๊ท ๊ฐ์ ๋ด๋ ๊ฒ๋ ์ง์ํจ
xxxxxxxxxx
from sklearn.metrics import silhouette_samples, silhouette_score
sampels
- ํ๊ท ๋ง์ผ๋ก๋ ์จ๊ฒจ์ง๋ ๋ถ๋ถ๋ค์ด ์์ผ๋ฏ๋ก ๊ทธ ๋ถํฌ๋ฅผ ๋ณด๋ค ์ ํํ๊ฒ ๋ณด๋ ค๊ณ .
- ์ด๋ฅผ ์ํด์ ์ค์ ๋ฐใ ฃ
x
import numpy as np
from sklearn.metrics import silhoutte_samples
from matplotlib import cm
โ
def plot_silhouetter(X, cluster_labels) :
cluster_labels = np.unique()
xxxxxxxxxx
import numpy as np
import pandas as pd
import csv
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
โ
filename = "CSV_BIG.csv"
โ
# Read the CSV file with the Pandas lib.
path_dir = ".\\"
dataframe = pd.read_csv(path_dir + filename, encoding = "utf-8", sep = ';' ) # "ISO-8859-1")
df = dataframe.copy(deep=True)
โ
#Use silhouette score
range_n_clusters = list (range(2,10))
print ("Number of clusters from 2 to 9: \n", range_n_clusters)
โ
for n_clusters in range_n_clusters:
clusterer = KMeans (n_clusters=n_clusters).fit(?)
preds = clusterer.predict(?)
centers = clusterer.cluster_centers_
โ
score = silhouette_score (?, preds, metric='euclidean')
print ("For n_clusters = {}, silhouette score is {})".format(n_clusters, score)
xxxxxxxxxx
for n_clusters in range_n_clusters:
clusterer = KMeans(n_clusters=n_clusters)
preds = clusterer.fit_predict(df)
centers = clusterer.cluster_centers_
โ
score = silhouette_score(df, preds)
print("For n_clusters = {}, silhouette score is {})".format(n_clusters, score))
3. Dunn Index
- ํ์คํ๋ ๊ฐ์ด๋ผ๊ณ ํ ์๋ ์์(?)
- ๋ถ์ : ๊ตฐ์ง ๊ฐ ๊ฑฐ๋ฆฌ๋ค ์ค ์ต์๊ฐ
- ๋ถ๋ชจ : ๊ตฐ์ง ๋ด ๊ฐ์ฒด ๊ฐ ๊ฑฐ๋ฆฌ์ ์ต๋๊ฐ
- ๐ ๊ฐ์ด 1์ด์์ด๋ผ๋ฉด ๊ฐ์ฅ ์์ ๊ตฐ์ง ๊ฐ์ ๊ฑฐ๋ฆฌ๊ฐ ๊ตฐ์ง ๋ด์ ๊ฐ์ฅ ๋จผ ๊ฑฐ๋ฆฌ๋ณด๋ค ๊ธธ๋ค๊ณ ํ ์ ์์ --> ๊ตฐ์งํ๊ฐ ์ ๋์๋ค
- ๊ฑฐ๋ฆฌ ์ธก์ ๋ฐฉ์ --> Euclidean? Jaccard? ์ด๊ฑด ์ฐ๋ฆฌ๊ฐ ์ ํํด์ผํ ๋ฌธ์
reference
http://blog.naver.com/PostView.nhn?blogId=samsjang&logNo=221017639342&categoryNo=0&parentCategoryNo=0&viewDate=¤tPage=1&postListTopCurrentPage=1&from=postView : kmeans clustering ์ต์ ์ ํด๋ฌ์คํฐ ๊ฐ์ ์ฐพ๊ธฐ
https://frhyme.github.io/python-lib/clustering_evaluation/ : ํด๋ฌ์คํฐ๋ง์ ๋ค์ ๊ณต๋ถํด๋ด ์๋ค
1.
euclidean ๊ฑฐ๋ฆฌ ๊ณ์ฐ์ ๋จ์ด์ ์ถํ๋น๋๋ก ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๋จ์ด์ ๋น๋๊ฐ ๋์ด๋๋ฉด ๋ฒกํฐ์ ํฌ๊ธฐ๊ฐ ์ปค์ ธ ๊ฑฐ๋ฆฌ๊ฐ ๋ฉ์ด์ง. ๋ฐ๋ฉด์ cosine ์ ์ฌ๋๋ ๋ฒกํฐ์ ํฌ๊ธฐ(magnitude)๋ฅผ ๋ฌด์ํ๊ณ ๊ฐ๋๋ง ๋ณด๊ณ ์ธก์ ํ๋ฏ๋ก ์ด๋ฌํ ์ ์์ cosine ์ ์ฌ๋๋ฅผ ์ด์ฉํ๋ ๊ฒ์ด ๋ ์ข์
jaccard ์ ์ฌ๋ ๋ํ ์ค๋ณต์ ๋ฌด์ํ๊ธฐ ๋๋ฌธ์ ๋จ์ด์ ๋ฐ๋ณต์ ์ธ ๋ฐ์์ด ์๋ ๊ฒฝ์ฐ cosine ์ ์ฌ๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์
2.
clustering ํ์ง์ ์ ๋์ ์ผ๋ก ๋ถ์ํ ์ ์๋ ์งํ๋ก ์ค๋ฃจ์ฃ ๊ธฐ๋ฒ์ ์ฌ์ฉํ ์ ์๊ณ , ์ต์ ์ k๋ฅผ ์ฐพ๋๋ฐ์ ํ์ฉํ ์ ์์
ํ์ง๋ง ์ค๋ฃจ์ฃ ๊ธฐ๋ฒ์ ๋ชจ๋ ๊ฐ์ฒด๋ค๊ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ์์ด๊ธฐ์ ์ฐจ์์ด ํฐ matrix์ ๋ํด์ computation์ด ๊ต์ฅํ ํฌ๋ฉฐ, ๋ฐ์ดํฐ๊ฐ sparseํ ํน์ฑ์ ๊ฐ์ง ๊ฒฝ์ฐ ์ค๋ฃจ์ฃ ์ค์ฝ์ด๊ฐ ๋งค์ฐ ๋ฎ๊ฒ ์ธก์ ๋จ. k๊ฐ์๋ฅผ ์ฆ๊ฐ์ํฌ์๋ก ์ค๋ฃจ์ฃ ์ค์ฝ์ด๊ฐ ์ฆ๊ฐํ๊ธด ํ๋ ๊ทธ ์ฐจ์ด๊ฐ ๊ต์ฅํ ๋ฏธ๋ฏธํจ.
--> ์ฐจ์์ด ํฌ๊ณ sparseํ ๋ฐ์ดํฐ๋ก ํด๋ฌ์คํฐ๋งํ ๊ฒ์ ์ค๋ฃจ์ฃ ๊ธฐ๋ฒ์ ํตํด ์ ๋์ ์ผ๋ก ๋น๊ตํ๊ธฐ์ ํ๊ณ๊ฐ ์์
์ฐจ์์ถ์๋ฅผ ์ํ PCA, TSNE ๊ณผ์ ๋
'Computer Science > Data Science' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[CNN] CNN feature map๊ณผ filter ์๊ฐํ (0) | 2022.04.18 |
---|---|
[text mining] word embedding ์ด๊ฑฐ๋ฉด ๋! (0) | 2022.03.02 |
[Machine Learning] LightGBM์ด๋? โ ์ค๋ช ๋ฐ ์ฅ๋จ์ (0) | 2021.05.20 |
[Machine Learning] ๋จธ์ ๋ฌ๋, ๋ชจ๋ธ์ ํธํฅ(bias)๊ณผ ๋ถ์ฐ(variance) : trade-off ๊ด๊ณ (0) | 2021.05.12 |
Naive Bayes Classifier (0) | 2021.03.08 |
Decision Tree ๊ฐ.๋จ.๋ช .๋ฃ (0) | 2021.03.08 |
Random Forest ๊ฐ.๋จ.๋ช .๋ฃ (0) | 2021.03.08 |
๋จ์์ ํํ๊ท / ๋ค์ค์ ํํ๊ท ๊ฐ.๋จ.๋ช .๋ฃ (0) | 2021.03.07 |