如何将程序算法转换为逻辑程序？

2019年7月20日 191次阅读

如何从程序描述中实现Prolog中的算法,以便最好地利用逻辑范例.

我有时会发现很难从算法的给定程序描述中编写一个prolog程序.我举一个下面一个尝试的具体例子.注意我有谓谓innerforloop或convergedloop的谓词.这似乎不对,很难检查我的实现是否与算法描述相符.此代码是否与描述相符？这些谓词有什么更好的名字？或者代码应该以不同的方式组织？

示例算法：训练感知器分类器.

Input: labelled training data in D homogeneous coordinates;
       learning rate n.
Output: weight vector W defining classifier ŷ = sign(w⃗ ⋅  x⃗).

w⃗ <- 0;
converged <- false;
While converged = false do
  converged <- true;
  for i = 1 to |D| do
    if yiw⃗⋅x⃗i <0
    then
      w⃗<- w⃗+n * yi * x⃗i;
      converged <-false
    end
  end
end

我的实施：

perceptron(Pos,Neg,classifier(W,0)):-
   Pos =[OneExample|_],
   length(OneExample,NumberOfFeatures),
   populate_list(0,NumberOfFeatures,Zerovector),
   maplist(myappend([1]),Pos,PosClass),
   maplist(myappend([-1]),Neg,NegClass),
   append(PosClass,NegClass,Examples),
   convergedloop(Examples,Zerovector,W).

convergedloop(Examples,Inputvector,OutputVector):-
  innerforloop(Examples,Inputvector,UpdateVector),
  check_converged(Examples,Inputvector,UpdateVector,OutputVector).

check_converged(_Examples,W1,W2,W2):-W1=W2.
check_converged(Examples,W1,W2,W3):-
  dif(W1,W2),
  convergedloop(Examples,W2,W3).

innerforloop([],W,W).
innerforloop(ExamplesWithClass,W1,WFin):-
  ExamplesWithClass =[One|Rest],
  update_weight(One,W1,W2),
  innerforloop(Rest,W2,WFin).

learning_rate(0.1).

update_weight(Example_with_class,W1,W2):-
  misclassified(W1,Example_with_class,true),
  learning_rate(N),
  append(Example,[Class|[]],Example_with_class),
  Scalar is N *Class,
  scalar_multiplication(Scalar,Example,ExampleScaled),
  vector_addition(W1,ExampleScaled,W2).

update_weight(Example_with_class,W,W):-
  misclassified(W,Example_with_class,false).

misclassified(W,Example_with_class,TrueFalse):-
  append(Example,[Class|[]],Example_with_class),
  dot_product(Example,W,Dot),
  multiply(Dot,Class,Value),
  (   Value =<0->TrueFalse=true;TrueFalse=false).

%%%background predicates
myappend(Y,X,Z):-
  append(X,Y,Z).

multiply(X,Y,Z):-
  Z is X*Y.

vector_addition(X,Y,Z):-
  maplist(my_plus,X,Y,Z).

dot_product(V1,V2,Dot):-
  maplist(multiply,V1,V2,VMul),
  sumlist(VMul,Dot).

scalar_multiplication(S,X,SX):-
  maplist(multiply(S),X,SX).

populate_list(Pop,Length,ListPoped):-
  length(List,Length),findall(X,(member(X,List),X=Pop),ListPoped).

%%%Data
linear_sep_data(Pos,Negs,All):-
All=[
    [1.5998426,0.52985437,1],
            [0.25065517,1.30425162,1],
            [0.76148911,0.60419602,1],
            [0.75591032,-0.78994764,1],
            [1.63605539,0.9225655,1],
            [2.70520379,0.93285704,1],
            [1.82870703,2.34804646,1],
            [-0.08549264,0.99868399,1],
            [0.44906531,0.90555838,1],
            [0.49966187,1.59299327,1],
            [1.00003726,-0.13822094,1],
            [1.67943676,1.25283262,1],
            [-1.00158649,2.73839505,1],
            [3.32539035,-0.39289509,1],
            [2.17885898,0.05984356,1],
            [1.85977529,0.76782626,1],
            [1.34470454,0.18312675,1],
            [0.5974872,0.1228956,1],
            [-1.52394333,-1.24558361,-1],
            [-2.48452861,-1.91070328,-1],
            [-1.04605257,-2.55270759,-1],
            [1.02370408,-1.67944911,-1],
            [-0.80492117,-1.49215482,-1],
            [-1.64954319,-3.41635041,-1],
            [-2.35543276,-0.37750433,-1],
            [-0.32384031,-2.08235145,-1],
            [-1.56576954,-1.22018985,-1],
            [-1.27853841,-1.28469686,-1],
            [-1.97696119,0.23717806,-1],
            [-1.78965834,-1.09026084,-1]],
findall(Instance,(member(InstanceC,All),append(Instance,[1|[]],InstanceC)),Pos),
findall(Instance,(member(InstanceC,All),append(Instance,[-1|[]],InstanceC)),Negs).

最佳答案 在Prolog中命名事物的关键见解是逻辑程序定义了实体之间的关系.理想情况下,谓词名称可以指示每个参数描述哪些实体.

因此,在这种情况下,像forloop或innerloop这样的名称对你来说是错误的：从像forloop这样的名称(或者更具可读性：for_loop),我们宁愿期待例如“for循环”是什么的语法描述,但肯定不是循环应该执行的实际计算.

命令式算法描述了一系列全局状态的破坏性修改.为了将命令式算法转换为声明性范式,我们改变了我们的观点,而是描述了状态之间的关系.

我们使用以下命名约定,这在许多程序中都很有用：S0表示初始状态. S1表示计算的一个步骤之后的状态. S2,S3等表示其他状态,最后,S表示最终状态.

现在考虑一下你引用的具体例子：

命令性术语中算法的本质是重复修改状态直到达到最终状态.在声明范式中描述这种状态转换序列的一种方法如下：

state0_state(S0, S) :-
     state_next(S0, S1),
     state0_state_(S0, S1, S).

state0_state_(S0, S, S) :-
     close_enough(S0, S).
state0_state_(S0, S1, S) :-
     not_close_enough(S0, S1),
     state0_state(S1, S).

其中state_next / 2,close_enough / 2和not_close_enough / 2必须由您提供.我将此作为练习.请注意,谓词state0_state / 2的命名方式是清楚每个参数表示的内容.通过一些思考,您可能会找到更具描述性的名称,例如training0_training / 2.

根据您的执行情况,我们观察到声明范式的一个有价值的优势：代码可以在所有方向上使用.这意味着您也可以发布最常见的查询：

?- state0_state(S0, S).

并且理想地获得这种关系中的状态.

命名谓词的另一个提示：避免命令.在声明范式中,命令毫无意义,因为许多谓词可以在多个方向上使用,而命令总是意味着单一方向.

点赞