feekood的基础知识--数据分析函数

于 2015-02-27 20:32:03 发布
阅读量1.6k 收藏
点赞数
分类专栏： feekood--API
feekood的基础知识--数据分析函数 
数据分析函数: :>    
概述：定义蕴含关系式
参数
P1(n1,n2…):>P2
示例     
//定义多个状态扩展行为
_add1(x) :> x+=1; //x自加1
_dec1(x) :> x-=1; //x自减1
_mul2(x) :> x*=2;//x自乘2
_mul10(x) :> x*=10;//x自乘10
_dev2(x) :> x=int(x/2);//x自除2
//定义初始条件
m=2;
//利用状态扩展行为搜索到达结果的步骤
result=target
(
	m, //脚本值
	value==500,//达到的目标
	value~==500,//启发搜索的表达式，越接近1的节点越先被扩展(提高搜索速度)
	{"_add1","_dec1","_mul10","_mul2","_dev2"},//支持的行为
	10000//搜索状态最大数量
);
print(result);
//打印{  M*=2;  M+=1;  M*=10;  M*=10;};
数据分析函数: ANNCREATE    
概述：建立人工神经网络节点
神经网络训练类型
BP:反向回馈训练方法
RBP:向前回馈训练方法
GA:遗传进化训练方法
DR:线性数据训练方法
节点激活函数类型
BSIG:S型激活函数(范围0~1)
ELT:伪S型激活函数(范围0~1)
ELTS:伪S型激活函数(范围-1~1)
LIM:梯度激活函数(范围0~1)
LIN:线性激活函数(范围0~1)
LOG:指数激活函数(范围0~1)
SIG:S型激活函数(范围-1~1)
SIN:三角曲线激活函数(范围0~1)
Tanh:反三角曲线激活函数(范围0~1)
参数
AnnCreate(annData)
annData:神经网络内置对象集合
返回:null
功能:定义一个神经网络模型
示例     
annModel=
{
	Name:"x1";//模型名称
	Type:"BP";//神经网络类型
	LearningRate:0.1;//神经网络学习速率
	Momentum:0;//神经网络学习动量
	Stage:10;//迭代次数
	Times:10000;//每次迭代的训练次数
	Error:0;// 每次迭代统计误差值
	Error:->
	{
		print(owner.error);
	};
	InputCount:2; // 输入节点数量
	OutputCount:1; // 输出节点数量
	Layers:
	{
		{Function:"BSIG", Count:2, Alpha:2}; // 输入层
		{Function:"BSIG", Count:2, Alpha:2}; // 隐藏层
		{Function:"BSIG", Count:1, Alpha:2}; // 输出层
	};
};
// 创建神经网络
AnnCreate(annModel);
// 创建训练数据
input={{0,0},{0,1},{1,0},{1,1}};
output={0,1,1,0};
// 训练数据
AnnTrain(annModel,input,output);
// 识别数据
ideal=AnnRun(annModel,input);
Print("识别结果");
Print(ideal);
// 实际结果
Print("实际结果");
Print(output);
数据分析函数: ANNRUN    
概述：运行神经网络
输入值input={{a1,a2,a3},{b1,b2,b3},{c1,c2,c3},{d1,d2,d3},{e1,e2,e3}}
a1,a2,a3为一个样本数据
input有3个数据维度,有a~e 5个数据样本
神经网络将多个数据样本计算出多个输出值
参数
AnnRun(annData, value)
annData:神经网络内置对象集合
value:输入值[数值集合]
返回:神经网络计算输出值
功能:识别，匹配，预测现有状态数据
示例     
annModel=
{
	Name:"x1";//模型名称
	Type:"BP";//神经网络类型
	LearningRate:0.1;//神经网络学习速率
	Momentum:0;//神经网络学习动量
	Stage:10;//迭代次数
	Times:10000;//每次迭代的训练次数
	Error:0;// 每次迭代统计误差值
	Error:->
	{
		print(owner.error);
	};
	InputCount:2; // 输入节点数量
	OutputCount:1; // 输出节点数量
	Layers:
	{
		{Function:"BSIG", Count:2, Alpha:2}; // 输入层
		{Function:"BSIG", Count:2, Alpha:2}; // 隐藏层
		{Function:"BSIG", Count:1, Alpha:2}; // 输出层
	};
};
// 创建神经网络
AnnCreate(annModel);
// 创建训练数据
input={{0,0},{0,1},{1,0},{1,1}};
output={0,1,1,0};
// 训练数据
AnnTrain(annModel,input,output);
// 识别数据
ideal=AnnRun(annModel,input);
Print("识别结果");
Print(ideal);
// 实际结果
Print("实际结果");
Print(output);
数据分析函数: ANNTRAIN    
概述：训练神经网络
输入值input={{a1,a2,a3},{b1,b2,b3},{c1,c2,c3},{d1,d2,d3},{e1,e2,e3}}
a1,a2,a3为一个样本数据
input有3个数据维度,有a~e 5个数据样本
输出值 output={a,b,c,d,e}
output有一个数据维度，5个数据样本
参数
AnnTrain(annModel,input,output)
annModel:神经网络模型集合
input:输入数据[数值集合]
output:输出数据[数值集合]
返回:null
功能:训练神经网络模型，利用输入值和输出值训练其拟合函数
示例     
annModel=
{
	Name:"x1";//模型名称
	Type:"BP";//神经网络类型
	LearningRate:0.1;//神经网络学习速率
	Momentum:0;//神经网络学习动量
	Stage:10;//迭代次数
	Times:10000;//每次迭代的训练次数
	Error:0;// 每次迭代统计误差值
	Error:->
	{
		print(owner.error);
	};
	InputCount:2; // 输入节点数量
	OutputCount:1; // 输出节点数量
	Layers:
	{
		{Function:"BSIG", Count:2, Alpha:2}; // 输入层
		{Function:"BSIG", Count:2, Alpha:2}; // 隐藏层
		{Function:"BSIG", Count:1, Alpha:2}; // 输出层
	};
};
// 创建神经网络
AnnCreate(annModel);
// 创建训练数据
input={{0,0},{0,1},{1,0},{1,1}};
output={0,1,1,0};
// 训练数据
AnnTrain(annModel,input,output);
// 识别数据
ideal=AnnRun(annModel,input);
Print("识别结果");
Print(ideal);
// 实际结果
Print("实际结果");
Print(output);
数据分析函数: CHECK    
概述：检查事实的存在的概率值
参数
Check(word1,word2,...wordn)
word1~n:对象名称1~n
返回:是否存在事实(包括推理出来的事实)
示例     
fact({"猫","狗","牛","马","猪"},"是","哺乳动物");
fact({"蝴蝶","蚂蚁","蜻蜓"},"是","昆虫");
fact("哺乳动物","有","骨头");
fact({"昆虫","哺乳动物"},"是","动物");
fact("动物","是","生物");
fact("生物","会","死");
fact(?x, "是", ?y) && fact(?y, "会", ?z) |-> fact(?x, "会", ?z);
fact(?x, "是", ?y) && fact(?y, "有", ?z) |-> fact(?x, "有", ?z);
print(check("蚂蚁","是","哺乳动物"));
print(check("狗","有","骨头"));
print(check("蝴蝶","会","死"));
数据分析函数: FACT    
概述：定义事实
参数：fact(word1,word2,...wordn)
word1~n:事实[字符串]
返回:null
功能:将事实放入智能数据库存储
fact(?variable,word1,word2,...wordn)
variable?:未知变量[变量名?]
word1~n:事实[字符串]
示例     
//定义事实
fact("小明","爱","小红");//定义事实(小明爱小红)
fact("小张","爱","小李");//定义事实(小张爱小李)
fact("小红","爱","小李");//定义事实(小红爱小李)
fact("小李","爱","小红");//定义事实(小李爱小红)
fact("小王","爱","小美");//定义事实(小王爱小美)
fact("小美","爱","小张");//定义事实(小美爱小张)
fact("小艳","爱","小孙");//定义事实(小艳爱小孙)
fact("小美","爱","小孙");//定义事实(小美爱小孙)
fact(?x,"爱","小孙");
Print("爱小孙的有"+x);
数据分析函数: RUNAF    
概述：运行激活函数
神经网络激活函数有
BSIG,SIG,ELT,ELTS,LIM,LIN,LOG,SIN,LOG,SIN,TANH
参数
RunAf(func,value)
func:神经网络激活函数名称[字符串]
value:数值
返回:计算激活函数的相应数值的导数
示例     
Print(RunAf("BSIG",0.5));//打印0.4621
数据分析函数: RUNAFD    
概述：运行激活函数求导
神经网络激活函数有
BSIG,SIG,ELT,ELTS,LIM,LIN,LOG,SIN,LOG,SIN,TANH
参数
RunAfd(func,value)
func:神经网络激活函数名称[字符串]
value:数值
返回:计算激活函数的相应数值的导数
示例     
Print(RunAfd("BSIG",100));//打印-9999
数据分析函数: TARGET    
概述：定义逻辑关系式
taget的目标必须是定义条件能达到的，否则返回空
参数
Target(value,targetExpr,inspriteExpr,actions,step,keyExpr)
value:需要搜索的变量[值]
targetExpr:目标条件表达式[表达式]
inspriteExpr:启发式搜索表达式，越接近1的节点会优先扩展查找
actions:允许的动作[字符串集合]
step:搜索状态最大数量[正整型]
keyExpr:状态识别表达式[表达式]
返回:达到目标的执行表达式集合
功能:达到或接近目标的步骤
示例     
// 简单搜索脚本案例
//定义多个状态扩展行为
_add1(x) :> x+=1; //x自加1
_dec1(x) :> x-=1; //x自减1
_mul2(x) :> x*=2;//x自乘2
_mul10(x) :> x*=10;//x自乘10
_dev2(x) :> x=int(x/2);//x自除2
//定义初始条件
m=2;

//利用状态扩展行为搜索到达结果的步骤
result=target
(
	m, //脚本值
	value==500,//达到的目标
	value~==500,//启发搜索的表达式，越接近1的节点越先被扩展(提高搜索速度)
	{"_add1","_dec1","_mul10","_mul2","_dev2"},//支持的行为
	10000,//搜索状态最大数量
    value//状态识别表达式
);
print(result);
//打印{  M*=2;  M+=1;  M*=10;  M*=10;};
//================================================================================
// 寻路搜索,复杂搜索脚本案例
m={
    {0,0,0,0,1},
    {0,1,1,2,1},
    {1,1,0,0,1},
    {0,0,0,1,0},
    {0,0,1,0,0}};
human={x:0,y:4,step:0};
moveUp(h):>case(any(MtxGet(m,h.x,h.y-1)=={0,2}),{h.y-=1,h.step+=1}::h);
moveDown(h):>case(any(MtxGet(m,h.x,h.y+1)=={0,2}),{h.y+=1,h.step+=1}::h);
moveLeft(h):>case(any(MtxGet(m,h.x-1,h.y)=={0,2}),{h.x-=1,h.step+=1}::h);
moveRight(h):>case(any(MtxGet(m,h.x+1,h.y)=={0,2}),{h.x+=1,h.step+=1}::h);

result=target
(
    human, //脚本值
    MtxGet(value.map,value.x,value.y)==2,//达到的目标表达式
    value.step~==0,//启发搜索的表达式，越接近1的节点越先被扩展(提高搜索速度)
    {"moveUp","moveDown","moveLeft","moveRight"},//支持的行为
    10000,//搜索状态最大数量
    {value.x,value.y}//状态识别表达式
);

print(result);
foreach(0...(size(result)-1),
{
    run(result->value);
    print(""+human.x +" "+human.y);
});

数据分析函数: |->    
概述：定义关联关系运行式
参数
concept1 |-> concept2
concept1:搜索事实
concept1:执行事实
返回:null
功能:定义推论规则
示例     
fact("小明","爱","小红");//定义事实(小明爱小红)
fact("小张","爱","小李");//定义事实(小张爱小李)
fact("小红","爱","小李");//定义事实(小红爱小李)
fact("小李","爱","小红");//定义事实(小李爱小红)
fact("小王","爱","小美");//定义事实(小王爱小美)
fact("小美","爱","小张");//定义事实(小美爱小张)
fact("小艳","爱","小孙");//定义事实(小艳爱小孙)
fact("小美","爱","小孙");//定义事实(小美爱小孙)
//定义事实规则
//恋人定义为一个人爱另一个人，另一个人也爱他
fact(?x,"爱",?y)&&fact(?y,"爱",?x) |-> fact(?x,?y,"是恋人");

//搜索m,n
fact(?m,?n,"是恋人");
Print(""+m+"和"+n+"是恋人");



MY_WORD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值