人工智能的图像识别

import pandas as pd
# 读取保留字典形式的动物特性信息

with open(r"animal_data.txt", "r", encoding='utf‐8') as f:  # 打开文件

    data = f.read()  # 读取文件

dic1 = eval(data)

print("字典形式的动物特性信息",dic1)

结果如下：

with open(r"rule_data.txt", "r", encoding='utf‐8') as f:  # 打开文件

    rule_data = f.read()  # 读取文件

rule_dic = eval(rule_data)

print("规则库特征数据",rule_dic )

结果如下：

with open(r"rule_result_data.txt", "r", encoding='utf‐8') as f:  # 打开文件

    result_data = f.read()  # 读取文件

result_dic = eval(result_data)

print("规则库匹配数据",result_dic )

结果如下：

# 综合数据库

def input1():

    answer_features = input('\n请选择动物的特征编号，用英文逗号分开，回车结束输入：')

    try:

        #print(answer)

        answer_features = list(answer_features.split(','))

        new_answer = [int(x) for x in answer_features]

        

        return new_answer

    except Exception:

        print('您输入的是数字格式有误')

# 正向匹配推理机
use_rules  = []  # 保存可能类别————能够与特征进行匹配的规则，即标记哪些规则被使用了
def rule_Find_Forward(features,rule,rule_result,animal_dic): 
    if len(features) < 6 :

        q = 1 #  存放是否停止判断的 参数

        global Data

        Data = []

        I = []

        N =[] # 存放要缺失的特征编号

        num = [] # 存放目标类的的位置

        for j in  range(1,len(rule_dic)+1) : # 遍历规则库

            n = []

            c= 0

            for i in range(len(rule_dic[j])): # 循环每一个匹配规则

                if rule_dic[j][i] not in features : # 判断这个类别规则中与输入规则是否有相符合的

                    n.append(rule_dic[j][i])

                else: 

                    c += 1

            N.append(list(n))

            num.append(j) # 并添加信息位置

            Si = c/len(rule_dic[j])

            I.append(Si)

            #n = list(set(n)) # 去重

            #n.sort() # 排序，因为规则是从小到大排序的

            # 输出相似度

        Data = pd.DataFrame({'可能类别':num,'缺失特征':N,'相似度':I})

        if sum(Data['相似度'] == 1) > 0:

            col1 = Data.iloc[Data['相似度'].values == 1,0]

            for i in col1:

                #[dict_before[nn] for nn in n],

                print('属于的类别为====>',dic1[result_dic[i]]) # 匹配可能属于的类别

            #print('最终类别为',Data.iloc[Data['相似度'].values == 1,0])

        elif sum(Data['相似度'] == 1) > 0 or sum(Data['相似度'] == 1) < 1:

            #print('最终类别为',Data.iloc[Data['相似度'].values > 0,0])

            col = Data.iloc[Data['相似度'].values > 0,0]

            for i in col:

                #[dict_before[nn] for nn in n],

                print(dic1[result_dic[i]]) # 匹配可能属于的类别
             #*********请补全代码-end**********#
        if features == [26]:
            return '金钱豹'
        elif features == [27]:
            return '虎'
        elif features == [28]:
            return '长颈鹿'
        elif features == [29]:
            return '斑马'
        elif features == [30]:
            return '鸵鸟'
        elif features == [31]:
            return '企鹅'
        elif features == [32]:
            return '海燕'
    else:
        print('输入的特征指标过多')
print(dic1)

# 初步输入特征（综合数据库）

animal_data1 = input1()

rule_Find_Forward(animal_data,rule_dic,result_dic,dic1)

结果如下:

# 逆向匹配推理机

def rule_Find_reverse(a,rule,rule_result,dict_before):

    if len(a) < 6 :

        q = 1 #  存放是否停止判断的 参数

        global Data

        Data = []

        I = []

        N =[] # 存放要缺失的特征编号

        num = [] # 存放目标类的的位置

        for j in  range(1,len(rule_dic)+1) : # 遍历规则库

            n = []

            c= 0

            for i in range(len(rule_dic[j])): # 循环每一个匹配规则

                if rule_dic[j][i] not in a : # 判断这个类别规则中与输入规则是否有相符合的

                    n.append(rule_dic[j][i])

                else: 

                    c += 1

            N.append(list(n))

            num.append(j) # 并添加信息位置

            Si = c/len(rule_dic[j])

            I.append(Si)

            #n = list(set(n)) # 去重

            #n.sort() # 排序，因为规则是从小到大排序的

            # 输出相似度

        Data = pd.DataFrame({'可能类别':num,'缺失特征':N,'相似度':I})

        if sum(Data['相似度'] == 1) > 0:

            col1 = Data.iloc[Data['相似度'].values == 1,0]

            for i in col1:

                #[dict_before[nn] for nn in n],

                print('属于的类别为====>',dic1[result_dic[i]]) # 匹配可能属于的类别

            #print('最终类别为',Data.iloc[Data['相似度'].values == 1,0])

        elif sum(Data['相似度'] == 1) > 0 or sum(Data['相似度'] == 1) < 1:

            #print('最终类别为',Data.iloc[Data['相似度'].values > 0,0])

            col = Data.iloc[Data['相似度'].values > 0,0]

            for i in col:

                #[dict_before[nn] for nn in n],

                print('可能属于',dic1[result_dic[i]],'的匹配概率为{:.2%}'.format(Data.iloc[i-1,2])) # 匹配可能属于的类别

            while q == 1 :

                print("是否还要继续判断？")

                c = input('\nY(y) or N(n)')

                if c == 'y' or c == 'Y':

                    # 打印输入特征缺失的类

                    rol = Data.iloc[Data['相似度'].values > 0,1]#此处特征不会更新

                    rol_new = []

                    for i in rol:

                        rol_new.append(list(i))

                    b = str(rol_new)

                    b = b.replace('[', '')

                    b = b.replace(']', '')

                    a1 = list(eval(b))

                    

                    n = list(set(a1)) # 去重

                    n.sort() # 排序，因为规则是从小到大排序的

                    

                    print('请继续增加以下特征')

                    for i in n:

                        if i in dic1 :

                            print(i,':',dic1[i])

                    animal_data1 = input1() 

                    a = a+animal_data1

                    rule_Find_reverse(a,rule_dic,result_dic,dic1)

                else:

                    q = 0   

        else:

            print('无法判断')

    else:

        print('输入的特征指标过多')

# 特征说明

print(dic1)

# 初步输入特征（综合数据库）

animal_data2 = input1()

rule_Find_reverse(animal_data,rule_dic,result_dic,dic1)

结果如下：

def rule_Find_two_way(a,rule,rule_result,dict_before):

    if len(a) < 6 :

        q = 1 #  存放是否停止判断的 参数

        global Data

        Data = []

        I = []

        N =[] # 存放要缺失的特征编号

        num = [] # 存放目标类的的位置

        for j in  range(1,len(rule_dic)+1) : # 遍历规则库

            n = []

            c= 0

            for i in range(len(rule_dic[j])): # 循环每一个匹配规则

                if rule_dic[j][i] not in a : # 判断这个类别规则中与输入规则是否有相符合的

                    n.append(rule_dic[j][i])

                else: 

                    c += 1

            N.append(list(n))

            num.append(j) # 并添加信息位置

            Si = c/len(rule_dic[j])

            I.append(Si)

            #n = list(set(n)) # 去重

            #n.sort() # 排序，因为规则是从小到大排序的

            # 输出相似度

        Data = pd.DataFrame({'可能类别':num,'缺失特征':N,'相似度':I})

        if sum(Data['相似度'] == 1) > 0:

            col1 = Data.iloc[Data['相似度'].values == 1,0]

            for i in col1:

                #[dict_before[nn] for nn in n],

                print('属于的类别为====>',dic1[result_dic[i]]) # 匹配可能属于的类别

            #print('最终类别为',Data.iloc[Data['相似度'].values == 1,0])

        elif sum(Data['相似度'] == 1) > 0 or sum(Data['相似度'] == 1) < 1:

            #print('最终类别为',Data.iloc[Data['相似度'].values > 0,0])

            col = Data.iloc[Data['相似度'].values > 0,0]

            for i in col:

                #[dict_before[nn] for nn in n],

                print('可能属于',dic1[result_dic[i]],'的匹配概率为{:.2%}'.format(Data.iloc[i-1,2])) # 匹配可能属于的类别

            while q == 1 :

                print("是否还要继续判断？")

                c = input('\nY(y) or N(n)')

                if c == 'y' or c == 'Y':

                    # 打印输入特征缺失的类

                    rol = Data.iloc[Data['相似度'].values > 0,1]#此处特征不会更新

                    rol_new = []

                    for i in rol:

                        rol_new.append(list(i))

                    b = str(rol_new)

                    b = b.replace('[', '')

                    b = b.replace(']', '')

                    a1 = list(eval(b))

                    

                    n = list(set(a1)) # 去重

                    n.sort() # 排序，因为规则是从小到大排序的

                    

                    print('请继续增加以下特征')

                    for i in n:

                        if i in dic1 :

                            print(i,':',dic1[i])

                    animal_data1 = input1() 

                    a = a+animal_data1

                    rule_Find(a,rule_dic,result_dic,dic1)

                else:

                    q = 0   

        else:

            print('无法判断')

    else:

        print('输入的特征指标过多')

 

# 双向推理

def rule_Find(a,rule,rule_result,dict_before):

    reslut = rule_Find_reverse(a,rule_dic,result_dic,dic1)

    if reslut == '无法识别':

         rule_Find_two_way(a,rule,rule_result,dict_before)

    else:

         print(reslut)

print(dic1)

animal_data = input1()

rule_Find(animal_data,rule_dic,result_dic,dic1)

结果如下：

所有的源码如下：

import pandas as pd
# 读取保留字典形式的动物特性信息

with open(r"animal_data.txt", "r", encoding='utf‐8') as f:  # 打开文件

    data = f.read()  # 读取文件

dic1 = eval(data)

print("字典形式的动物特性信息",dic1)
with open(r"rule_data.txt", "r", encoding='utf‐8') as f:  # 打开文件

    rule_data = f.read()  # 读取文件

rule_dic = eval(rule_data)

print("规则库特征数据",rule_dic )
with open(r"rule_result_data.txt", "r", encoding='utf‐8') as f:  # 打开文件

    result_data = f.read()  # 读取文件

result_dic = eval(result_data)

print("规则库匹配数据",result_dic )
# 综合数据库

def input1():

    answer_features = input('\n请选择动物的特征编号，用英文逗号分开，回车结束输入：')

    try:

        #print(answer)

        answer_features = list(answer_features.split(','))

        new_answer = [int(x) for x in answer_features]

        

        return new_answer

    except Exception:

        print('您输入的是数字格式有误')
# 正向匹配推理机
use_rules  = []  # 保存可能类别————能够与特征进行匹配的规则，即标记哪些规则被使用了
def rule_Find_Forward(features,rule,rule_result,animal_dic): 
    if len(features) < 6 :

        q = 1 #  存放是否停止判断的 参数

        global Data

        Data = []

        I = []

        N =[] # 存放要缺失的特征编号

        num = [] # 存放目标类的的位置

        for j in  range(1,len(rule_dic)+1) : # 遍历规则库

            n = []

            c= 0

            for i in range(len(rule_dic[j])): # 循环每一个匹配规则

                if rule_dic[j][i] not in features : # 判断这个类别规则中与输入规则是否有相符合的

                    n.append(rule_dic[j][i])

                else: 

                    c += 1

            N.append(list(n))

            num.append(j) # 并添加信息位置

            Si = c/len(rule_dic[j])

            I.append(Si)

            #n = list(set(n)) # 去重

            #n.sort() # 排序，因为规则是从小到大排序的

            # 输出相似度

        Data = pd.DataFrame({'可能类别':num,'缺失特征':N,'相似度':I})

        if sum(Data['相似度'] == 1) > 0:

            col1 = Data.iloc[Data['相似度'].values == 1,0]

            for i in col1:

                #[dict_before[nn] for nn in n],

                print('属于的类别为====>',dic1[result_dic[i]]) # 匹配可能属于的类别

            #print('最终类别为',Data.iloc[Data['相似度'].values == 1,0])

        elif sum(Data['相似度'] == 1) > 0 or sum(Data['相似度'] == 1) < 1:

            #print('最终类别为',Data.iloc[Data['相似度'].values > 0,0])

            col = Data.iloc[Data['相似度'].values > 0,0]

            for i in col:

                #[dict_before[nn] for nn in n],

                print(dic1[result_dic[i]]) # 匹配可能属于的类别
             #*********请补全代码-end**********#
        if features == [26]:
            return '金钱豹'
        elif features == [27]:
            return '虎'
        elif features == [28]:
            return '长颈鹿'
        elif features == [29]:
            return '斑马'
        elif features == [30]:
            return '鸵鸟'
        elif features == [31]:
            return '企鹅'
        elif features == [32]:
            return '海燕'
    else:
        print('输入的特征指标过多')
print(dic1)

# 初步输入特征（综合数据库）

animal_data1 = input1()

rule_Find_Forward(animal_data,rule_dic,result_dic,dic1)
# 逆向匹配推理机

def rule_Find_reverse(a,rule,rule_result,dict_before):

    if len(a) < 6 :

        q = 1 #  存放是否停止判断的 参数

        global Data

        Data = []

        I = []

        N =[] # 存放要缺失的特征编号

        num = [] # 存放目标类的的位置

        for j in  range(1,len(rule_dic)+1) : # 遍历规则库

            n = []

            c= 0

            for i in range(len(rule_dic[j])): # 循环每一个匹配规则

                if rule_dic[j][i] not in a : # 判断这个类别规则中与输入规则是否有相符合的

                    n.append(rule_dic[j][i])

                else: 

                    c += 1

            N.append(list(n))

            num.append(j) # 并添加信息位置

            Si = c/len(rule_dic[j])

            I.append(Si)

            #n = list(set(n)) # 去重

            #n.sort() # 排序，因为规则是从小到大排序的

            # 输出相似度

        Data = pd.DataFrame({'可能类别':num,'缺失特征':N,'相似度':I})

        if sum(Data['相似度'] == 1) > 0:

            col1 = Data.iloc[Data['相似度'].values == 1,0]

            for i in col1:

                #[dict_before[nn] for nn in n],

                print('属于的类别为====>',dic1[result_dic[i]]) # 匹配可能属于的类别

            #print('最终类别为',Data.iloc[Data['相似度'].values == 1,0])

        elif sum(Data['相似度'] == 1) > 0 or sum(Data['相似度'] == 1) < 1:

            #print('最终类别为',Data.iloc[Data['相似度'].values > 0,0])

            col = Data.iloc[Data['相似度'].values > 0,0]

            for i in col:

                #[dict_before[nn] for nn in n],

                print('可能属于',dic1[result_dic[i]],'的匹配概率为{:.2%}'.format(Data.iloc[i-1,2])) # 匹配可能属于的类别

            while q == 1 :

                print("是否还要继续判断？")

                c = input('\nY(y) or N(n)')

                if c == 'y' or c == 'Y':

                    # 打印输入特征缺失的类

                    rol = Data.iloc[Data['相似度'].values > 0,1]#此处特征不会更新

                    rol_new = []

                    for i in rol:

                        rol_new.append(list(i))

                    b = str(rol_new)

                    b = b.replace('[', '')

                    b = b.replace(']', '')

                    a1 = list(eval(b))

                    

                    n = list(set(a1)) # 去重

                    n.sort() # 排序，因为规则是从小到大排序的

                    

                    print('请继续增加以下特征')

                    for i in n:

                        if i in dic1 :

                            print(i,':',dic1[i])

                    animal_data1 = input1() 

                    a = a+animal_data1

                    rule_Find_reverse(a,rule_dic,result_dic,dic1)

                else:

                    q = 0   

        else:

            print('无法判断')

    else:

        print('输入的特征指标过多')

# 特征说明

print(dic1)

# 初步输入特征（综合数据库）

animal_data2 = input1()

rule_Find_reverse(animal_data,rule_dic,result_dic,dic1)
def rule_Find_two_way(a,rule,rule_result,dict_before):

    if len(a) < 6 :

        q = 1 #  存放是否停止判断的 参数

        global Data

        Data = []

        I = []

        N =[] # 存放要缺失的特征编号

        num = [] # 存放目标类的的位置

        for j in  range(1,len(rule_dic)+1) : # 遍历规则库

            n = []

            c= 0

            for i in range(len(rule_dic[j])): # 循环每一个匹配规则

                if rule_dic[j][i] not in a : # 判断这个类别规则中与输入规则是否有相符合的

                    n.append(rule_dic[j][i])

                else: 

                    c += 1

            N.append(list(n))

            num.append(j) # 并添加信息位置

            Si = c/len(rule_dic[j])

            I.append(Si)

            #n = list(set(n)) # 去重

            #n.sort() # 排序，因为规则是从小到大排序的

            # 输出相似度

        Data = pd.DataFrame({'可能类别':num,'缺失特征':N,'相似度':I})

        if sum(Data['相似度'] == 1) > 0:

            col1 = Data.iloc[Data['相似度'].values == 1,0]

            for i in col1:

                #[dict_before[nn] for nn in n],

                print('属于的类别为====>',dic1[result_dic[i]]) # 匹配可能属于的类别

            #print('最终类别为',Data.iloc[Data['相似度'].values == 1,0])

        elif sum(Data['相似度'] == 1) > 0 or sum(Data['相似度'] == 1) < 1:

            #print('最终类别为',Data.iloc[Data['相似度'].values > 0,0])

            col = Data.iloc[Data['相似度'].values > 0,0]

            for i in col:

                #[dict_before[nn] for nn in n],

                print('可能属于',dic1[result_dic[i]],'的匹配概率为{:.2%}'.format(Data.iloc[i-1,2])) # 匹配可能属于的类别

            while q == 1 :

                print("是否还要继续判断？")

                c = input('\nY(y) or N(n)')

                if c == 'y' or c == 'Y':

                    # 打印输入特征缺失的类

                    rol = Data.iloc[Data['相似度'].values > 0,1]#此处特征不会更新

                    rol_new = []

                    for i in rol:

                        rol_new.append(list(i))

                    b = str(rol_new)

                    b = b.replace('[', '')

                    b = b.replace(']', '')

                    a1 = list(eval(b))

                    

                    n = list(set(a1)) # 去重

                    n.sort() # 排序，因为规则是从小到大排序的

                    

                    print('请继续增加以下特征')

                    for i in n:

                        if i in dic1 :

                            print(i,':',dic1[i])

                    animal_data1 = input1() 

                    a = a+animal_data1

                    rule_Find(a,rule_dic,result_dic,dic1)

                else:

                    q = 0   

        else:

            print('无法判断')

    else:

        print('输入的特征指标过多')

 

# 双向推理

def rule_Find(a,rule,rule_result,dict_before):

    reslut = rule_Find_reverse(a,rule_dic,result_dic,dic1)

    if reslut == '无法识别':

         rule_Find_two_way(a,rule,rule_result,dict_before)

    else:

         print(reslut)

print(dic1)

animal_data = input1()

rule_Find(animal_data,rule_dic,result_dic,dic1)