ИИ Сапера — проблема с каким-то крайним случаем вывода знаний о безопасной ячейке

Я прохожу курс CS50 «Введение в искусственный интеллект с помощью Python», и мне он очень нравится. Когда я запускаю свой сценарий, кажется, что все работает хорошо, но программа проверки CS50 обнаруживает какой-то крайний случай, когда мое программное обеспечение, очевидно, не находит безопасную ячейку при выводе знаний. Вот спецификация CS50, ориентированная на ту часть, которая не прошла тест:

Спецификация

Завершите реализацию класса Sentence и класса MinesweeperAI в minesweeper.py.

• В классе Sentence выполните реализации known_mines, known_safes, mark_mine и mark_safe.

• Функция known_mines должна возвращать набор всех ячеек в self.cells, которые, как известно, являются шахтами.

• Функция known_safes должна возвращать набор всех ячеек в self.cells, о которых известно, что они безопасны.

• Функция mark_mine должна сначала проверить, является ли cell одной из ячеек, включенных в предложение.

  • Если cell находится в предложении, функция должна обновить предложение так, чтобы cell больше не было в предложении, но по-прежнему представляло логически правильное предложение, учитывая, что cell известно как мое.

  • Если cell нет в предложении, никаких действий не требуется.

• Функция mark_safe должна сначала проверить, является ли cell одной из ячеек, включенных в предложение.

  • Если cell находится в предложении, функция должна обновить предложение так, чтобы cell больше не было в предложении, но по-прежнему представляло логически правильное предложение, учитывая, что cell известно как безопасное.

  • Если cell нет в предложении, никаких действий не требуется.

В классе MinesweeperAI выполните реализации add_knowledge, make_safe_move и make_random_move.

• add_knowledge должен принять cell (представленный в виде кортежа (i, j)) и соответствующий ему count и обновить self.mines, self.safes, self.moves_made и self.knowledge любой новой информацией, которую может вывести ИИ, учитывая, что cell известно как безопасная ячейка с count минами соседний с ним.

  • Функция должна пометить cell как один из ходов, сделанных в игре.

  • Функция должна пометить cell как безопасную ячейку, а также обновить все предложения, содержащие cell.

  • Функция должна добавить новое предложение в базу знаний ИИ на основе значений cell и count, чтобы указать, что count из соседей cell — мои. Обязательно включите в предложение только те ячейки, состояние которых еще не определено.

  • Если на основании любого из предложений в self.knowledge новые ячейки можно пометить как безопасные или минные, то функция должна это сделать.

  • Если на основе любого из предложений в self.knowledge можно вывести новые предложения (используя метод подмножества, описанный в разделе «История вопроса»), то эти предложения также следует добавить в базу знаний.

  • Обратите внимание: каждый раз, когда вы вносите какие-либо изменения в знания вашего ИИ, возможно, можно будет сделать новые выводы, которые раньше были невозможны. Убедитесь, что эти новые выводы добавлены в базу знаний, если это возможно.

Вот мой код (большая часть задачи выполнена, так что если не хотите его испортить, не продолжайте):

import itertools
import random
import copy

"""
- cut code related to setting up a board of 8x8 cells with 8 mines spread around randomly in them.
"""


class Sentence:
    """
    Logical statement about a Minesweeper game
    A sentence consists of a set of board cells,
    and a count of the number of those cells which are mines.
    """

    def __init__(self, cells, count):
        self.cells = set(cells)
        self.count = count

    def __eq__(self, other):
        return self.cells == other.cells and self.count == other.count

    def __str__(self):
        return f"{self.cells} = {self.count}"

    def known_mines(self):
        """
        Returns the set of all cells in self.cells known to be mines.
        """
        if len(self.cells) == self.count != 0:
            return self.cells
        else:
            return set()

    def known_safes(self):
        """
        Returns the set of all cells in self.cells known to be safe.
        """
        if self.count == 0:
            return self.cells
        else:
            return set()

    def mark_mine(self, cell):
        """
        Updates internal knowledge representation given the fact that
        a cell is known to be a mine.
        """
        if cell in self.cells:
            self.cells.remove(cell)
            self.count -= 1
            return True
        return False

    def mark_safe(self, cell):
        """
        Updates internal knowledge representation given the fact that
        a cell is known to be safe.
        """
        if cell in self.cells:
            self.cells.remove(cell)
            return True
        return False


class MinesweeperAI:
    """
    Minesweeper game player
    """

    def __init__(self, height=8, width=8):

        # Set initial height and width
        self.height = height
        self.width = width

        # Keep track of which cells have been clicked on
        self.moves_made = set()

        # Keep track of cells known to be safe or mines
        self.mines = set()
        self.safes = set()

        # List of sentences about the game known to be true
        self.knowledge = []

    def mark_mine(self, cell):
        """
        Marks a cell as a mine, and updates all knowledge
        to mark that cell as a mine as well.
        """
        self.mines.add(cell)
        for sentence in self.knowledge:
            sentence.mark_mine(cell)

    def mark_safe(self, cell):
        """
        Marks a cell as safe, and updates all knowledge
        to mark that cell as safe as well.
        """
        self.safes.add(cell)
        for sentence in self.knowledge:
            sentence.mark_safe(cell)

    def nearby_cells(self, cell):
        """
        Returns set of cells around the given cell.
        """
        # Keep count of nearby mines
        cells = set()

        # Loop over all cells within one row and column
        for i in range(cell[0] - 1, cell[0] + 2):
            for j in range(cell[1] - 1, cell[1] + 2):

                # Ignore the cell itself
                if (i, j) == cell:
                    continue

                # Add cell to set if cell in bounds
                if 0 <= i < self.height and 0 <= j < self.width:
                    cells.add((i, j))

        return cells

    def add_sentence(self, cells, count):
        # Create new sentence based on the nearby cells and known mines and safe cells.
        newSentence = Sentence(cells, count)
        self.knowledge.append(newSentence)

        # Check new sentence for discoveries.
        for cell in copy.deepcopy(newSentence.known_safes()):
            if cell not in self.safes:
                self.mark_safe(cell)
        for cell in copy.deepcopy(newSentence.known_mines()):
            if cell not in self.mines:
                self.mark_mine(cell)

        # Remove empty sentences:
        for sentence in self.knowledge:
            if len(sentence.cells) == 0:
                self.knowledge.remove(sentence)

        # Add mines and safes from inferred sentences:
        for sentence in self.knowledge:
            if len(sentence.cells) == sentence.count:
                for cell in copy.deepcopy(sentence.cells):
                    self.mark_mine(cell)
                self.knowledge.remove(sentence)
                continue
            if sentence.count == 0:
                for cell in copy.deepcopy(sentence.cells):
                    self.mark_safe(cell)
                self.knowledge.remove(sentence)
                continue

        # Remove same sentences
        updatedKnowledge = []
        for sentence in self.knowledge:
            if sentence not in updatedKnowledge:
                updatedKnowledge.append(sentence)
        self.knowledge = updatedKnowledge

        # Infer knowledge based on new sentence
        if len(self.knowledge) > 1:
            for sentence in self.knowledge:
                if sentence != newSentence:
                    if sentence.cells.issubset(newSentence.cells):
                        inferredSet = Sentence(
                            newSentence.cells - sentence.cells,
                            newSentence.count - sentence.count,
                        )
                        if inferredSet not in self.knowledge:
                            self.add_sentence(
                                newSentence.cells - sentence.cells,
                                newSentence.count - sentence.count,
                            )
                    if newSentence.cells.issubset(sentence.cells):
                        inferredSet2 = Sentence(
                            sentence.cells - newSentence.cells,
                            sentence.count - newSentence.count,
                        )
                        if inferredSet2 not in self.knowledge:
                            self.add_sentence(
                                sentence.cells - newSentence.cells,
                                sentence.count - newSentence.count,
                            )

    def add_knowledge(self, cell, count):
        """
        Called when the Minesweeper board tells us, for a given
        safe cell, how many neighboring cells have mines in them.

        This function should:
            1) mark the cell as a move that has been made
            2) mark the cell as safe
            3) add a new sentence to the AI's knowledge base
               based on the value of `cell` and `count`
            4) mark any additional cells as safe or as mines
               if it can be concluded based on the AI's knowledge base
            5) add any new sentences to the AI's knowledge base
               if they can be inferred from existing knowledge
        """
        # Mark cell as the move made
        self.moves_made.add(cell)

        # Mark cell as safe
        self.mark_safe(cell)

        # Get nearby cells and substract known mines and safe cells
        NearbyCells = self.nearby_cells(cell)
        validNearbyCells = copy.deepcopy(NearbyCells)
        for cell in NearbyCells:
            if cell in self.safes:
                validNearbyCells.discard(cell)
            if cell in self.mines:
                validNearbyCells.discard(cell)
                count -= 1

        # Add new sentence and infer knowledge based on added sentence
        self.add_sentence(validNearbyCells, count)

После того, как я запустил свой скрипт через функцию проверки CS50, это вывод:

:) minesweeper.py exists
:) minesweeper.py imports
:) Sentence.known_mines returns mines when conclusions possible
:) Sentence.known_mines returns no mines when no conclusion possible
:) Sentence.known_safes returns mines when conclusion possible
:) Sentence.known_safes returns no mines when no conclusion possible
:) Sentence.mark_mine marks mine when cell in sentence
:) Sentence.mark_mine does not mark mine when cell not in sentence
:) Sentence.mark_safe marks safe when cell in sentence
:) Sentence.mark_safe does not mark safe when cell not in sentence
:) MinesweeperAI.add_knowledge marks cell as a move made
:) MinesweeperAI.add_knowledge marks cell as safe
:) MinesweeperAI.add_knowledge adds sentence in middle of board
:) MinesweeperAI.add_knowledge adds sentence in corner of board
:) MinesweeperAI.add_knowledge ignores known mines when adding new sentence
:) MinesweeperAI.add_knowledge ignores known safes when adding new sentence
:) MinesweeperAI.add_knowledge infers additional safe cells
:) MinesweeperAI.add_knowledge can infer mine when given new information
:) MinesweeperAI.add_knowledge can infer multiple mines when given new information
:( MinesweeperAI.add_knowledge can infer safe cells when given new information
did not find (0, 0) in safe cells when possible to conclude safe
:) MinesweeperAI.add_knowledge combines multiple sentences to draw conclusions

Помощь!

Я уже все перепробовал, чат GPT ничуть не помог, я попробовал pytest с test_minesweeper.py для модульного тестирования моего кода, и все казалось нормально! Во всех ситуациях, которые я добавляю к своим знаниям, код работает хорошо.