์ ์๋๊ธฐ
์ฒญ๊ฐ์ฅ์ ์ธ์ ์ํ ์ธ๊ณต์ง๋ฅ
์ธ๊ณต์ง๋ฅ ๊ธฐ์ ์ด ๊ธ์๋๋ก ๋ฐ์ ํ๊ณ ์๋ ํ์ฌ, ์ด๋ฅผ ํ์ฉํ์ฌ ์ผ์์ํ์ ๋ถํธ์ ๋๋ผ๋ ์ฅ์ ์ธ ๋ถ๋ค์ ์ํ ์ ํ์ ๋ง๋ค์ด ๋ณด๊ณ ์ถ์๋ค. ๊ทธ ์ค ์ฒญ๊ฐ์ฅ์ ์ธ์ ์ํ ์ํ์ธ์ ํ๋ก๊ทธ๋จ์ ๋ง๋ค๋ฉด ์ข๊ฒ ๋ค๊ณ ์๊ฐํ๊ฒ ๋์๋ค.
MediaPipe ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ์์ joint๋ฅผ ๊ฒ์ถํ๋ค.
๊ทธ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ๋จ์ผ ๋์์ผ๋ก ๋ถ๋ฅ ํ ์ ์๋ KNN(K-Nearest Neighbor)๊ณผ ์ฐ์ ๋์์ ๋ถ๋ฅ ํ ์ ์๋ RNN(Recurrent Neural Network)์ ์ ๋ ฅ์ผ๋ก ํ์ตํ์ฌ ์งํ๋ฅผ ์ค์๊ฐ์ผ๋ก ์ธ์ํ๊ณ ์ถ๋ ฅํ๋ค.
์ด๋ก ์ ๋ฐฐ๊ฒฝ
MediaPipe
MediaPipe๋ ๊ตฌ๊ธ์์ ์ ๊ณตํ๋ AI ํ๋ ์์ํฌ๋ก์จ, ๋น๋์ค ํ์ ๋ฐ์ดํฐ๋ฅผ ์ด์ฉํ ๋ค์ํ ๋น์ AI๊ธฐ๋ฅ์ ํ์ดํ๋ผ์ธ ํํ๋ก ์์ฝ๊ฒ ์ฌ์ฉํ ์ ์๋๋ก ์ ๊ณต๋๋ค.
AI ๋ชจ๋ธ ๊ฐ๋ฐ ๋ฐ ์๋ง์ ๋ฐ์ดํฐ์ ์ ์ด์ฉํ ํ์ต๋ ๋ง์น ์ฌํ๋ก ์ ๊ณต๋๋ฏ๋ก ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ถ๋ฌ ์ฌ์ฉํ๋ฏ์ด ๊ฐํธํ๊ฒ ํธ์ถํ์ฌ ์ฌ์ฉํ๊ธฐ๋ง ํ๋ฉด ๋๋ ํํ๋ก, ๋น์ AI ๊ธฐ๋ฅ์ ๊ฐ๋ฐ ํ ์ ์๋ค.
๋ค์๊ณผ ๊ฐ์ด ์์ ์ธ์ํ์ฌ ์ค๋ค.
์ด๋ ๋นจ๊ฐ์ ์ผ๋ก ํ์๋ ๋ง๋(joint)๋ฅผ ์ฌ์ฉํ์ฌ ๋ฒกํฐ๋ฅผ ๋ง๋ค๊ณ ,
๊ทธ ๋ฒกํฐ๋ค ์ฌ์ด์ ๊ฐ๋๋ฅผ ์ด์ฉํด์ ์ ๋ชจ์์ ํ์ต์ํฌ ์ ์๋ค.
KNN(K-Nearest Neighbor)
knn์ ์ต๊ทผ์ ์ด์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ง๋ํ์ต ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋์ด๋ค.
- ์ง๋ํ์ต : ์ฌ๋ฌ ๋ฌธ์ ์ ๋ต์ ๊ฐ์ด ํ์ตํจ์ผ๋ก์จ ๋ฏธ์ง์ ๋ฌธ์ ์ ๋ํ ์ฌ๋ฐ๋ฅธ ๋ต์ ์์ธกํ๊ณ ์ ํ๋ ๋ฐฉ๋ฒ์ด๋ค. ๋ฐ๋ผ์ ์ง๋ํ์ต์๋ ๋ฌธ์ ์ ํจ๊ป ๊ทธ ์ ๋ต๊น์ง ์๊ณ ์๋ ๋ฐ์ดํฐ๊ฐ ์ ๊ณต๋์ด์ผ ํ๋ค.
- ๋น์ง๋ํ์ต : ์ง๋ํ์ต๊ณผ๋ ๋ฌ๋ฆฌ ์ ๋ต ๋ผ๋ฒจ์ด ์๋ ๋ฐ์ดํฐ๋ฅผ ๋น์ทํ ํน์ง๋ผ๋ฆฌ ๊ตฐ์งํ ํ์ฌ ์๋ก์ด ๋ฐ์ดํฐ์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ์์ธกํ๋ ๋ฐฉ๋ฒ์ด๋ค.
์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ ๋ฐ์์๋, ํด๋น ๋ฐ์ดํฐ์ ๊ฐ์ฅ ๊ฐ๊น์ด์ ์๋ k๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํ์ธํด, ์๋ก์ด ๋ฐ์ดํฐ์ ํน์ฑ์ ํ์ ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ ๊ทธ๋ฆผ์์ '?'์ ์ฃผ๋ณ์ ๊ฐ์ฅ ๊ฐ๊น๊ณ ๋ง์ด ์๋๊ฒ์ด ๋ฌด์์ธ๊ฐ ๋ฅผ ํ์ธํ์ฌ '?'๊ฐ ์ผ๊ฐํ์ธ์ง ์์ธ์ง ํ๋ณํ๋ ๊ฒ์ด๋ค.
- K๊ฐ 1์ผ๊ฒฝ์ฐ '?'์ฃผ๋ณ์๋ ๊ฐ์ฅ ๊ฐ๊น๊ณ ๋ง์ด ์๋๊ฒ์ ์ ํ๋์ด๋ฏ๋ก '?'๋ ์์ผ๋ก ํ๋ณํ๋ค.
- K๊ฐ 4์ผ ๊ฒฝ์ฐ '?'์ฃผ๋ณ์ ๊ฐ์ฅ๊ฐ๊น๊ณ ๋ง์ด ์๋๊ฒ์ ์ผ๊ฐํ์ด๋ฏ๋ก '?'๋ ์ผ๊ฐํ์ผ๋ก ํ๋ณํ๋ค.
๊ทธ๋ฌ๋ฉด K๋ ๋ช์ผ๋ก ์ค์ ํ๋๊ฒ ๊ฐ์ฅ ์ข์๊น?
- k๊ฐ ๋ฎ๋ค → ์ ์ ์ด์ ์๋ก ํ๋จํ๋ค → ๋ถ์์ ํ ๊ฒฐ๊ณผ
- k๊ฐ ๋๋ค → ๋ง์ ์ด์ ์๋ก ํ๋จํ๋ค → ์ง๋์น ์ผ๋ฐํ
- ๊ฐ์ฅ ์ข์ ์ฑ๋ฅ์ ๋ด๋ k๋ฅผ ์ ํ
- k์ ๊ฐ์ 1๋ถํฐ ์ฆ๊ฐ์์ผ๊ฐ๋ฉฐ ๊ฐ ์ ๋ค์ ๋ํด knn์ผ๋ก ๋ถ๋ฅํด๋ณด๊ณ ์ค๋ฅ ๊ณ์ฐ
- ๊ฐ์ฅ ์ค๋ฅ๊ฐ ์ ์ k๊ฐ์ ์ ํ
RNN
RNN์ ์์ฑ, ๋ฌธ์์ ๊ฐ์ด ์์ฐจ์ ์ผ๋ก ์งํํ๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ์ ์ ํฉํ ์๊ณ ๋ฆฌ์ฆ ์ด๋ค.
๊ทธ๋ฆผ๊ณผ ๊ฐ์ด hidden layer์ ๊ฒฐ๊ณผ๊ฐ ๋ค์ hidden layer์ ์ ๋ ฅ์ผ๋ก ๋ค์ด๊ฐ๋ ์ํ๋๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ก๊ธฐ ๋๋ฌธ์ ์ฌ๊ท ์ธ๊ณต ์ ๊ฒฝ๋ง์ด๋ผ๊ณ ๋ถ๋ฆฐ๋ค.
hidden layer์ ๊ฒฐ๊ณผ๊ฐ ๋ค์ hidden layer์ ์ ๋ ฅ์ผ๋ก ๋ค์ด๊ฐ๋ ํน์ฑ ๋๋ฌธ์ RNN์ ํ์ฌ ๋ค์ด์ค๋ ์ ๋ ฅ ๋ฐ์ดํฐ์ ์ ๋จ๊ณ์์ ๋์จ ๊ฒฐ๊ณผ๋ฅผ ๋์์ ๊ณ ๋ คํ๊ฒ ๋จ์ผ๋ก์จ ๊ธฐ์ต ๋ฅ๋ ฅ์ด ์๋ค๊ณ ํ ์ ์๊ฒ ๋๊ณ , sequence ๋๋ ์๊ณ์ด ๋ฐ์ดํฐ๋ฅผ ๋ถ์ํ๋๋ฐ ๊ต์ฅ์ด ํจ๊ณผ์ ์ธ ๋คํธ์ํฌ์ด๋ค.
๊ตฌํ ๊ณผ์
1. media pipe๊ฐ ์ ๊ณตํด ์ฃผ๋ ์์ joint๋ฅผ ํ์ฉํ์ฌ ๋ฒกํฐ์ฌ์ด์ ๊ฐ๋๋ฅผ ๊ตฌํ๋ค.
1๏ธโฃ ์ ๊ณผ ์ ์ฌ์ด์ ๋บ์ ์ฐ์ฐ์ ํตํด 0๋ฒ์์ 1๋ฒ์ผ๋ก ๊ฐ๋ ๋ฒกํฐ, 1๋ฒ์์ 2๋ฒ์ผ๋ก ๊ฐ๋ ๋ฒกํฐ ๋ฑ๋ฑ ๋ง์ ๋ฒกํฐ๋ฅผ ๋ง๋ค์ด๋ธ๋ค.
if result.multi_hand_landmarks:
for hand_landmarks in result.multi_hand_landmarks: # ์ฌ๋ฌ๊ฐ์ ์์ ์ธ์ ํ ์ ์์ผ๋๊น, for๋ฌธ ๋ฐ๋ณต
joint = np.zeros((21,4)) # ์ ๊ด์ (joint) ๋ํ์ด ๋ฐฐ์ด๋ก ์์ฑ
for j, lm in enumerate(hand_landmarks.landmark): # media pipe์ landmark๋ฅผ ๋ฐ๋ณตํ๋ฉฐ joint์ ๋์
joint[j] = [lm.x,lm.y,lm.z,lm.visibility]
v1 = joint[[0,1,2,3,0,5,6,7,0, 9,10,11, 0,13,14,15, 0,17,18,19],:3] # ๋ฒกํฐ๋ฅผ ๊ตฌํ๊ธฐ ์ํด ์์ฑํ๋ v1,v2 (v2์์ v2์ ๋นผ๋ฉด v๋ฐฑํฐ๊ฐ ๋๋ค)
v2 = joint[[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20],:3]
v = v2-v1
v = v / np.linalg.norm(v,axis=1)[:,np.newaxis] # ์ ๊ทํ
2๏ธโฃ ๋ง๋ค์ด์ง ๋ฒกํฐ๋ค ์ฌ์ด์ ๊ฐ๋๋ฅผ ๊ตฌํ๋ค
compareV1 = v[[0,1,2,4,5,6,8,9,10,12,13,14,16,17,18],:] #๊ฐ ๋ฒกํฐ์ ๊ฐ๋๋ฅผ ๋น๊ตํ๊ธฐ ์ํด ์์ฑํ๋ compare๋ฒกํฐ
compareV2 = v[[1,2,3,5,6,7,9,10,11,13,14,15,17,18,19],:]
angle = np.arccos(np.einsum('nt,nt->n',compareV1,compareV2)) # compare๋ฒกํฐ๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ๋๋ฅผ ๊ตฌํจ
angle = np.degrees(angle)
3๏ธโฃ ์ ๋ชจ์์ ๋ฐ๋ฅธ ๋ฐ์ดํฐ์ ํ์ผ์ writeํ๋ค
if keyboard.is_pressed('a'): # gesture๋ฅผ ํ์ตํ๊ธฐ ์ํ ์กฐ๊ฑด๋ฌธ(aํค๋ฅผ ๋๋ฅด๊ณ ์์ผ๋ฉด ๊ฐ๋์ ๋ผ๋ฒจ์ด test.txt์ write๋จ)
for num in angle:
num = round(num,6)
f.write(str(num))
f.write(',')
f.write("25.000000") # ํ์ตํ๊ณ ์ ํ๋ ์ ๋์์ ๋ผ๋ฒจ
f.write('\n')
print('next')
๋ฐ์ดํฐ ์
์ ๊ตฌํ๋ ์ฝ๋์ด๋ค. ํค๋ณด๋ 'a'ํค๋ฅผ ๋๋ฅด๊ณ ์์ผ๋ฉด test.txtํ์ผ์ ํ์ฌ ๊ฐ๋์ ์ ๋์์ ๋ผ๋ฒจ์ด write๋๋ค.
์ด๋ ๊ฒ ์ ๋์ ํ๋ํ๋์ ๋ํด์ ๊ตฌํ ์ ๋ณด๋ฅผ dataSet.txtํ์ผ์ ๋ถ์ฌ๋ฃ์ด ๋ฐ์ดํฐ์ ์ ์์ฑํ์๋ค.
2-1. ๊ตฌํด์ง ๊ฐ๋์ KNN ์ ์ฌ์ฉํ์ฌ ์ ์ ์ธ ์๋์์ ํ์ต์ํจ๋ค.
data = np.array([angle],dtype=np.float32)
ret, results, neighbours, dist = knn.findNearest(data,3) #knn์๊ณ ๋ฆฌ์ฆ ์ ์ฉ
๊ตฌํ angle์ numpy ํํ ๋ฐ์ดํฐ๋ก ๋ง๋ค๊ณ , ๊ทธ ๋ฐ์ดํฐ์ knn์ ์ฌ์ฉํ์ฌ ํ์ต์ํค๋ ์ฝ๋์ด๋ค.
์ํ๊ฒฐ๊ณผ
๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์๋์์ ๋ฐ๋ฅธ ์์์ด ์ ์ถ๋ ฅ๋์๋ค.
2-2. 'done'๋์์ ์ทจํ๋ฉด ์ ๋ ฅํ ์ด์ฑ์ผ๋ก ์์ํ๋ ๋จ์ด๋ชฉ๋ก์ ์ถ๋ ฅํ์ฌ ์ค๋ค
gesture = {
0:'ใฑ',1:'ใด',2:'ใท',3:'ใน',4:'ใ
',5:'ใ
',6:'ใ
',7:'ใ
',
8:'ใ
',9:'ใ
',10:'ใ
',11:'ใ
',12:'ใ
',13:'ใ
', 25:'done',26:'spacing',27:'clear'
}
complete = 0 # ๊ธ์จ ์
๋ ฅ์ ์๋ฃ ํ๋์ง ํ์ธํ๋ ๋ณ์(done ๋์์ ํ๋ฉด 1๋ก ๋ฐ๊ฟ)
.
.
.
if index == 25: # done๋์(25์์์ ์ฝ์ dic_file์์ sentce๊ฒ์ํ๊ณ , ๊ทธ ์์น์ ๋จ์ด๋ฅผ ์ถ๋ ฅ
for i in range(0, dic_file.[0]):
if (sentence == dic['์ด์ฑ'][i]):
selected_words.append(dic_file['๋จ์ด'][i])
complete=1 #complete ๋ฅผ ์ํด 1๋ก ๋ณ๊ฒฝํ๋ค
i=0
word=''
elif complete==0 and index!=27index!=26:
sentence += gesture[index]
startTime = time.time()
if complete==0:
word = gesture[index]
draw.text((int(hand_landmarks.landmar x*image.shape[1]),int(hand_landm landmark[0].y*image.shape[0])), word, font=font, fill=(255,255,255))
draw.text((20,400),sentence,font=font,fill=(255,255,255))
if complete==1:
print(sentence)
print(selected_words)
.
.
.
25๋ฒ ๋์, ์ฆ done์ ํ๋ฉด dic์์ ์
๋ ฅํ ์ด์ฑ์ ๊ฒ์ํ๊ณ , selected_words
์ append
ํ๋ค.
๊ทธ ๋ค์ ์ผ์ข
์ flag๋ณ์
์ญํ ์ ํ๋ complete๋ฅผ 1๋ก ๋ณ๊ฒฝ์ํจ๋ค.
(์ด๋ ๊ฒ ํ๋ ์ด์ ๋ done๋์์ ํ์ ๊ฒฝ์ฐ ๋ถ๊ธฐ์ ์ ๋ง๋ค์ด ๋ค๋ฅธ ์กฐ๊ฑด๋ฌธ์ด ์คํ๋๋๋ก ํ๊ธฐ ์ํจ์ด๋ค.)
3.RNN์ LSTM์ ์ฌ์ฉํ์ฌ ๋์ ์ธ ์๋์(next, prev)์ ํ์ต
3-1.window๋ฅผ ์์ฑ
RNN์ LSTM์ ์ฌ์ฉํ์ฌ ๋์ ์ธ ๋์์ ํ์ต์ํค๋ ๊ณผ์ ๋ ๋ฒกํฐ์ฌ์ด์ ๊ฐ๋๋ฅผ ์ด์ฉํ๋ค. ํ์ง๋ง window๋ผ๋ ๊ฒ์ ๋ง๋ค์ด์ผ ํ๋๋ฐ ์ด๊ฒ์ LSTM์ ๊ธฐ๋ณธ ๊ฐ๋
์ธ ์ต๊ทผ ~๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ ๋ค์ ๋ฐ์ดํฐ๋ฅผ ์์ธกํ๊ธฐ
์ํด์์ด๋ค.
seq_length = 30
seq_length=30, ์ฆ window ์ฌ์ด์ฆ๋ฅผ 30์ผ๋ก ์ค์ ํ์๋ค.
(์ต๊ทผ 30๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ณด๊ณ ๋ค์ ๋ฐ์ดํฐ๋ฅผ ์์ธกํ๊ฒ ๋๋ค)
์ฌ์ง์ถ์ฒ : ๋นตํ์ ๊ฐ๋ฐ๋์๊ตญ ์ ํ๋ธ
์ ๊ทธ๋ฆผ์์ ๋ณด๋๊ฒ ์ฒ๋ผ ๋นจ๊ฐ์ window๋ฅผ ๋ง๋ค๊ณ ๊ทธ ๋ค์ ํ์นธ์ฉ ๋ด๋ ค๊ฐ๋ฉด์ window๋ฅผ ๊ณ์ ๋ง๋ ๋ค. (๋ ธ๋์ window๋ฅผ๋ง๋ค๊ณ , ์ด๋ก์ window ...)
full_seq_data = []
for seq in range(len(data) - seq_length):
full_seq_data.append(data[seq:seq + seq_length])
full_seq_data = np.array(full_seq_data)
np.save(os.path.join('dataset', f'seq_{action}_{created_time}'), full_seq_data)
๊ทธ ๋ค์ for๋ฌธ์ ๋๋ฉด์ full_seq_data๋ผ๋ ๋ฆฌ์คํธ์ 30๊ฐ์ ํ ์คํ ์ฉ ๋์ด๊ฐ๋ฉด์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ์ฌ sequence dataSetํ์ผ์ ๋ง๋ ๋ค.
3-2.dataSetํ์ผ์ ์ฌ์ฉํ์ฌ train
actions = [
'prev',
'next',
'stop'
]
data = np.concatenate([
np.load('dataset/seq_prev_1653293844.npy'),
np.load('dataset/seq_next_1653293844.npy'),
np.load('dataset/seq_stop_1653293844.npy'),
], axis=0)
์ก์ ์ 3๊ฐ๋ก ์ ์ํด์ฃผ๊ณ , ์์์ ๋ง๋ dataSet์ ์ ๋ถ load ํ ํ๋๋ก ํฉ์ณ์ค๋ค.
x_data = data[:, :, :-1]
labels = data[:, 0, -1]
๋ผ๋ฒจ๊ณผ ๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฆฌํ์ฌ ์ค๋ค.
๊ทธ ๋ค์ ๋ผ๋ฒจ์ Categorical data๋ก ๋ง๋ค์ด ์ฃผ๊ธฐ ์ํด One-Hot Encoding์ ํด์ผ ํ๋ค.
One-Hot Encoding์ด๋ ์ฌ๋์ด ์ดํดํ๋ ๋ฐ์ดํฐ๋ฅผ ์ปดํจํฐ์๊ฒ ์ฃผ์ ์ํค๊ธฐ ์ํ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ์ด๋ผ๊ณ ํ ์ ์๋ค.
๋ฐ์ดํฐ๋ฅผ ์ ๋ง์ 0๊ณผ ํ ๊ฐ์ 1 ๊ฐ์ผ๋ก ๊ตฌ๋ถํ๋ค. ์๋ฅผ๋ค์ด ์ซ์ 0๋ถํฐ 9๊น์ง ๊ตฌ๋ถํ๋ ค ํ๋ค๋ฉด[1,0,0,0...0]
[0,1,0,0...0]
[0,0,1,0...0]
...
[0,0,0,0...1]
์ด๋ ๊ฒ ์ธ์ฝ๋ฉํ๋ ๊ฒ์ด๋ค.
from tensorflow.keras.utils import to_categorical
y_data = to_categorical(labels, num_classes=len(actions))
print(y_data.shape)
tensorflow keras์ to_categorical์ ์ฌ์ฉํ์ฌ One-Hot Encoding์ ์ ์ฉํ์๋ค.
from sklearn.model_selection import train_test_split
x_data = x_data.astype(np.float32)
y_data = y_data.astype(np.float32)
x_train, x_val, y_train, y_val = train_test_split(x_data, y_data, test_size=0.1, random_state=2021)
sklearn์ train_test_split์ ์ฌ์ฉํด์ training set๊ณผ test set์ผ๋ก ๋๋ ์ค๋ค. training set์ 90%, test set์ 10% ๋ก ๋๋ ์ค๋ค.
training set(ํ์ต ๋ฐ์ดํฐ์ ) : ๋ชจ๋ธ์ ํ์ต์ ์ํด ์ฌ์ฉ๋๋ ๋ฐ์ดํฐ์ด๋ค.
test set(ํ ์คํธ ๋ฐ์ดํฐ์ ) : ์์ฑ๋ ๋ชจ๋ธ์ ์์ธก์ฑ๋ฅ์ ํ๊ฐํ๋๋ฐ ์ฌ์ฉ๋๋ค.
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
model = Sequential([
LSTM(64, activation='relu', input_shape=x_train.shape[1:3]),
Dense(32, activation='relu'),
Dense(len(actions), activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc'])
model.summary()
๋ชจ๋ธ์ ์ ์ํ๋ ์ฝ๋์ด๋ค.
Sequential API๋ฅผ ์ฌ์ฉํ์ฌ LSTM๊ณผ DENSE ๋๊ฐ๋ฅผ ์ฐ๊ฒฐํ์ฌ ์ค๋ค. LSTM์ ๋
ธ๋ ๊ฐฏ์๋ 64๊ฐ activation ์ relu๋ฅผ ์ฌ์ฉ, Dense์ ๋
ธ๋ ๊ฐฏ์๋ 32๊ฐ activation์ relu๋ฅผ ์ฌ์ฉํ๋ค. ๊ทธ๋ฆฌ๊ณ activation์ softmax๋ฅผ ์ฌ์ฉํ๋ค.
loss๋ categorical_crossentropy๋ฅผ ์ฌ์ฉํ์ฌ 3๊ฐ์ ๋์ ์ค ์ด๋ค๊ฒ์ธ๊ฐ๋ฅผ modelํํ ์ถ๋ก ํ๊ฒ ํ๋ค.
history = model.fit(
x_train,
y_train,
validation_data=(x_val, y_val),
epochs=200,
callbacks=[
ModelCheckpoint('models/model.h5', monitor='val_acc', verbose=1, save_best_only=True, mode='auto'),
ReduceLROnPlateau(monitor='val_acc', factor=0.5, patience=50, verbose=1, mode='auto')
]
)
์ต์ข ์ ์ผ๋ก ํ์ต์ ์ํค๋ ๊ณผ์ ์ด๋ค.
์์๋
์ํ๊ฒฐ๊ณผ
์ฐธ์กฐ
์ ํ๋ธ '๋นตํ์ ๊ฐ๋ฐ๋์๊ตญ'
๐
๋นตํ์ ๊ฐ๋ฐ๋์๊ตญ
ํ๊ณ
์์์ ์ฌ์ฉํ์ฌ ๋์ ์ธ ๋์์ด ๋ง์ ์ํ๋ฅผ ํ์ต์ํค๋ ๊ฒ์ ์ด๋ ค์์ ๋๊ปด, ์ํ์ ํ ์ข ๋ฅ์ธ ์งํ๋ฅผ ๊ตฌํํ์๋ค. ๊ทธ๋ฆฌ๊ณ ์งํ๋ฅผ ํตํด ํ์ ๋ ๋จ์ด๋ฅผ ๋ฒ์ญํ๋๊ฒ์ ๊ทธ์ณค๋ค.
๊ฐ์ ํ๊ณ ์ถ์์
๋ชจ์์ ์งํ๋ฅผ ์ถ๊ฐํ์ฌ, ์์๊ณผ ๋ชจ์์ ์กฐํฉํ ์ ์๋ ๊ธฐ๋ฅ์ ๋ง๋ค๋ฉด ์ง๊ธ๋ณด๋ค๋ ๋ ์์ฑ๋ ์๋ ํ๋ก๊ทธ๋จ์ด ๋ ๊ฒ ๊ฐ๋ค.
๋๋์
ํ์ด์ฌ์ด ์ํด์๊ณ , ๋ฅ๋ฌ๋๋ ์ฒ์์ด์๋ค. ๊ฝค ์ค๋๊ธฐ๊ฐ ๋์ ๊ตฌ๊ธ ์ ํ๋ธ ๋ฑ์ ์ฐพ์๋ณด๋ฉฐ ์ด๋ป๊ฒ๋ ํด๋ด๊ณ ์ ํ์๋ค. ํ๋ก์ ํธ๋ฅผ ์งํํ๋ฉฐ ๋๋ต์ ์ธ ๋ฅ๋ฌ๋์ ๊ฐ๋ ์ ์ ์ ์์๋ค. ์๋ฒฝํ์ง ์์ง๋ง ๋ฅ๋ฌ๋์ ์ฌ์ฉํด๋ดค๋ค๋ ์ ๊ณผ ๊ฒฐ๊ณผ๋ฌผ์ ๋ง๋ค์ด ๋๋ค๋ ์ ์ ์์๋ฅผ ๋๊ณ ์ถ๋ค.๐
[์ ์ฒด์ฝ๋ : ์บก์คํค๊ฒฝ์ง๋ํ ์์ฐ์ ์ํด gui๋ฅผ ์ถ๊ฐํ ์ฝ๋]
'๐ํ๋ก์ ํธ:Project' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
TAB(Take a Bus) (0) | 2023.08.31 |
---|---|
forURtravel (0) | 2023.06.20 |
ํผ์ค๋์ปฌ๋ฌ ์ง๋จ ํ๋ก์ ํธ (0) | 2023.05.03 |