广义智能集论文

来源：互联网发布：python 获取当前日期编辑：程序博客网时间：2024/06/05 09:08

广义智能集

lindorl

1 摘要

广义智能集是人工智能方面的理论，它采用生态系统构建的思路和方式去认识、解释并指导构建出具备智能的物理或数字体系。

在人工智能的发展历史中并没有明确、有效地指出过“智能”的概念，而大多数成熟的科学科目都具备基本概念明晰的一个特点。然而，由于人工智能的特殊性，这一词汇到目前为止仍然没有得到一个明晰的解释。虽然，对“智能”的定义非常的困难，不过广义智能集理论仍然将尝试地给出一些明晰的概念并提供与之相关的智能系统构建方案。

需要注意的是，在本文中并没有将人类的大脑当做唯一的拥有智能的东西，任何生物学概念上认定的生命系统在本文中都认定为拥有智能的东西，例如：猴子、树、草履虫等等。

2 介绍

广义智能集尝试用一种新的方式去解释当前所谓的人工智能，并提出广义智能集所定义的广义智能。

第三节 —— 详细描述广义智能集的思路，设想；

第四节 —— 详细说明论证广义智能集的基本概念、原理、相关特性；

第五节 —— 采用两个简单的 Demo 说明广义智能集的可实践性；

第六节 —— 提出一些根据广义智能集的思想或理论推导出的事物；

第七节 —— 对广义智能集的相关工作做出总结。

3 思路构建

很明显，在这个世界上不是只有人才具有智能，例如黑猩猩也应当具有智能，因为相关研究表明黑猩猩的智力可以相当于5~7岁的人类，你总不能说7岁以下、五岁以上的儿童还不具备能力通过图灵测试吧（当然要保证测试方式的科学性），同样的大象、猴子、海豚也都应当具有智能，不过你认为它们都能通过图灵测试吗？（即便能够保证测试方式的科学性）。所以我认为研究智能时，除了考虑数量级的区别外还应考虑类型的区别。

假定所有生命都具备智能（这里的假定不需要被证明，只不过提出这样的假定可以在方法论上提高对智能的可研究性），包括动物，植物，单细胞生物和病毒。那么，我们可以很快推导出由生物与非生物环境有机组成的生态系统同样具备智能。一方面生态系统不会消去单个生物的特征，另一方面由于多个生物互相影响可能会使得其构成的体系具有更多特征。与此同时，也很容易认可构成生物的最小因子一定是非生物物质。

假定多细胞生物本身也是一个生态系统（这里的假定不需要被证明，只不过提出这样的假定可以在方法论上提高对智能的可研究性）。实际上多细胞生物内部同样具备生态系统的特征。如果不考虑多细胞生命体内的细胞的生殖问题，完全可以将其当做生存在多细胞生命体环境下的单细胞生物。那么如果认可单细胞生物具备智能，就理应认可细胞具备智能。

由上面的两个假设，我们得出这样的一些简单的结论：

注意，从现在开始，我所说的“智能”如果没有明确说明，都指的是广义智能集所定义的智能。

一定条件下，非智能物体可以构成智能物体；

为什么？首先我们可以肯定的是我们既然提出“智能”，那么就已经认可不是所有的物体都是智能的了。而如果我们把一个智能的物体从结构上一直细分，当细分到一定程度，如每个通过细分得到的元素与其它元素差异很小时，那在这个集合中这些元素可以被认为不具备智能的意义，因为当每个元素变得一样时你显然不能说出谁更智慧一些或讨论是否都是智慧的。

一定条件下，智能物体也可以构成智能物体；

好比生物可以构成具有一定智慧的组织一样。

一定条件下，非智能物体与智能物体也可以构成智能物体。

如同生物与非生物可以组成生态系统。

备注：【生态系统】1936年Arthur Tansley提出，生态系统是指在一定的空间内生物成分和非生物成分通过物质循环和能量流动而互相作用、互相依存而构成的一个生态学功能单位。

4 广义智能集

4.1 智能元

定义 :

由一定数量的至少具有一个共同特征且其它特征互相差异不大的元素所构成的可以在总体特征上反应元素特征并能够通过某种机制作用于元素使得总体特征在一定程度上维持稳定的集合被称为智能元。

特性 :

元素特征可以有量的变化；
总体特征不固定，而是在某个范围内变动；
具有调节机制，可以通过调整元素特征，使总体特征维持稳定；

4.2 智能集

定义 :

由一个以上的，特征不能互相替代的智能元参与组成的集合，若该集合的元素之间存在着协同或抑制关系，且能够通过某种机制调节集合中的元素特征使得该集合的总体特征维持稳定，则该集合被称为一阶智能集。由一个以上的特征不能互相替代的一阶智能集参与组成的集合，若该集合的元素之间存在着协同或抑制关系，且能够通过某种机制调节集合中的元素特征使得该集合的总体特征维持稳定，则该集合被称为二阶智能集，而构成它的一阶智能集为其智能子集。同理会有三阶、四阶……n阶（n为正整数，下同）智能集和它们各自的智能子集，其中，在第（n + 1）阶的智能集中的最高阶智能子集的阶数为n。一阶智能集外，其它的智能集都是高阶智能集。

特性 :

元素不可相互替代，具有必要性、唯一性；
元素特征可以有量的变化；
总体特征不固定，而是在某个范围内变动；
具有调节机制，可以通过调整元素特征，使总体特征维持稳定；

4.3 基本方程

智能元定义方程 :

F(X) + I ∈ L；
| K(L) - M | ≤ N ;

说明：特征集L为元素集X通过F变换后的F(X)加上一个不定参量I；集合L通过K运算得到实践总体特征数值K(L)，使得K(L)与期望总体特征数值M的差的绝对值| K(L) - M |小于等于允许误差N。

智能集定义方程 :

L ⊆ O ;
x, y ∈ L & z = x∩y & z ≠ x & z ≠ y ；
| K(L) - M | ≤ N ;

说明：式一表示L为由目标体系内所有智能元、智能集构成的集合的一个子集；式二表示集合L中任意两个元素x、y的特征都不可互相替换；式三表示集合L通过K运算得到实践总体特征数值K(L)，使得K(L)与期望总体特征数值M的差的绝对值| K(L) - M |小于等于允许误差N。

5 基本实践

5.1 构建智能元实践

以下代码用以构建广义智能集中的智能元。

#! /usr/bin/python# Code segment 1: Import libraryimport numpy as npimport cv2import time# Code segment 2: ConfigureSCREEN_SIZE = (600, 800)DELAY_SIZE = 0.1EVOLUTION_SPEED = 8VARIATION_SPEED = 7# Code segment 3: F(X) + I = L ;def Func1(X):    F = X + np.array([EVOLUTION_SPEED] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), np.uint8)    I = np.array(np.random.randint(0, VARIATION_SPEED, size=(SCREEN_SIZE[0] * SCREEN_SIZE[1])), dtype=np.uint8)    L = F + I    return L# Code segment 4: |K(L) - M| <= N ;def Func2(L, M = 128, N = 16):    while True:        t = L.mean() - M        if abs(t) < N:            # Print data            print 'D-value -> abs(t): ', abs(t)            return L        else:            SS = int(N * 0.618)            L += [SS, -SS][t > 0]# Code segment 5: main(), to call some modules and print messagesdef main():    X = np.array([128,] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), np.uint8)    while True:        time.sleep(DELAY_SIZE)        L = Func1(X)        O = Func2(L)        X = O        # Print data        print '-------------------------------'        print 'Element array:'        print O.dtype, O.shape        print O        print '-------------------------------'        print '===============================\n'        img = np.zeros((SCREEN_SIZE[0], SCREEN_SIZE[1], 3), dtype=np.uint8)        img[:,:,0] = O.reshape((SCREEN_SIZE[0], SCREEN_SIZE[1]))        img[:,:,1] = O.reshape((SCREEN_SIZE[0], SCREEN_SIZE[1]))        cv2.imshow('Intelligence Element Simulation...', img)        KEY = cv2.waitKey(1) & 0xFF        if 27 == KEY: break        elif 32 == KEY: cv2.waitKey(0)    cv2.destroyAllWindows()if __name__ == '__main__':    main()# End of code

代码说明

Code segment 1:

# Code segment 1: Import libraryimport numpy as npimport cv2import time

引入numpy数学处理库、opencv的python库cv2和time模块，在运行该程序时需要确保系统已经安装了numpy和python-opencv。

Code segment 2:

# Code segment 2: ConfigureSCREEN_SIZE = (600, 800)DELAY_SIZE = 0.1EVOLUTION_SPEED = 8VARIATION_SPEED = 7

设置一些全局常量，SCREEN_SIZE表示视频显示尺寸，DELAY_SIZE表示循环延时（单位s），EVOLUTION_SPEED表示进步速度（体现在Func1(X)中），VARIATION_SPEED表示变异速度（体现在Func1(X)）。

Code segment 3:

# Code segment 3: F(X) + I = L ;def Func1(X):    F = X + np.array([EVOLUTION_SPEED] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), np.uint8)    I = np.array(np.random.randint(0, VARIATION_SPEED, size=(SCREEN_SIZE[0] * SCREEN_SIZE[1])), dtype=np.uint8)    L = F + I    return L

Func1(X)函数用以实现公式中的F(X) + I = L，其中” F = X + np.array([EVOLUTION_SPEED] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), np.uint8) “表示为集合（这里用矩阵表示）中的某个元素添加一个常数用以构成公式中的 F(X) 运算，其中” I = np.array(np.random.randint(0, VARIATION_SPEED, size=(SCREEN_SIZE[0] * SCREEN_SIZE[1])), dtype=np.uint8) “表示为公式中 I 的得到方法（取一个元素在0到7之间的随机矩阵，元素数量与 X 相同），最好得到 L = F + I 并输出。

Code segment 4:

# Code segment 4: |K(L) - M| <= N ;def Func2(L, M = 128, N = 16):    while True:        t = L.mean() - M        if abs(t) < N:            # Print data            print 'D-value -> abs(t): ', abs(t)            return L        else:            SS = int(N * 0.618)            L += [SS, -SS][t > 0]

Func2(L, M=128, N=16)用以实现公式中的|K(L) - M| <= N，其中参数L、M、N分别对应公式中的L、M、N。其中 ” t = L.mean() - M “用以得到L的平均值并用这个平均值减去M，这里的K(L)就指的是L的平均值，通过while循环进行矫正使得 t 的绝对值小于N，然后像屏幕打印此时t的绝对值 abs(t) 并输出 L 同时结束该段程序。

Code segment 5:

# Code segment 5: main(), to call some modules and print messagesdef main():    X = np.array([128,] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), np.uint8)    while True:        time.sleep(DELAY_SIZE)        L = Func1(X)        O = Func2(L)        X = O        # Print data        print '-------------------------------'        print 'Element array:'        print O.dtype, O.shape        print O        print '-------------------------------'        print '===============================\n'        img = np.zeros((SCREEN_SIZE[0], SCREEN_SIZE[1], 3), dtype=np.uint8)        img[:,:,0] = O.reshape((SCREEN_SIZE[0], SCREEN_SIZE[1]))        img[:,:,1] = O.reshape((SCREEN_SIZE[0], SCREEN_SIZE[1]))        cv2.imshow('Intelligence Element Simulation...', img)        KEY = cv2.waitKey(1) & 0xFF        if 27 == KEY: break        elif 32 == KEY: cv2.waitKey(0)    cv2.destroyAllWindows()

main()调用了Func1()和Func2()用来实现这个公式的运算并使之循环，同时也打印出相关信息和输出视频图像。

5.2 通过智能元构建智能集实践

以下代码构建广义智能集中的智能集。

#! /usr/bin/python# Code segment 1: import libraryimport numpy as npimport cv2import timeimport random# Code segment 2: ConfigureSCREEN_SIZE = (400, 400)DELAY_SIZE = 0.1EVOLUTION_SPEED = 8VARIATION_SPEED = 7# Code segment 3: IntelligenceElement_Adef FuncA_1(X):    F = X + np.array([EVOLUTION_SPEED] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), np.uint8)    I = np.array(np.random.randint(0, VARIATION_SPEED, size=(SCREEN_SIZE[0] * SCREEN_SIZE[1])), dtype=np.uint8)    L = F + I    return Ldef FuncA_2(L, M=128, N=16):    while True:        t = L.mean() - M        if abs(t) < N:            return t, L        else:            SS = int(N * 0.618)            L += [SS, -SS][t > 0]def FuncA(X, M=128):    L = FuncA_1(X)    T, O = FuncA_2(L, M)    return T, O# Code segment 4: IntelligenceElement_Bdef FuncB_1(X):    F = X + np.array([EVOLUTION_SPEED] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), np.uint8)    I = np.array(np.random.randint(0, VARIATION_SPEED, size=(SCREEN_SIZE[0] * SCREEN_SIZE[1])), dtype=np.uint8)    L = F + I    return Ldef FuncB_2(L, M=128, N=16):    while True:        t = L.mean() - M        if abs(t) < N:            return t, L        else:            SS = int(N * 0.618)            L += [SS, -SS][t > 0]def FuncB(X, M=128):    L = FuncB_1(X)    T, O = FuncB_2(L, M)    return T, O# Code segment 5: IntelligenceSetdef main():    X_A = np.array([128,] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), dtype=np.uint8)    X_B = np.array([128,] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), dtype=np.uint8)    M_A = M_B = 128    LIMIT = 0.618 * 32    while True:        for i in range(64):            time.sleep(DELAY_SIZE)            T_A, X_A = FuncA(X_A, M_A)            T_B, X_B = FuncB(X_B, M_B)            T = T_A + T_B            if abs(T) <= LIMIT:                # Print data                print 'T:', T                print "T_A: %f, T_B: %f" % (T_A,T_B)                print '--------------------------------'                print "M_A: %f, M_B: %f" % (M_A,M_B)                print '--------------------------------'                print 'Set array:'                print X_A                print X_B                print '--------------------------------'                print '================================\n'                break            print 'The abs(T) more than LIMIT'            if T > 0:                if T_A > 0: M_A += random.random()                if T_B > 0: M_B += random.random()            else:                if T_A < 0: M_A -= random.random()                if T_B < 0: M_B -= random.random()        else:            print '\n================================\n'            print 'END OF WORLD'            print '\n================================\n'            X_A = np.array([128,] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), dtype=np.uint8)            X_B = np.array([128,] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), dtype=np.uint8)        # Show data        img = np.zeros((SCREEN_SIZE[0], SCREEN_SIZE[1] * 3, 3), dtype=np.uint8)        OA = X_A.reshape((SCREEN_SIZE[0], SCREEN_SIZE[1]))        OB = X_B.reshape((SCREEN_SIZE[0], SCREEN_SIZE[1]))        img[:,:SCREEN_SIZE[1],0] = OA        img[:,SCREEN_SIZE[1] * 2:,1] = OB        img[:,SCREEN_SIZE[1]:SCREEN_SIZE[1] * 2,0] = OA        img[:,SCREEN_SIZE[1]:SCREEN_SIZE[1] * 2,1] = OB        cv2.imshow('Intelligence Set Simulation...', img)        KEY = cv2.waitKey(1) & 0xFF        if 27 == KEY: break        elif 32 == KEY: cv2.waitKey(0)    cv2.destroyAllWindows()if __name__ == '__main__':    main()# End of code

代码说明

Code segment 1-4：

其中的FuncA_1(X)、FuncA_2(L, M=128, N=16)、FuncB_1(X)、FuncB_2(zL, M=128, N=16)都是前面用于构建智能元的函数，值得注意的是除却之前的功能，在这里FuncA_2(L, M=128, N=16)和FuncB_2(L, M=128, N=16)还多反馈一个参数——差值 t，FuncA与FuncB用以整合前面的FuncA_1(X)、FuncA_2(L, M=128, N=16)、FuncB_1(X)、FuncB_2(zL, M=128, N=16)，有点类似前面的代码中的main函数的功能。

Code segment 5：

    X_A = np.array([128,] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), dtype=np.uint8)    X_B = np.array([128,] * (SCREEN_SIZE[0] * SCREEN_SIZE[1]), dtype=np.uint8)    M_A = M_B = 128    LIMIT = 0.618 * 32

初始化两个不同的集合X_A、X_B，两个智能元定义公式中的M_A, M_B，LIMIT相当于智能集定义公式中的N。

    while True:        for i in range(64):            time.sleep(DELAY_SIZE)            T_A, X_A = FuncA(X_A, M_A)            T_B, X_B = FuncB(X_B, M_B)            T = T_A + T_B            if abs(T) <= LIMIT:                # Print data                print 'T:', T                print "T_A: %f, T_B: %f" % (T_A,T_B)                print '--------------------------------'                print "M_A: %f, M_B: %f" % (M_A,M_B)                print '--------------------------------'                print 'Set array:'                print X_A                print X_B                print '--------------------------------'                print '================================\n'                break            print 'The abs(T) more than LIMIT'            if T > 0:                if T_A > 0: M_A += random.random()                if T_B > 0: M_B += random.random()            else:                if T_A < 0: M_A -= random.random()                if T_B < 0: M_B -= random.random()

相当于智能集定义公式中的 | K(L) - M | < N 用以修正参数M_A、 M_B，起到反馈的作用。

6 理论延伸与其它设想

人类参与组件了一个更高阶的智能集

由人类参与的生态系统（以往的生态系统都不怎么考虑与人类的联系）可以当做一个高阶智能集。

人脑的思维的形成离不开身体

人的大脑作为人的肉体的一个智能子集会受到其所在的集合（肉体）的反馈，从而进行调整。

人类的个体可能无法主动地避免做出对于自身利益非纯理性（或非最优）的行为

主要由于由人类个体参与的更高阶的智能集会为了维持整体稳定而调节个体，使个体行为偏移对自己的最有利的行为。而一旦有个体突破这一点则有可能会改变该智能集的特征。

7 结论

广义智能集提出了关于智能的数理意义上的定义，论文也给出了相关实践的Demo。

总的来说广义智能集的理论的思路还是比较清晰的，只不过我现在不打算直接去证明这个理论的科学性。实质上这篇论文还没有完整的反应我的思想，或许下一篇论文或其它文体的著作就会比较完整的描述我的想法。

总而言之，广义智能集的研究算是我这些年学习自然科学和计算机科学走上正轨的一个标志吧，希望在今后的道路中依然能够坚持。

1 0