关于计算机数据关联的一点思考 - 第2页 - CPU与编译器 - Chinaunix

cjaizss 发表于 2008-04-26 13:10

量子计算机应该是物理级别的概念，而不是体系结构级别的概念吧。

nicolas.shen 发表于 2008-04-26 13:20

嗯，更正一下，量子效应是量子（电子，光子等）的运动效应，比如说一个量子，既可以处于“1”态，又可以处于“0”态，比如说50% 处于“1”态，50%处于“0”态，但是如果你探测他，就破坏了他的状态，探测的结果只能有一个。量子计算机目前是利用量子超导效应来解决电子传输的极限问题，（发热，噪声，衰减等），还没有到量子信息编码的应用阶段。

jamesr 发表于 2008-04-26 14:27

Wind-Son 发表于 2008-04-26 22:51

原帖由 nicolas.shen 于 2008-4-26 13:20 发表 http://linux.chinaunix.net/bbs/images/common/back.gif
嗯，更正一下，量子效应是量子（电子，光子等）的运动效应，比如说一个量子，既可以处于“1”态，又可以处于“0”态，比如说50% 处于“1”态，50%处于“0”态，但是如果你探测他，就破坏了他的状态，探测的结果 ...

我理解的量子效应就是“测不准”，具体说在某个具体的时刻和具体的空间状态是不可测的，你只能有一个平均的、概率上的统计结果。“测量”本身是值得怀疑的，因为测量内在地包含了测量者本身的因素，不再是单纯的结果。

cjaizss 发表于 2008-04-27 14:29

原帖由 gvim 于 2008-4-25 09:41 发表 http://linux.chinaunix.net/bbs/images/common/back.gif
现在所谓的智能，一般现阶段的处理方法，是在大规模经验数据上做的一些分析，然后模糊匹配，得到需要处理的动作。更一般来说，使用数学手段做出的智能。
比如说红色，我们人知道什么是红色，但是"计算机"或者其 ...
数学的手段是给抽象的机器建模，然而，对于模糊匹配，都要涉及到一些变换以及滤波之类，比如傅立叶变换以及建立在傅立叶变换基础上的一些变换，乃至普通的一阶求导、二阶求导，这些都可以缩为数字处理的形式，而不一定要用离散。离散的处理不是数字计算机做的事情，而是模拟计算机处理的范畴，而对模拟计算机我是一窍不通。但是至少在我看来，如果真要做一个智能计算机硬件，这些基础的变换形式是少不了的。比方，对色彩的辨别其实可以基于带通滤波。

yuanchengjun 发表于 2008-04-27 14:56

1，人工神经网络(ANN)
应该还做不到能够“理解”，只是模拟神经计算过程。
可以用于图像识别。

2，遗传算法(GA)
这个求近似解，在某些情况下很合适，和智能没多少关系。
例如，《可计算性和计算复杂性》里面的旅行家问题：
共n个城市，已知任意2个城市之间的距离，从一个城市出发每个城市到过并且只到过一次，最后回到出发城市。使路程最短。
当n = 100的时候。首先是可以求解的；其次，复杂度很高。np难解
GA 就可以给出解，但可能不是最优解。

3，人工智能
定义、公理是已有的，无法证明的，只能记忆（存储？）；定理可以证明的。
外国已经有能把一本书的定理证明的了。
有兴趣可以看一下w3c的owl问题。

4，一定是分工的
当作了人工智能，对下层实现绝对只是提出需求了。
一定分工的，不会是一个人从头到脚都会，可能某块东西做一辈子时间都不够。
好比http之于网卡。

顺便贴一下最近写的份推理源码。
是我向朋友解释，C++可能可以这么干用来推理。
这里，male和female这两个概念，不能同时具有。
对这个xml，自己写的c++类源码。
可能一些处理不当，比如：一致性检查对象释放问题；这里只是说明可能可以用C++这样来做来检查male和female不能同时是这两个概念的方法。

#ifndef OWL_H_
#define OWL_H_

#include <stdio.h>

class Knowledge;
class Consistent;
class disjointWithException;

// 如果 disjointWith 导致不一致，抛出这个异常。

class disjointWithException
{
private:
char msg[128];

public:
const char * getMessage() const
{
   return msg;
}

disjointWithException(const char *obj, const char *from, const char *to)
{
   sprintf(msg, "Object of '%s', '%s' disjointWith '%s'", obj, from, to);
}

virtual ~disjointWithException()
{
}
};

// Knowledge 一致性检查接口

class Consistent
{
public:
virtual void check(Knowledge *nlg) = 0;

Consistent()
{
}

virtual ~Consistent()
{
}
};

// 知识

class Knowledge
{
// 需要被检查n个一致性，假设最多100个。

Consistent *Consistents[100];
int count;

protected:
void addConsistent(Consistent *c)
{
   Consistents[count++] = c;
}

public:
Knowledge()
{
   count = 0;
}

void checkConsistent()
{
   int total = count;
   while (total)
         Consistents[--total]->check(this);
}

void check()
{
   // 检查一致性，

   checkConsistent();
}

virtual ~Knowledge()
{
   while(count)
         delete Consistents[--count];
}
};

// Knowledge一致性检查的一个实现

template<typename _TypeOne, typename _TypeOther> class disjointWith : public Consistent
{
public:
// 用 C++ RTTI 特性检查不能同时是 _TypeOne 和 _TypeOther 这两种类型。

virtual void check(Knowledge *nlg)
{
   _TypeOne *from = dynamic_cast<_TypeOne *>(nlg);
   if (0 == from)
         return;

   _TypeOther *to = dynamic_cast<_TypeOther *>(nlg);
   if (0 == from)
         return;

   throw disjointWithException(typeid(*nlg).name(), typeid(_TypeOne).name(), typeid(_TypeOther).name());
}

disjointWith()
{
}

virtual ~disjointWith()
{
}
};

#endif /*OWL_H_*/

#ifndef FAMILY_H_
#define FAMILY_H_

#include "owl.h"

class people;
class female;
class male;
class father;
class mother;
class Marry;
class impossible;
class fufu;

// people ÊÇÒ»ÖÖ Knowledge

class people : public virtual Knowledge
{
public:
people()
{
}

virtual ~people()
{
}
};

// male ÊÇÒ»ÖÖ Knowledge

class male : public virtual Knowledge
{
public:
male()
{
   addConsistent(new disjointWith<female, male>);
}

virtual ~male()
{
}
};

// female ÊÇÒ»ÖÖ Knowledge

class female : public virtual Knowledge
{
public:

female()
{
   addConsistent(new disjointWith<male, female>);
}

virtual ~female()
{
}
};

class father : public male, public people
{
public:
father()
{
}

virtual ~father()
{
}
};

class mother : public people, public female
{
public:
mother()
{
}

virtual ~mother()
{
}
};

class impossible : public father, public mother
{
public:
impossible()
{
}

virtual ~impossible()
{
}
};

class fufu : public impossible
{
public:
fufu()
{
   check();
}

virtual ~fufu()
{
}
};

class Marry : public father
{
public:
Marry()
{
   check();
}

virtual ~Marry()
{
}
};

#endif /*FAMILY_H_*/

#include <iostream>

#include "family.h"

using namespace std;

int main()
{

try
{
   Marry objMarry;
   fufu objFufu;
}
catch (const disjointWithException &e)
{
   cout << e.getMessage() << endl;
}

return 0;
}

[ 本帖最后由 yuanchengjun 于 2008-4-27 15:19 编辑 ]

yuanchengjun 发表于 2008-04-27 15:21

实例只有Marry和fufu，其他都只表示一个概念。

<?xml version="1.0"?>
<rdf:RDF
xmlns="http://www.owl-ontologies.com/Ontology1208675847.owl#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:owl="http://www.w3.org/2002/07/owl#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xml:base="http://www.owl-ontologies.com/Ontology1208675847.owl">
<owl:Ontology rdf:about=""/>

<owl:Class rdf:ID="female">
<owl:disjointWith>
<owl:Class rdf:ID="male"/>
</owl:disjointWith>
</owl:Class>

<owl:Class rdf:about="#male">
<owl:disjointWith rdf:resource="#female"/>
</owl:Class>

<owl:Class rdf:ID="father">
<rdfs:subClassOf rdf:resource="#male"/>
<rdfs:subClassOf>
<owl:Class rdf:ID="people"/>
</rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:ID="mother">
<rdfs:subClassOf rdf:resource="#female"/>
<rdfs:subClassOf rdf:resource="#people"/>
</owl:Class>

<owl:Class rdf:ID="impossible">
<rdfs:subClassOf rdf:resource="#mother"/>
<rdfs:subClassOf rdf:resource="#father"/>
<rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
</owl:Class>

<impossible rdf:ID="fufu"/>
<father rdf:ID="Mary"/>

</rdf:RDF>



[ 本帖最后由 yuanchengjun 于 2008-4-27 15:27 编辑 ]

Wind-Son 发表于 2008-04-30 00:03

我始终认为严格意义上说，“人工”和“智能”两个词是矛盾的

cjaizss 发表于 2008-04-30 01:41

回复 #18 Wind-Son 的帖子

绝对的智能是上天造就，人只有能力去模拟智能的一些方面而已。

页: 1 [2]

Chinaunix's Archiver

实例只有Marry和fufu，其他都只表示一个概念。

回复 #18 Wind-Son 的帖子