[Farm System🪴] 인공지능 스터디 4주차(피동적 알고리즘)

🙌서론

이번 주차 스터디는 간단히 요약해서 말하면 저번주차까지 배운 파이썬과 넘파이를 알고리즘을 통해 복습해본다는 느낌이 강합니다. 실제로 교재에서도 무언갈 새로이 배우기 보다는 숫자야구라는 예시를 통해 파이썬, 넘파이를 활용해 알고리즘을 짜보는 느낌이 강합니다.
그래서 저도 이번 주차 스터디는 이때까지 배운 파이썬과 간단한 넘파이를 복습하고 총정리 한다는 느낌으로 학습해보았습니다.

참고로 제목이 피동적 알고리즘인 이유는 교재의 필자가 다음과 같이 적어놨다.
필자가 고안한 해법에 따라서만 답을 찾아간다는 점에서 이 장의 제목은 피동적 알고리즘이라 하였다.

🧢숫자 야구

교재에선 이번 주차 내용 통채로 숫자야구라는 것을 파이썬, 넘파이를 이용해 작성하고 설명하는 내용으로만 이루어져 있습니다.

숫자야구란?

'숫자야구'라고 그냥 들으면 무엇인지 감이 안오실 수도 있는데 규칙을 들으면 아? 하고 생각나실 수 있을 겁니다. 아마 다들 한번씩 해봤을 겁니다(저도 기억속에서 초딩때 해본게 떠오르네요..ㅎㅎ).

각자 3/4자리의 숫자를 임의로 정한 뒤, 서로에게 3/4자리의 숫자를 불러서 결과를 확인한다. 
그리고 그 결과를 토대로 상대가 적은 숫자를 예상한 뒤 맞힌다.
사용되는 숫자는 0에서 9까지 서로 다른 숫자이다. 
경우에 따라 0은 사용하지 않기도 하며 0이 첫번째 숫자로 올 수 없게하는 룰도 있다.

1. 숫자는 맞지만 위치가 틀렸을 때는 BALL.

2. 숫자와 위치가 전부 맞으면 STRIKE.
(물론 무엇이 BALL이고 STRIKE인지는 알려주지 않는다.)

3. 숫자와 위치가 전부 틀리면 OUT. 

- 두 숫자가 중복되면 경우의 수가 많아져서 그런지 중복 숫자는 잘 사용하지 않는다.

저희가 학습할 코드는 정답 숫자를 3자리로 하고 0은 포함하지 않은 1~9까지 숫자로 합니다. 또한 숫자 중복도 없다고 하겠습니다.

또한 코드를 짜기전 사용할 패키지는 다음과 같습니다.
import numpy as np

응답자 코드

우선 컴퓨터가 응답자 역할을 하는 코드를 작성해 보겠습니다.
(응답자라 함은 컴퓨터가 숫자 3개를 정하고 문제를 만들었다 생각하면 됩니다. 즉 컴퓨터가 스트라이크가 몇개인지, 볼이 몇개인지 등을 알려줍니다.)

rsp_nums = [i for i in range(1, 10)]
rsp_nums = np.random.choice(rsp_nums, size = 3, replace = False)

우선 위 코드는 컴퓨터 응답자가 사용할 숫자를 무작위적으로 생성하는 코드입니다.

1부터 9까지의 정수 아홉개가 포함된 리스트 rsp_nums를 생성한 다음, np.random.choice를 사용해서 rsp_nums에 포함된 숫자 중에서 세개의 숫자를 중복이 없도록 무작위적으로 선택하도록 한 후 반환되는 배열 객체에 rsp_nums를 다시 붙여 만들었습니다.

다음 아래 코드는 rsp_nums배열과 해결자(문제를 해결할 사람)가 추측한 세 개의 숫자가 담긴 guess 리스트를 입력받고 응답하는 함수입니다.

def get_response_from_guess(rsp_nums, guess):
	n_stk = 0
    n_bll = 0
    for i in range(3):
    	if guess[i] == rsp_nums[i]:
        	n_stk += 1
        elif guess[i] in rsp_nums:
        	n_bll += 1
        else:
        	pass
    respose = (n_stk, n_bll)
    return response

n_stk와 n_bll은 각각 스트라이크와 볼의 개수이고 rsp_nums와 guess를 각각 if문을 통해 비교해가며 스트라이크와 볼의 개수를 증가시켜 반환하면 됩니다.

위의 코드들을 바탕으로 응답자 클래스를 구현해 보겠습니다.

class Responder():
	
    def __init__(self):
    	self.rsp_nums = np.random.choice(
        [i for i in range(1, 10), size = 3, replace = False)
    
    def get_response_from_guess(rsp_nums, guess):
		n_stk = 0
    	n_bll = 0
    	
        for i in range(3):
    		if guess[i] == rsp_nums[i]:
        		n_stk += 1
       	 	elif guess[i] in rsp_nums:
       	 		n_bll += 1
        	else:
        		pass
    	
        respose = (n_stk, n_bll)
    	
        return response

마지막으로 입력을 받아 guess를 생성하는 코드를 만들어보겠습니다.

while True:
	guess = input("Guess:")
    if len(guess) == 3 and len(set(guess))==3:
    	break
guess = [int(item) for item in guess]

눈 여겨 볼 구간은 len(set(guess)) == 3 이부분입니다. 저희는 중복숫자를 받지 않기로 하였기에 set을 이용한 것입니다.
(집합은 중복숫자를 count하지 않기 때문이죠)

이렇게 응답자 코드를 짜보았습니다.

해결자 코드

해결자는 응답자와 반대로 문제를 맞추는 경우라고 보면 됩니다. 즉 guess를 입력하고 결과로 알게되는 (num_str, num_bll)을 통해 답을 추론하는 알고리즘이죠.
일종의 탐색 알고리즘이며 결과를 8개로 구분이 가능하므로 브루타포스 알고리즘이라 보셔도 됩니다.

나올 수 있는 경우는 3S0B, 0S3B, 1S2B, 1S0B, 0S1B, 2S0B, 1S1B, 0S2B 입니다.
(S는 스트라이크 개수, B은 볼의 개수 입니다.)

해결자 코드는 아래와 같이 작성 가능합니다.

numbers = [i for i in range(1, 10)]

while True:
	init_guess = np.random.choice(nubers, size = 3, replace = False)
    
    nubers.remove(init_guess[0])
    nubers.remove(init_guess[1])
    nubers.remove(init_guess[2])
    
    pirnt("guess:", "".join([str(n) for n in init_guess]))
    
    #human input
    n_stk = int(input("n strikes:"))
    n_bll = int(input("n balls :"))
    response = (n_stk, n_bll)
    
    if response == (3, 0) or reponse != (0, 0):
    	break
    
    if response == (0, 3):
    	guesser = Guesser_0S3B(init_guess)
    
    if response == (1, 2):
    	guesser = Guesser_0S3B(init_guess)
    
    if response == (1, 0):
    	guesser = Guesser_0S3B(init_guess)
    
    if response == (0, 1):
    	guesser = Guesser_0S3B(init_guess)
	
    if response == (2, 0):
    	guesser = Guesser_0S3B(init_guess)
	
    if response == (1, 1):
    	guesser = Guesser_0S3B(init_guess)
	
    if response == (0, 2):
    	guesser = Guesser_0S3B(init_guess)

1부터 9까지의 숫자중 3개를 골라 guess로 정하고 원래 1부터 9까지가 있는 number에서 guess로 고른 것들을 삭제합니다.

그 후 경우에 따라 나눠서 클래스를 실행시킵니다. 만약 (3, 0)인 경우 정답을 맞춘 것이기에 추측을 하지 않고 break를 통해 그만둡니다. (0, 0)인 경우 남은 number 중 다시 guess를 생성하여 탐색합니다.

위 예시를 통해 해결자 클래스를 작성 가능합니다. 코드가 거의 같고 길이가 길기에 코드는 생략하겠습니다.

추측기 클래스

추측기 클래스는 위 해결자 코드에서 guesser로 받는 클래스들이라 보시면 됩니다.
즉, 경우에 따라 추측기 클래스를 다르게 하여 정답 숫자를 추측을 하게 됩니다.

(3, 0)과 (0, 0)은 이 추측기 클래스가 필요 없으므로 이것들을 제외한 7개의 추측기 클래스가 있는데 전부 방법은 같기 때문에 2가지 경우만 코드를 통해 확인하겠습니다.

Guesser_0S3B 클래스

추측한 숫자가 abc라 하면 이 a, b, c 세개의 숫자 모두 정답 숫자이지만 자리만 전부 틀린 경우입니다. 즉 최대 다섯번의 시도로 정답을 찾을 수 있습니다.

코드는 다음과 같습니다.

class Guesser_0S3B():
	
    def __init__(self, init_guess):
    	self.init_guess = init_guess
        self.branch_id = 1
    
    def make_guess(self, response = None):
    	[a,b,c] = [self.init_guess[0],self.init_guess[1],self.init_guess[2])
        
        if self.branch_id == 1: next_guess = [a,c,b]
        if self.branch_id == 2: next_guess = [b,a,c]
        if self.branch_id == 3: next_guess = [c,a,b]
        if self.branch_id == 4: next_guess = [b,c,a]
        if self.branch_id == 5: next_guess = [c,b,a]
        
        self.branch_id += 1
        
        return next_guess

acb, bac, cab, bca, cba 순으로 최대 다섯번의 시도로 정답을 찾을 수 있다.
branch_id로 추측과정을 기억하도록 하였다.

Guesser_2S0B 클래스

두 개의 숫자가 정답 숫자이며 자리까지 맞는 경우입니다.

	abx	axc	xbc
abc	2S0B	2S0B	2S0B
acb	1S1B	1S1B	0S2B
bac
cab
bca
cba	1S1B	0S2B

위 표와 같이 경우가 나올 수 있는데 표를 해석하자면 위 첫째 줄은 ab, ac, bc가 정답 숫자일 경우를 뜻합니다. 그리고 왼쪽 경우들이 자리를 바꿨을 경우이고요.

즉 처음에 b와 c의 자리를 바꿨는데 0S2B가 되면 b와 c가 정답숫자입니다. 그 외에는 a, b 혹은 a, c이고요. 그후 cba순으로 guess로 하여 1S1B인 경우 a와 b가, 0S2B인 경우 a와 c가 정답 숫자입니다.

이걸 토대로 아래처럼 코드를 작성할 수 있습니다.

class Guesser_2S0B():
	def __init__(self, numbers, init_guess):
    	self.numbers = numbers
        self.init_guess = init_guess
        self.branch_id = 1
    
    def make_guess(self, response=None):
    	[a,b,c] = [self.init_guess[0],self.init_guess[1],slef.init_guess[2]]
        
        if self.branch_id == 1:
        	next_guess[a,c,b]
            self.branch_id = 2
            return next_guess
        
        if self.branch_id == 2 and response == (0,2):
        	self.branch_id = "xbc"
        
        if self.branch_id == 2 and response == (1,1):
        	 next_guess = [c,b,a]
             self.branch_id = 21
             return next_guess
         
         #--------------------------------------------
         
         if self.branch_id == 21 and response == (1,1):
         	self.branch_id == "abx"
         
         if self.branch_id == 21 and response == (0,2):
         	self.branch_id == "axc"
      	 
         #--------------------------------------------
         
         if self.branch_id == "xbc":
         	x = self.numbers.pop()
            next_guess = [x,b,c]
            return next_guess
            
        if self.branch_id == "abx":
         	x = self.numbers.pop()
            next_guess = [a,b,x]
            return next_guess
            
        if self.branch_id == "axc":
         	x = self.numbers.pop()
            next_guess = [a,x,c]
            return next_guess

위 두 경우를 제외하고도 이와 같이 코드를 작성하면 됩니다.

🌈색 조합 맞추기 게임

위 예시와 비슷하게 색 조합 맞추기 게임 코드를 작성할 수도 있습니다.

import numpy as np
from itertools import permutations

# 색상 후보
COLORS = ["red", "blue", "green", "yellow", "purple", "orange"]

# 사용자 입력
def get_secret_color_combination():
 while True:
     user_input = input(f"비밀 색 조합 3개를 입력하세요 (예: red blue green): ").split()
     if len(user_input) == 3 and len(set(user_input)) == 3 
     and all(c in COLORS for c in user_input):
         return user_input
     print("입력이 잘못되었습니다. 가능한 색상:", COLORS)

# 피드백 함수
def get_feedback(guess, answer):
 exact = sum([g == a for g, a in zip(guess, answer)])
 partial = sum([(g in answer) and (g != answer[i]) for i, g in enumerate(guess)])
 return exact, partial

# 추측 클래스
class ColorGuesser:
 def __init__(self):
     self.candidates = list(permutations(COLORS, 3))
     self.prev_guess = None
     self.first_guess_done = False

 def make_guess(self, feedback=None):
     if not self.first_guess_done:
         # 첫 추측은 np.random.choice로 무작위로 뽑기
         self.prev_guess = list(np.random.choice(COLORS, size=3, replace=False))
         self.first_guess_done = True
         return self.prev_guess
     else:
         # 이전 피드백과 일치하는 후보만 남기고 무작위 선택
         self.candidates = [
             c for c in self.candidates
             if get_feedback(list(c), self.prev_guess) == feedback
         ]
         if not self.candidates:
             raise ValueError("후보가 없습니다. 입력이 잘못되었을 수 있습니다.")
         idx = np.random.choice(len(self.candidates))
         self.prev_guess = list(self.candidates[idx])
         return self.prev_guess

# 게임 실행
def play_color_game():
 print("색 조합 추측 게임 - 컴퓨터가 맞춥니다!")
 secret = get_secret_color_combination()
 guesser = ColorGuesser()

 attempts = 0
 feedback = None

 while True:
     guess = guesser.make_guess(feedback)
     attempts += 1
     print(f"[{attempts}] 컴퓨터 추측: {guess}")

     feedback = get_feedback(guess, secret)
     print(f" → 정확: {feedback[0]}개, 색만 맞음: {feedback[1]}개")

     if feedback[0] == 3:
         print(f"\n 컴퓨터가 {attempts}번 만에 비밀 색 조합을 맞췄습니다!")
         break

# 실행
if __name__ == "__main__":
 play_color_game()

😊마무리

이때까지 배운 python과 numpy의 np.random을 이용하여 숫자야구 코드를 작성 가능하였습니다.
또한 비슷한 예제인 색 조합 맞추기 게임 또한 코드로 작성하였습니다.
(색 조합 맞추기 게임은 교재에 없는 예제)
사실 여기서 numpy는 거의 안 쓰였기에 사실상 python으로 알고리즘 공부를 하였다고 봐도 될 듯 합니다.

지금까지 교재를 4장까지 하였습니다. 스터디를 1주차당 한 장씩 나가고 있으므로 당연하긴 합니다.

다음에 공부할 5장은 상태와 행동이라는 단원입니다. 6장과 7장은 각각 미니맥스와 몬테카를로 트리 탐색법에 대해 학습을 할 것인데 5장은 이에 기초가 되는 상태와 행동에 따른 상태의 변화를 알려줄 상태 클래스에 대해 학습할 것 같습니다.

이제부터 인공지능의 학습에 관한 알고리즘을 자세히 학습하게 될 것 같습니다. 내용도 점점 어려워 질것 같으니 열심히 해보아야 겠습니다. 요즘 날씨가 더워지고 있는데 이 글을 보시는 분들 모두 시원한 여름 되셨으면 좋겠습니다!

번외로 메타몽 귀엽지 않나요? 메타몽은 사랑입니다💜