养成式AI:Reasoning Robot v1.1

养成式AI:Reasoning Robot v1.1
SLYZPG.PrinceYang
#作者立志制作一个可以养成的AI，这是制作过程中的思考日记，希望得到其他人的建议帮助。
#作者从未系统学习过计算机人工智能的的专业知识，希望有人能告诉他他的想法是否正确，是否历史上有人提出过类似想法，结果是什么。
AI在解决问题的时候总是得益于他内部的算法，而我想要做的是一个没有内置算法的AI，也就是说他不会解决任何问题——他也会解决任何问题。
人的智慧来自于经验和思维，而经验又是从思维中得出的。所以让机器解决问题的时候就可以考虑人的思维，然后机器运用思维得到经验，从而得到智慧。
那么思维是从何而来？我认为思维也可以算作是一种经验。在处理各种问题的时候，人才得到了思维方式，那么就应当有一种根本的思维方式让人来得到其他的思维。
在数学课中，思维主要是合情推理和演绎推理。而在上课的时候，学生对合情推理学的很快，很容易理解，这就不免让人想到合情推理是人类的一种本能，而演绎推理则是人们通过对自然规律的认识而得到的。
合情推理包括类比和归纳——来自人教数学选修2-2。
无论是类比还是归纳，他本质上都是对于事物之间联系的认知。例如:
金属——铁——导电，金属——铜——导电，就可以通过相同的联系“金属——铝”得到“铝——导电”。
这样或许就可以建立一个人类的思维模型，先输入信息，得到联系，当遇到没见过的信息时就通过已经建立的联系来推测。


成人的思维过于复杂，不如考虑婴儿:
婴儿的母亲对他说:“妈妈，叫我妈妈。”
这时婴儿得到的信息是这样的:1.视觉信息:一个外貌为什么什么样人。2.听觉信息:一组特殊频率的声波。婴儿的大脑中就会写入妈妈的外貌与声波的一组联系信息(视觉:*妈妈*，听觉:“妈妈”)
这时婴儿是不会说话的，因为他不知道怎么发声。
他需要先实验:某一次他偶尔叫出一声“妈”，然后得到听觉信息“妈”，建立联系(听觉:“妈”，行为:控制声带怎么怎么震动)
之后再一次见到妈妈时就会收到视觉信息*妈妈*，然后大脑联想声波“妈妈”，最后关联到行为:说“妈妈”


这是一个思维实验，或许可以用以说明天生耳聋的孩子很难学会说话的原因。在此我希望有人能够提供更多的支持或反驳的例证。
我认为这个AI内部算法必然是十分简单的，仅仅是输入信息，建立联系，查找比对，输出结果四个过程，或许还要加上联系大小(即给人的印象有多深)的算法，和遗忘(像人一样把不常出现的知识遗忘掉)的算法。总之结构像婴儿一样的简单，他来算数的时候会想人一样思考，这将导致他具有极低的工作效率，但是他会表现得像一个真正的人类而不是一个机器。我甚至幻想过这样就可以证明生命是可以人造的，但他现在还仅仅是一个想法。马上要高三了，也许高考之后我会去计算机系，也许我也会永远地放弃编程，总之，这是我的目标，要制造一个可以养成的婴儿AI,希望得到回复。

源代码与一些缺陷:

#-*-coding:utf8;-*-



import os

import xml.etree.ElementTree as ET

import time



########## 数据初始化 ############



#创建数据库

print "Loading memory..."

try:#尝试打开数据库

    opmem = open("memories.xml")

except IOError:#打开错误就创建数据库

    opmem = ET.Element("root")

    tree = ET.ElementTree(opmem)

    tree.write("memories.xml",encoding="UTF-8")

#重载数据库，tree为数据库对象，root为根节点

tree = ET.parse("memories.xml")

root = tree.getroot()



#创建日志

print "Loading log..."

try:#尝试打开日志

    oplog = open("log.txt")

except IOError:#日志错误则创建日志

    oplog = open("log.txt","w")

    oplog.write("It is a LOG.")

    oplog.close()



#定义数据类

class Data(object):

    """

    数据类用于对得到的数据进行操作:

    self.refer为检索项

    self.connect为关联项

    self.weight为数据权

    self.s为识别标志

    self.save()为保存数据

    """

    def __init__(self,refer,connect,weight):

        self.refer = refer

        self.connect = connect

        self.weight = weight

        self.s = self.refer + self.connect

    def save(self,location):

        """

        输入节点地址

        保存为refer元素，connect元素，weight元素

        """

        a = ET.SubElement(location,"refer")

        a.text = self.refer

        b = ET.SubElement(location,"connect")

        b.text = self.connect

        c = ET.SubElement(location,"weight")

        c.text = str(self.weight)



#输入器

def inputsth():

    global sth

    sth = raw_input(">>> ")

    return sth



#归纳器

def induct(spl):

    """

    将获得的数据归纳入库

    """

    datas = []#临时数据库

    for i0 in spl:#遍历拆分结果

        for i1 in spl:

            if i0 != i1:#除去自我关联项

                #计算两个数据的距离相关度

                w = spl.index(i0)-spl.index(i1)

                if abs(w) > 3:#距离超过3的数据不写入，防止句子过长导致运算量过大。

                    continue

                #顺序时增加相关度

                if w > 0:

                    w += 1

                #存入临时数据库

                datas.append(Data(i0,i1,4-abs(w)))

    for i in datas:#遍历临时数据库

        check = False#是否数据库已有此项

        for a in root:#遍历data元素

            c = ''#识别标志

            for b in a:#获取识别标志

                c += b.text

            #判断此data元素和数据是否相同

            if c.find(i.s) != -1:

                #修改weight元素加一

                #重复次数的权重

                w = a.find("weight")

                w.text=str(int(w.text)+1)

                check = True

                break      

        if check == False:#找不到相同数据时添加新data元素

            put = ET.SubElement(root,"data")  

            put.attrib["time"] = str(time.time())

            i.save(put)

    #保存数据库

    tree.write("memories.xml",encoding="UTF-8")



#类比器

def analogic(spl):

    global output

    #创建临时数据库

    datas = []

    try:

        x = spl.index("?")

    except ValueError:

        return False

    for i in spl:#遍历spl

        y = spl.index(i)

        if i != "?":#读取非？项目

            dis = x-y

            if dis > 0:

                dis += 1

            for child in root:#遍历数据库

                #查询项目

                if child.find("refer").text == i:

                    #查询结果写入datas

                    datas.append([child.find("connect").text,int(child.find("weight").text)-abs(dis)+4])

    if datas == []:

        return False

    #整理库

    ans = {}

    for i in datas:

        #将同类结果和并

        try:

            ans[i[0]] += i[1]

        except KeyError:

            ans.update({i[0]:i[1]})

    #找出比重最大的结果

    h = 0

    for i in ans:

        if ans[i] > h:

            h = ans[i]

            output = i







############# 主程序 ############

print "Welcome To Reasoning Robot ver 1.1"

print "#"*20+" HELP "+"#"*20

print "input nothing to exit"

print 'input "Clear memory" to rebuild memory'

print 'input "Clear log" to rebuild log'

print 'input "Delete" to delete all the datas'

print

print "for example:"

print ">>> hello world"

print "I see."

print ">>> hello ?"

print "world"

print

print "WARNING!!!!!!!!!"

print "the most important thing should be say three*3 times:"

print "Do Not Input Chinese!!!"*3

print "Do Not Input Chinese!!!"*3

print "Do Not Input Chinese!!!"*3

print "#"*46

print

while inputsth() != "":

    #写入日志

    open("log.txt","a").write("\n["+time.asctime(time.localtime())+"]\ninput = "+sth)

    open("log.txt","a").close()

    #输入解析

    if sth == "Clear memory":#清除记忆

        del root#清除内存

        os.remove("memories.xml")#删除文件

        #重建数据库

        opmem = ET.Element("root")

        tree = ET.ElementTree(opmem)

        tree.write("memories.xml",encoding="UTF-8")

        tree = ET.parse("memories.xml")

        root = tree.getroot()

        print "Done"

        open("log.txt","a").write("\noutput = Done")

        open("log.txt","a").close()

        continue

    if sth == "Clear log":#清除日志

        os.remove("log.txt")

        oplog = open("log.txt","w")

        oplog.write("It is a LOG.")

        oplog.close()

        print "Done"

        continue

    if sth == "Delete":#删除数据

        os.remove("log.txt")

        os.remove("memories.xml")

        print "Done"

        continue

    spl = sth.split(" ")

    #判断输入为陈述还是疑问

    if sth.find("?") == -1:

        #输入为陈述

        if spl[0] == sth:

            #只有一个输入，无法建立关联

            #报错

            output = "Sorry,I cannot understand it."

        else:

            #将输入归纳入库

            induct(spl)

            output = "I see."

    else:

        if spl == sth:

            #只有一个输入，无法联想

            #报错

            output = "Sorry,I don't know."

        else:

            if analogic(spl) == False:

                output = "Please give me more information"

    #写入日志

    open("log.txt","a").write("\noutput = "+output)

    open("log.txt","a").close()

    print output

这个程序可以运行，但是有很多缺陷。


1.我希望在类比器运行时根据"？"的所在位置更加准确的填空。但是很无奈我被乱七八糟的数据搞蒙了，也没有过多精力去修改。
2.不能输入汉语，我给我的一个同学发过去，结果程序被他输入的汉语搞崩溃了。
3.没有遗忘功能，程序应该随着输入次数增多而忘掉关联度少的内容，在我输入一篇英语小说后，他运行的效率堪称龟速。
4.关联应该是一张网，而我这个只能两两关联，这也是运行效率低的原因之一。
5.一次只能输出一个结果。


这也是我对2.0版本的设想，在输入一本例如“日常口语3000句”之后可以与人简单交流，希望得到建议。