Trí tuệ nhân tạo đã được khởi đầu như thế đó

Trí tuệ nhân tạo đã được khởi đầu như thế đó [Lịch sử ngành xử lý ngôn ngữ tự nhiên (1957-1970)]

Phần 2: Cuộc họp lịch sử mùa thu năm 1956 tại Pennsylvania - [Lịch sử ngành xử lý ngôn ngữ tự nhiên (1957-1970)]

Mùa hè năm 1956, 4 nhà ngôn ngữ học và khoa học máy tính hàng đầu (John McCarthy, Marvin Minsky, Claude Shannon) đã mời các nhà nghiên cứu khác tham gia một cuộc họp kéo dài 2 tháng. Và tại hội nghị này, các nhà nghiên cứu đã chính thức đặt tên mới cho lĩnh vực xử lý ngôn ngữ tự nhiên là: trí tuệ nhân tạo.

Vào tháng 06 năm 1958, một cuộc họp quan trọng khác đã diễn ra tại Đại học Pennsylvania. Tại đây, dự án Discourse Analysis Project (TDAP) đã được triển khai và các nhà khoa học quyết định mở rộng thêm một hướng nghiên cứu mới cho lĩnh vực trí tuệ nhân tạo. Và hướng này dựa trên các lý thuyết của Allen Newell, John McCarthy và Herbert A. Simon.

Lý thuyết Logic Theorist

Lý thuyết Logic Theorist là thuật toán được Newell và Simon phát triển từ năm 1956. Chương trình này được thiết kế để chứng minh các định lý logic của ngôn ngữ học và logic học.

Lý thuyết Logic Theorist sử dụng ngôn ngữ logic học và một bộ quy tắc biến đổi (đơn giản hóa vấn đề) để chứng minh, máy tính hoàn toàn có đủ trí tuệ để giải quyết các vấn đề phức tạp. Logic Theorist đã thành công trong việc chứng minh 38 trong số 52 định lý trong chương hai của cuốn sách Principia Mathematica (Bertrand Russell, Alfred North Whitehead).

Ví dụ chứng minh định lý Euclid về tính chia hết của các số nguyên tố, bài toán mà trước đó chỉ có con người có khả năng chứng minh. 

Dưới đây là một ví dụ bằng Java triển khai Lý thuyết Logic Theorist để chứng minh định lý sau:

A → B
B → C
A → C

Ví dụ này sử dụng một tập hợp quy tắc logic đơn giản để chứng minh định lý. Các quy tắc logic này bao gồm:

- Quy tắc modus ponens: Nếu A → B và A là đúng, thì B là đúng.
- Quy tắc modus tollens: Nếu A → B và B là sai, thì A là sai.

import java.util.ArrayList;
import java.util.List;

public class LogicTheorist {

    private static List<Rule> rules = new ArrayList<>();

    static {
        rules.add(new Rule("modus ponens", "A → B, A -> B"));
        rules.add(new Rule("modus tollens", "A → B, ¬B -> ¬A"));
    }

    public static boolean prove(List<String> premises, String conclusion) {
        List<String> goals = new ArrayList<>();
        goals.add(conclusion);

        // Duyệt qua các quy tắc logic
        while (!goals.isEmpty()) {
            String goal = goals.get(0);

            // Tìm kiếm các quy tắc logic có thể áp dụng cho goal
            List<Rule> applicableRules = getApplicableRules(goal);
            if (applicableRules.isEmpty()) {
                return false;
            }

            // Áp dụng quy tắc logic phù hợp nhất
            Rule rule = applicableRules.get(0);
            List<String> newPremises = new ArrayList<>();
            newPremises.addAll(premises);
            newPremises.addAll(rule.premises);

            // Thêm các tiền đề mới vào danh sách mục tiêu
            goals.removeAll(newPremises);
            goals.addAll(newPremises);
        }

        return true;
    }

    private static List<Rule> getApplicableRules(String goal) {
        List<Rule> applicableRules = new ArrayList<>();
        for (Rule rule : rules) {
            if (rule.conclusion.equals(goal)) {
                applicableRules.add(rule);
            }
        }
        return applicableRules;
    }

    public static void main(String[] args) {
        List<String> premises = new ArrayList<>();
        premises.add("A → B");
        premises.add("B → C");

        String conclusion = "A → C";

        if (prove(premises, conclusion)) {
            System.out.println("Định lý được chứng minh");
        } else {
            System.out.println("Định lý không được chứng minh");
        }
    }
}

class Rule {

    String conclusion;
    List<String> premises;

    public Rule(String conclusion, String... premises) {
        this.conclusion = conclusion;
        this.premises = new ArrayList<>();
        for (String premise : premises) {
            this.premises.add(premise);
        }
    }
}

Ví dụ này sẽ in ra kết quả sau: Định lý được chứng minh

Dự án General Problem Solver (GPS)

Dự án General Problem Solver (GPS) được Herbert A. Simon, Allen Newell và J.C. Shaw chủ trì phát triển trong giai đoạn từ những năm .1950 - 1960. 

GPS là một hệ thống trí tuệ nhân tạo đầu tiên được tạo ra để giải quyết các vấn đề tổng quát bằng cách sử dụng phương pháp giải quyết dựa trên quy tắc. Chẳng hạn như tìm đường đi từ điểm A đến điểm B, giải câu đố, lập kế hoạch, giải quyết các vấn đề kinh doanh.

GPS hoạt động dựa trên ý tưởng: Giả định rằng một vấn đề có thể được biểu diễn bằng một tập hạn chế các toán tử hoặc quy tắc biến đổi. Hệ thống này có khả năng tạo ra các phương án giải quyết các các vấn đề phức tạp bằng cách sử dụng quy tắc biến đổi và thử nghiệm một loạt các phương án để tìm ra giải pháp tốt nhất.

GPS đã đánh dấu sự phát triển của mô hình giải quyết vấn đề dựa trên quy tắc và đã cung cấp nền tảng cho việc phát triển các hệ thống thông minh sau này. Nó đã thể hiện rằng, máy tính có thể tự động giải quyết nhiều loại vấn đề, không chỉ giới hạn trong lĩnh vực logic mà còn trong nhiều lĩnh vực khác.

Dưới đây là một ví dụ bằng Java sử dụng thuật toán General Problem Solver để giải câu đố đơn giản sau:

Bạn đang đứng ở vị trí A, muốn đến vị trí B. Có hai đường, một đường đi qua vị trí C, một đường đi thẳng đến B. Bạn không biết đường nào dẫn đến B. Hãy tìm đường đi từ A đến B.

Ví dụ này sử dụng một tập hợp quy tắc chuyển đổi đơn giản để giải câu đố. Các quy tắc chuyển đổi này bao gồm:

- Quy tắc đi theo một đường: Nếu bạn đang ở vị trí A, và có một đường đi đến vị trí B, thì bạn có thể đi theo đường đó để đến vị trí B.
- Quy tắc đi theo một đường qua một vị trí: Nếu bạn đang ở vị trí A, và có một đường đi đến vị trí C, thì bạn có thể đi theo đường đó đến vị trí C, và sau đó đi theo đường từ C đến B.

import java.util.ArrayList;
import java.util.List;

public class GeneralProblemSolver {

    private static List<Rule> rules = new ArrayList<>();

    static {
        rules.add(new Rule("go-along-a-path", "A, A → B -> B"));
        rules.add(new Rule("go-along-a-path-through-a-position", "A, A → C, C → B -> B"));
    }

    public static List<List<String>> solve(List<String> initialState, List<String> goalState) {
        List<List<String>> solutions = new ArrayList<>();

        // Khởi tạo một trạng thái hiện tại bằng trạng thái ban đầu
        List<String> currentState = new ArrayList<>();
        currentState.addAll(initialState);

        // Duyệt qua các quy tắc chuyển đổi
        while (!currentState.equals(goalState)) {
            // Tìm kiếm các quy tắc chuyển đổi có thể áp dụng cho trạng thái hiện tại
            List<Rule> applicableRules = getApplicableRules(currentState);
            if (applicableRules.isEmpty()) {
                return null;
            }

            // Áp dụng quy tắc chuyển đổi phù hợp nhất
            Rule rule = applicableRules.get(0);
            List<String> newState = new ArrayList<>();
            newState.addAll(currentState);
            newState.addAll(rule.premises);

            // Thêm trạng thái mới vào danh sách các giải pháp
            solutions.add(newState);

            // Cập nhật trạng thái hiện tại thành trạng thái mới
            currentState = newState;
        }

        return solutions;
    }

    private static List<Rule> getApplicableRules(List<String> currentState) {
        List<Rule> applicableRules = new ArrayList<>();
        for (Rule rule : rules) {
            if (rule.conclusion.equals(currentState.get(currentState.size() - 1))) {
                applicableRules.add(rule);
            }
        }
        return applicableRules;
    }

    public static void main(String[] args) {
        List<String> initialState = new ArrayList<>();
        initialState.add("A");

        List<String> goalState = new ArrayList<>();
        goalState.add("B");

        List<List<String>> solutions = solve(initialState, goalState);

        if (solutions != null) {
            for (List<String> solution : solutions) {
                System.out.println(solution);
            }
        } else {
            System.out.println("Không có giải pháp");
        }
    }
}

class Rule {

    String conclusion;
    List<String> premises;

    public Rule(String conclusion, String... premises) {
        this.conclusion = conclusion;
        this.premises = new ArrayList<>();
        for (String premise : premises) {
            this.premises.add(premise);
        }
    }
}

Và kết quả hiển thị là:

[A, A → C]
[A, A → C, C → B]