《人工智能导论》第 7 章 专家系统与机器学习

class ExpertSystem:
    def __init__(self):
        # 知识库：使用字典存储规则，键为症状，值为可能的疾病
        self.knowledge_base = {
            "咳嗽": ["感冒", "支气管炎"],
            "打喷嚏": ["感冒", "过敏"],
            "食欲不振": ["消化不良", "肠胃炎"],
            "发热": ["感染", "炎症"],
            "呼吸困难": ["肺炎", "哮喘"],
            "腹泻": ["肠胃炎", "食物中毒"]
        }
        # 综合数据库：存储用户输入的症状和推理结果
        self.database = {
            "symptoms": [],
            "diagnosis": []
        }
    
    def get_user_input(self):
        """获取用户输入的症状"""
        print("请输入宠物的症状（输入'结束'完成输入）：")
        while True:
            symptom = input("症状: ")
            if symptom == "结束":
                break
            self.database["symptoms"].append(symptom)
            print(f"已记录症状: {symptom}")
    
    def infer(self):
        """推理机：根据症状推断可能的疾病"""
        if not self.database["symptoms"]:
            print("没有输入症状，无法进行诊断")
            return
        
        print("\n正在分析症状...")
        possible_diseases = set()
        
        # 遍历知识库，查找与症状匹配的疾病
        for symptom in self.database["symptoms"]:
            if symptom in self.knowledge_base:
                possible_diseases.update(self.knowledge_base[symptom])
        
        if possible_diseases:
            self.database["diagnosis"] = list(possible_diseases)
            print(f"可能的疾病: {', '.join(self.database['diagnosis'])}")
        else:
            print("根据现有知识，无法确定可能的疾病")
    
    def explain(self):
        """解释机构：解释推理过程"""
        if not self.database["diagnosis"]:
            return
        
        print("\n诊断依据:")
        for disease in self.database["diagnosis"]:
            matching_symptoms = []
            for symptom in self.database["symptoms"]:
                if symptom in self.knowledge_base and disease in self.knowledge_base[symptom]:
                    matching_symptoms.append(symptom)
            
            if matching_symptoms:
                print(f"{disease}: 与症状 {', '.join(matching_symptoms)} 相关")
    
    def run(self):
        """运行专家系统"""
        print("宠物健康诊断专家系统")
        print("=" * 30)
        
        self.get_user_input()
        self.infer()
        self.explain()
        
        print("\n=" * 30)
        print("诊断结束")


# 运行专家系统
if __name__ == "__main__":
    es = ExpertSystem()
    es.run()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.decomposition import PCA
from sklearn.metrics import accuracy_score

plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
# 1. 监督学习：逻辑回归示例
def logistic_regression_example():
    """逻辑回归分类示例"""
    print("=== 逻辑回归分类示例 ===")
    # 生成简单的二维分类数据
    np.random.seed(42)
    X = np.random.randn(100, 2)
    y = (X[:, 0] + X[:, 1] > 0).astype(int)

    # 创建并训练逻辑回归模型
    model = LogisticRegression()
    model.fit(X, y)

    # 预测并计算准确率
    y_pred = model.predict(X)
    accuracy = accuracy_score(y, y_pred)
    print(f"模型准确率: {accuracy:.4f}")

    # 可视化分类结果
    plt.figure(figsize=(8, 6))
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', edgecolors='k')

    # 绘制决策边界
    h = 0.02
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, alpha=0.3, cmap='viridis')

    plt.xlabel('特征1')
    plt.ylabel('特征2')
    plt.title('逻辑回归分类结果')
    plt.savefig('logistic_regression.png')
    plt.close()


# 2. 无监督学习：K-means聚类示例
def kmeans_clustering_example():
    """K-means聚类示例"""
    print("=== K-means聚类示例 ===")
    # 生成聚类数据
    np.random.seed(42)
    X = np.vstack([
        np.random.randn(50, 2) + np.array([2, 2]),
        np.random.randn(50, 2) + np.array([-2, -2]),
        np.random.randn(50, 2) + np.array([2, -2])
    ])

    # 创建并训练K-means模型
    kmeans = KMeans(n_clusters=3, random_state=42)
    kmeans.fit(X)
    labels = kmeans.predict(X)
    centroids = kmeans.cluster_centers_

    # 可视化聚类结果
    plt.figure(figsize=(8, 6))
    plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', edgecolors='k')
    plt.scatter(centroids[:, 0], centroids[:, 1], c='red', marker='x', s=200)

    plt.xlabel('特征1')
    plt.ylabel('特征2')
    plt.title('K-means聚类结果')
    plt.savefig('kmeans_clustering.png')
    plt.close()


# 3. 无监督学习：PCA降维示例
def pca_example():
    """PCA降维示例"""
    print("=== PCA降维示例 ===")
    # 生成高维数据
    np.random.seed(42)
    X = np.random.randn(100, 10)

    # 创建并应用PCA
    pca = PCA(n_components=2)  # 降维到2维
    X_reduced = pca.fit_transform(X)

    # 输出方差解释率
    explained_variance = pca.explained_variance_ratio_
    total_variance = sum(explained_variance)
    print(f"各主成分方差解释率: {explained_variance}")
    print(f"总方差解释率: {total_variance:.4f}")

    # 可视化降维结果
    plt.figure(figsize=(8, 6))
    plt.scatter(X_reduced[:, 0], X_reduced[:, 1])

    plt.xlabel('主成分1')
    plt.ylabel('主成分2')
    plt.title('PCA降维结果')
    plt.savefig('pca_reduction.png')
    plt.close()


# 4. 监督学习：决策树示例
def decision_tree_example():
    """决策树分类示例"""
    print("=== 决策树分类示例 ===")
    # 生成简单的二维分类数据
    np.random.seed(42)
    X = np.random.randn(100, 2)
    y = (X[:, 0] ** 2 + X[:, 1] ** 2 > 1).astype(int)

    # 创建并训练决策树模型
    model = DecisionTreeClassifier(max_depth=3)
    model.fit(X, y)

    # 预测并计算准确率
    y_pred = model.predict(X)
    accuracy = accuracy_score(y, y_pred)
    print(f"模型准确率: {accuracy:.4f}")

    # 可视化分类结果
    plt.figure(figsize=(8, 6))
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', edgecolors='k')

    # 绘制决策边界
    h = 0.02
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, alpha=0.3, cmap='viridis')

    plt.xlabel('特征1')
    plt.ylabel('特征2')
    plt.title('决策树分类结果')
    plt.savefig('decision_tree.png')
    plt.close()


# 运行示例
if __name__ == "__main__":
    logistic_regression_example()
    kmeans_clustering_example()
    pca_example()
    decision_tree_example()
    print("所有示例运行完毕，结果图片已保存")

import pandas as pd
import matplotlib.pyplot as plt
from mlxtend.frequent_patterns import apriori, association_rules

plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
def association_rule_mining_example():
    """关联规则挖掘示例"""
    print("=== 关联规则挖掘示例 ===")
    # 创建示例购物篮数据
    # 每一行表示一个购物篮，列表示商品是否被购买（1表示购买，0表示未购买）
    data = {
        '面包': [1, 1, 0, 1, 0],
        '牛奶': [1, 0, 1, 1, 1],
        '鸡蛋': [0, 1, 1, 0, 1],
        '黄油': [1, 0, 0, 1, 0],
        '奶酪': [0, 1, 1, 0, 1],
        '水果': [1, 1, 1, 0, 1]
    }
    df = pd.DataFrame(data)

    print("购物篮数据:")
    print(df)

    # 使用Apriori算法发现频繁项集
    frequent_itemsets = apriori(df, min_support=0.4, use_colnames=True)
    frequent_itemsets['length'] = frequent_itemsets['itemsets'].apply(lambda x: len(x))

    print("\n频繁项集:")
    print(frequent_itemsets)

    # 生成关联规则
    rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.5)

    print("\n关联规则:")
    print(rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']])

    # 可视化强关联规则
    plt.figure(figsize=(10, 6))
    plt.scatter(rules['support'], rules['confidence'], alpha=0.5)
    plt.xlabel('支持度')
    plt.ylabel('置信度')
    plt.title('关联规则 - 支持度 vs 置信度')

    # 为强规则添加标签
    for i, rule in rules.iterrows():
        if rule['lift'] > 1.5:  # 只标记提升度高的规则
            plt.annotate(f"({', '.join(rule['antecedents'])}) -> ({', '.join(rule['consequents'])})",
                         (rule['support'], rule['confidence']),
                         fontsize=9)

    plt.grid(True)
    plt.savefig('association_rules.png')
    plt.close()


# 运行示例
if __name__ == "__main__":
    association_rule_mining_example()
    print("关联规则挖掘示例运行完毕，结果图片已保存")