2 Wed
TIL
ํ๋ก๊ทธ๋๋จธ์ค AI ์ค์ฟจ 1๊ธฐ
1์ฃผ์ฐจ DAY 2
์ค๋ ์์ DAY 2์ DAY 3๋ฅผ ๋๋ด๊ฒ ๋ค ๋ค์งํ๊ฑด๋ง, DAY 2๋ฅผ ๋ค ํ์ง ๋ชปํ๋ค. 12์๊น์ง ํด์ผ ์ถ์์ ๋ฐ์๋๋ค๊ณ ํ๋๋ฐ ํฐ์ผ๋ ๊ฒ ๊ฐ๋ค. ์์ ์ ๋๊ฒจ์๋ผ๋ ์ผ๋ฅธ ํด์ผ๊ฒ ๋ค.



DAY 1 ์์๋ ๋๋ฌด ๊ธฐ์ด์ ์ธ ๊ฒ ์๋๊ฐ ์ถ์๋๋ฐ, DAY 2๋ ์ข ๋ ์ ์ตํ๋ค.(ํน์, ๋ด ์์ค์ ์ฌ๊ธฐ์ ๋ถํฐ์ธ ๊ฑธ๊น?) ์ค์ํํ์ ํ์ํํ ๋ถํฐ ์ฝ์ง ์์๋ ๊ฒ ๊ฐ๋ค. ํ์คํ ์ฒ์ ๋ฐฐ์ธ ๋๋ ๊ทธ๋ฌ์ง๋ง, ์ดํด ํ๋ ๊ฒ๊ณผ ๊ตฌํํ๋ ๊ฒ์ ์ ๋ง ๋ค๋ฅธ ๊ฒ ๊ฐ๋ค. ์ด๋ด ๊ธฐํ๊ฐ ์ค์ ๋ํ ๊ฐ์ ์ด์ธ์๋ ์์๋๋ฐ, ์ด๋ ๊ฒ ๋ค์ ๊ตฌํํด๋ณด๋๊น ํฐ ๋ณต์ต์ด ๋๋ ๊ฒ ๊ฐ๋ค. ์๊ฐ๋ณด๋ค ์ด๋ ค์์ ์ค์ต ํ๋ ํ๊ธฐ๊ฐ ์ฝ์ง ์๋ค. ๋คํํ๋ ๋ชจ๋ ์๋ฃ๊ตฌ์กฐ์ ๋์ ๋ฐฉ์์ ๊ฐ๋จํ๊ฒ๋ผ๋ ์๊ณ ์์ด์ ํก์๋ ๋ฐ๋ก๋ฐ๋ก ํ๋ค. ๋ช ๊ฐ ๋๋ฆ ์ค์ํ๋ค๊ณ ์๊ฐํ ๋ด
์ฐ์ ์์ ํ๋ ์ญ์ ํ ๋๋ง๋ค ํด๋น ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ๊ฒ๋ณด๋ค ์ฝ์ ํ ๋๋ง๋ค ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๋ ๊ฒ์ด ๋ ๋น ๋ฅด๋ค.
์ฐ์ ์์ ํ๋ ์ ํ ๋ฐฐ์ด๋ก ๊ตฌํํ ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ์์, ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ๊ตฌํํ ๊ฒฝ์ฐ ์๋์์ ๊ฐ์ ์ ์ป๋๋ค.
1์ฃผ์ฐจ DAY 3

dictionary์ ์ด๊ธฐํ์ ๋ํด์ d.setdefault(x, 0)๋ง ์๊ณ ์์๋๋ฐ, d.get(x, 0)์ ๋ฌธ๋ฒ์ ์๊ฒ ๋์๋ค. ๋์ ์ฐจ์ด์ ์ ์ข ๋ ์์ธํ ์์๋ณด๊ธฐ ์ํด ๋ค์ ๋งํฌ ์ฐธ
get๋ณด๋ค setdefault์ ์๋๊ฐ 10% ๋ ๋น ๋ฅด๋ค. ๋ค๋ง, setdefault๋ unset๋ dictionary์ ๋ํด์ ์ด๊ธฐํ๋ฅผ ํ๋ ๊ฒ์ด๊ณ get์ unset์ ๊ตฌ๋ถ์ง์ง ์๊ณ reset์ ํ ์ ์๋ค๋ ํน์ง์ด ์๋ค.
์ ๋ฐ์ ์ผ๋ก ์ ๋ฃ ๊ฐ์์ ๋ํด ๋๋ ์ ์, ์ด๋ป๊ฒ ํ์ด์ผ ํ ์ง๋ฅผ ์ ์ค๋ช ํ๊ณ ๋ฌธ์ ํ์ด๋ฅผ ์์ํ๋ ๊ฐ์๋ผ๊ณ ์๊ฐํ๋ค. ์ค์ ํ๋ก๊ทธ๋๋จธ์ค์์ ๋ฌธ์ ๋ฅผ ํ๋ฉด ๋ค๋ฅธ ์ฌ๋์ ์ฝ๋๋ฅผ ํ์ธํ ์ ์๋๋ฐ, ํ์ด ๋ฐฉ๋ฒ์ด ์ถ์ฒ์ ๋ง์ด ๋ฐ์ ํ์ด์ ๋๋ถ๋ถ ์กด์ฌํ๋ค. ๊ทธ ์ฌ๋๋ค์ด ์ ๋ฃ๊ฐ์๋ฅผ ๋ณด๊ณ ํ์ ๊ฒ์ธ์ง, ์ด ์ฌ๋๋ค์ ํ์ด๋ฅผ ๋ณด๊ณ ์ ๋ฃ๊ฐ์ ์ ์์ ์ฐธ๊ณ ํ ๊ฒ์ธ์ง๋ ๋ชจ๋ฅด๊ฒ ๋ค.(์๋ง ํ์๊ฐ ์๋๊น). ๋ค๋ง ์๋ ค์ค ํ์ด ๋ฐฉ๋ฒ๋ณด๋ค ๋ ์ข์ ๋ฐฉ๋ฒ๋ ๋ช ๊ฐ ์์ผ๋ ๊ฐ์๋ฅผ ๋ณด๋ ์ฌ๋๋ค์ ๋ ๊ฐ์ ํ ์ ์ ์๊ฐํด๋ณด๋ฉด ์ข์ ๊ฒ ๊ฐ๋ค.
๋, AI ์ค์ฟจ 1์ฃผ์ฐจ์ ๋ํด ๋๋ ์ ์ ์ด๋ฏธ CS ์ง์์ ๋ํด ์ด๋ ์ ๋ ์๊ณ ์์ผ๋ฉด ๋ณต์ต์ด ๋๊ณ ๋ณด์ถฉ์ด ๋ ๊ฒ ๊ฐ๋ค. ๊ทธ๋ฌ๋ ์ต๊ทผ์ ํ๋ก๊ทธ๋๋จธ์ค์ ์ฌ๋ฌ ๋ฌธ์ ๋ฅผ ํ์ดํ๋ ์ฌ๋๋ค์ ๋ฌธ์ ํ์ด์ ๋ํด์๋ ์ข ์๊ฐ ์ฑ์ฐ๊ธฐ ๋๋์ด ๋ค ๊ฒ ๊ฐ๋ค. (๋ด๊ฐ ํ์์ ๋๋์ด๋ผ...) ํผ๋๋ฐฑ์ด ์๋ค๋ฉด, ์์ง AI๋ฅผ ๋ฐฐ์ฐ๊ธฐ ์ ์ด์ง๋ง ์ด๋ฌํ ๋ฌธ๋ฒ์ ์ด๋ค ๊ฒ์ ๋ฐฐ์ฐ๋ ๋ฐ ํ์ํ๋ค ๊ฐ์ ์ ์ฉ ๋ถ์ผ๋ฅผ ์ธ๊ธํ๊ฑฐ๋ ๊ฐ๋จํ AI ์ง์์ ์ ์ฉํ๋ฉด์ ์ด๋ ๊ฒ ์ฌ์ฉํ ์ ์๋ค ๋ผ๋ ๋ฐฉ์์ผ๋ก ๋ฐฐ์ฐ๋ฉด ์ข ๋ ํฅ๋ฏธ๋ก์ธ ๊ฒ ๊ฐ๋ค.
์คํ ๋งํ์ ์ปดํ์ผ๋ฌ
์ค์ ํ๋ณ ํ ํฐ ๋ถ์
์๊ฐ ์ค์ธ ๊ฐ์์ ์ค์๋ฅผ ํ๋ณํ๋ ์คํ ๋งํ์ DFA๋ฅผ ๊ทธ๋ฆฌ๊ณ ์ค์ ๋ก ํ๋ก๊ทธ๋๋ฐ ํ๋ ๊ณผ์ ๊ฐ ๋์๋ค. ์ ๊ท์์ผ๋ก ๋น ๋ฐฉ ํ๋๊น 5์ค๋ง์ ๋๋ฌ๋๋ฐ, ํ ํฐ์ ๋ถ์ํ๋ ๋๋์ด ์๋์ด์(๋ฌผ๋ก ์ ๊ท์ ๋ด๋ถ์์๋ ํ ํฐ์ผ๋ก ๋ถ์ํ๊ฒ ์ง๋ง ๋ด๊ฐ ํ ํฐ๋ง๋ค ๋ถ์ํ ๊ฑด ์๋๋๊น) ์ฌ๋ฌ ๋ถ๊ธฐ์ ์ ๋ง๋ค์๋ค.

#
# data : 2020.12.02
# author : sangmandu at Dankook Univ.
# program : automata that analyze token by token and distinguish type of input is float or not
#
#
# prerequisite : the number could not be calculated by other operators or operand
# although there are many operators and operand and result of calculation number is regarded as certain type,
# here's token analyzer regards input as calculated number completely
# ex) -11-3.e-3 is float but token analyzer says this is no float as duplicate of '-'
#
# Test cases
X = ['+5-5', '5*5*5', '5-5-5', '1...5', '1.2.3', '1.5e15', '000.5', '0000.', '000100.5', '3.5', '2', '4.', '-5.3E+2', '36', '-52', '-13.E+3', '54.123E-2',
'0', '0.0', '-0', '-0.0', '.35', '+++++3.5', '-----3.5','11.e+++3', '11.e---3', '11.e-3-', 'abc', '+35a', '-35b', '+35.5a', '123a.123', '23.12c', '11.232e++']
Y = [False, False, False, False, False, True, True, True, True, True, False, True, True, False, False, True, True,
False, True, False, True, True, True, True, False, False, False, False, False, False, False, False, False, False]
P = []
#
# Float Regular Expression
# Re : [+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?
#
# 0 : [+-] 1 : [0-9] 4 : [Ee] 5 : (Ee)[0-0]
# 2 : (exist)[.](free num) 3 : (none)[.](essential num)
#
# () : able to skipped, -- : essential, == : optional
# order one : (0) -- 1 -- 2 == 4 -- (0) -- 5
# order two : (0) -- 3 == 4 -- (0) -- 5
#
def floatOrNot(x):
idxRe = 0
for idx, token in enumerate(x):
if token in ['+', '-']: # sign check
if idxRe == 0:
continue
elif idxRe == 4:
idxRe = 5
continue
else:
return (False, f"unproper location of {token}")
if token in '0123456789': # number check
if idxRe == 0:
idxRe = 1
continue
elif idxRe in [1, 2, 3, 5]:
continue
elif idxRe == 4:
idxRe = 5
continue
if token == '.': # dot check
if idxRe == 0:
idxRe = 3
continue
elif idxRe == 1:
idxRe = 2
continue
else:
return (False, "Alreay being dot")
if token in ['e', 'E']: # exponential notation check
if idxRe in [2, 3]:
idxRe = 4
continue
else:
return (False, "No dot or No num")
return (False, f"Not number {token}") # no matching
return (True, ) if idxRe > 1 else (False, "Int") # float must have dot
#
# function floatOrNot return only True value as tuple type when input is float.
# but when input is not float then return False value and why False
#
X = list(map(str, X))
P = sum([[floatOrNot(x)] for x in X], [])
correct = [y == p[0] for y, p in zip(Y, P)]
accuracy = correct.count(True) / len(correct)
print(
f"\nPerformance is {accuracy*100}%\n\nuncorrect result(case, label) is", end=''
)
if int(accuracy*100) == 100:
print(" None.\n")
print("[Result]")
for i in range(len(P)):
print("%10s"%str(X[i])+"%10s"%str(P[i][0])+"\t"+(str(P[i][1]) if P[i][0] != True else ''))
else:
print()
for i in range(len(correct)):
if correct[i] != True:
print(f"{[(X[i], Y[i], P[i]) ]}")
๋ฑ 100์ค ์ฝ๋(์ฃผ์์ด ์ข ๋ง๊ธด ํ์ง๋ง ํํ..) ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๊น๋ํ๊ฒ ํ๋ค. ์ ๊ฒฐํ ๋ฏ ์ถ๋ค.
Last updated
Was this helpful?