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?