Newsgroup: it.comp.programmare
Titolo: Aiuto in prolog

Ciao a tutti, sono una studentessa di Informatica e devo svolgere un
progetto in Prolog,
ossia devo creare un bias di linguaggio che mi permette di selezionare
dei patterns specifici che sono l'input di un altro programma Prolog
gia' creato. C'è qualche programmatore Prolog che puo' aiutarmi?


Cos'è un "bias di linguaggio"??

Massimo Soricetti ha scritto:

Il bias è una specie di template nel quale vengono definiti dei
vincoli ,se i pattern soddisfano il template vengono selezionati.Il mio
problema è quello di creare proprio questo bias in Prolog,sapendo gia'
quali sono i vincoli.Non ho molta dimestichezza col Prolog per questo
vorrei  un aiuto per capire come si potrebbe fare una cosa del genere
in questo linguaggio.

 in questo linguaggio.
Mi puoi fare qualche esempio di bias e di pattern? Da quanto lavori con 
il prolog?

Mi sto esercitando col Prolog da circa un mese, ma a dire la verita'
non è uno dei miei linguaggi preferiti,lo sto imparando per fare
l'esame.
Comunque ora ti spiego  in cosa consiste il mio progetto:
è il miglioramento di un modulo di Semantic Web Mining per il
Raffinamento di Ontologie.
Dato un file di testo in input con una serie di patterns frequenti
presenti nell'ontologia, ecco un esempio di pattern:
f([14,0.9333333333333334],pcvs([2,2],[6,3],5,2,3,3,[believes/2,is_a/2],pcv([vt('A',ro),
vt('B',tro)],pc(['ARM','BRN','IR','IRQ','IL','JOR','KWT','RL','OM','Q','SA','SYR','TR','UAE'],
c_MiddleEastCountry('A'),[believes('A','B'),is_a('B','MonotheisticReligion')])))).
in cui
[14,0.9333333333333334] rappresentano la frequenza assoluta e relativa
del concetto di riferimento;
[0,1],[0,0] individuano rispettivamente il predecessore logico e
ontologico del pattern frequente;
1, 1, 2, 2 indicano il numero progressivo del pattern, il livello di
granularità il numero dei passi di raffinamento e il numero di atomi
presenti nel pattern;
['believes/2'] è lista dei predicati con la relativa arità che
occorrono nel pattern;
[vt('A',ro),vt('B',tro)] è lista delle variabili utilizzate
nel pattern memorizzate con il rispettivo ruolo;
['UAE','TR','SYR','SA','Q','OM','RL','KWT','JOR','IL','IRQ','IR','BRN','ARM']
rappresenta la lista degli oggetti di riferimento che supportano il
pattern ovvero l'estensione;
c_MiddleEastCountry('A') è la chiave del pattern;
[believes('A','B')] è la lista dei predicati che rappresentano
l'intensione del pattern;
il modulo di Semantic Web Mining adesso procede in questo modo:
prende il primo pattern delle lista e lo inserisce come nodo in  un
grafo poi prende il secondo e lo insersce nel grafo e così via secondo
dei criteri.
Ora il miglioramento da fare sta nel fatto che non  deve inserire tutti
i pattern nel grafo ,ma dal file di testo deve selezionare dei pattern
che rispettano le caratteristiche di questo bias,
i vincoli da imporre sono: minimo livello di granularita',le variabili
devono essere vincolate ontologicamente.
Ho un esempio di bias di linguaggio che impone dei vincoli applicato
pero' ad un altro problema ecco:
lb_Load_LanguageBias :-
        leggiNomeFileLanguageBias(NomeFile),
        lb_Load_LanguageBias_(NomeFile),
        lb_Set_Key,
        lb_Read_Predicates,
        % vincoli
        lb_Read_Constraints,
        lb_Read_Left_Constraints,
        lb_Read_Right_Constraints,
        %
        lb_Set_Hierarchy,
        asserisciFiglioDi,
        readVerbosity,
        %lb_Set_MaxUntypedVar, non serve a niente!!!!
        %lb_Get_Parametri,
        !,
        lb_defaults,!.
lb_Load_LanguageBias_(NomeFile) :-
        open(NomeFile,read,Stream),
        repeat,
                read(Stream,Term),
                assert(languageBias(Term)),
        Term == end_of_file, % Loop back if not at end of file
        !,
        close(Stream).
lb_Set_Key :-
        retract(languageBias(key(X))),
        assert( languageBiasKey( X ) ).
lb_Get_Key( K ) :-
        languageBiasKey( K ).
lb_Get_Constraints(LAtom,MinOccur):-
        languageBias(pattern_constraint(LAtom,MinOccur)).
lb_Get_Constraints(LConstraints):-
        pattern_constraint(LConstraints).
lb_Read_Constraints :-
        setof([X,Y],languageBias(pattern_constraint(X,Y)),Z),
    assert(pattern_constraint(Z)),
    retract(languageBias(pattern_constraint(_,_))).
% se non sono definiti i vincoli
lb_Read_Constraints :- !.
% restituisce i vincoli sulla parte sinistra
lb_Get_Left_Constraints(LAtom,MinOccur):-
        languageBias(body_constraint(LAtom,MinOccur)).
lb_Get_Left_Constraints(LConstraints):-
        body_constraint(LConstraints).
% legge i vincoli sulla parte sinistra
lb_Read_Left_Constraints :-
        setof([X,Y],languageBias(body_constraint(X,Y)),Z),
    assert(body_constraint(Z)),
    retract(languageBias(body_constraint(_,_))).
% se non sono definiti i vincoli
lb_Read_Left_Constraints :- !.
% restituisce i vincoli sulla parte sinistra
lb_Get_Right_Constraints(LAtom,MinOccur):-
        languageBias(head_constraint(LAtom,MinOccur)).
lb_Get_Right_Constraints(RConstraints):-
        head_constraint(RConstraints).
% legge i vincoli sulla parte sinistra
lb_Read_Right_Constraints :-
        setof([X,Y],languageBias(head_constraint(X,Y)),Z),
    assert(head_constraint(Z)),
    retract(languageBias(head_constraint(_,_))).
% se non sono definiti i vincoli
lb_Read_Right_Constraints :- !.
lb_Read_Predicates :-
        setof(X,languageBias(lb_atom(X)),Y),
        lb_Read_Predicates_(Y,PredAdds),
        assert(languageBiasPredAdd(PredAdds)),
        retract(languageBias(lb_atom(_))).
lb_Read_Predicates_([],[]).
lb_Read_Predicates_([H|T],PredAdds) :-
     lb_Read_Predicates_(T,PredAdd1),
     lb_Read_Predicates__(H,Pred),
     PredAdds = [ Pred | PredAdd1 ].
%lb_Read_Predicates__(Pred,Pred).
% mantiene un lista dei predicati non spaziali per
% correggere il problema di max_no_untyped_vars
% NON SERVE PER IL MOMENTO
lb_Read_Predicates__(spa Pred,Pred) :-
        assert(languageSpatialRelation(Pred)).
lb_Read_Predicates__( Pred , Pred) :-
    Pred =.. [Rel|_] ,
    %Pred = Rel,
    (   languageNoSpatialRelation(Rel)
        ;
        assert(languageNoSpatialRelation(Rel))
    ),!.
lb_Read_Predicates__(Pred,Pred).
lb_Get_Predicate_List( PredAdds ):-
       languageBiasPredAdd(PredAdds).
lb_Get_SpatialRelation(Rel) :-
       call(languageSpatialRelation(Rel)).
lb_Get_No_SpatialRelation(Rel) :-
        Rel =.. [P|_],
    call(languageNoSpatialRelation(P)).
/****************************************************************
                lb_Get_Hierarchy
        legge i predicati hierarchy e li mette in una lista
****************************************************************/
lb_Set_Hierarchy :-
        setof(X,languageBias(trh(X)),Y),
        assert(languageBias(gerarchie(Y))).
lb_Get_Hierarchy( G ) :-
        languageBias(gerarchie(G)).
%---------------------------------------------------------------
leggiIs_aList( L ) :-
        languageBiasIs_aList( L ).
%********************************************************************
lb_defaults:-
        ( languageBias(max_no_untyped_vars( N1 )) ->
                assert(param__( n_max_vars_without_is_a , N1 ))
        ;
                assert(param__( n_max_vars_without_is_a , 1 ))
        ),
        % my new
        ( languageBias(max_rules_untyped_vars( N2 )) ->
                assert(param__( max_rules_untyped_vars , N2 ))
        ;
                assert(param__( max_rules_untyped_vars , 0 ))
        ),
        ( languageBias(param(max_best_rules , BR )) ->
               assert(param__( n_max_best_rules_is_a , BR ))
        ;
               assert(param__( n_max_best_rules_is_a , 100 ))
        ),
        ( languageBias(param( patterns_to_rules , YN )) ->
                assert(param__( generate_rules , YN ))
        ;
                assert(param__( generate_rules , yes ))
        ),
        ( languageBias(param( max_level , Max_Level )) ->
                assert(param__( max_level , Max_Level ))
        ;
                assert(param__( max_level , 3 ))
        ),
        ( languageBias(param( max_ref_steps , MLarg )) ->
                assert(param__( max_largeness , MLarg ))
        ;
                assert(param__( max_largeness , 5 ))
        ),
% new paramter 'filter_confident_one    '
        ( languageBias(param( filter_confident_one , YN2 )) ->
                assert(param__( filter_confident_one , YN2 ))
        ;
                assert(param__( filter_confident_one , no ))
        ),
%       new parameter 'show_xml_rules'
        ( languageBias(param( show_xml_rules , YN3 )) ->
                assert(param__( show_xml_rules , YN3 ))
        ;
                assert(param__( show_xml_rules , yes ))
        ),
%       new parameter 'gen_rules_method'
        ( languageBias(param( gen_rules_method , MN1 )) ->
                assert(param__( gen_rules_method , MN1 ))
        ;
                assert(param__( gen_rules_method , old_confidence ))
        ),
%       new parameter 'minimum_pattern_length'
        ( languageBias(param( minimum_pattern_length , MLL1 )) ->
                assert(param__( minimum_pattern_length , MLL1 ))
        ;
                assert(param__( minimum_pattern_length , 2 ))
        ),
%       new parameter 'minimum_rule_head_length'
/*      ( languageBias(param( minimum_rule_head_length , MLL1 )) ->
                assert(param__( minimum_rule_head_length , MLL1 ))
        ;
                assert(param__( minimum_rule_head_length , 10 ))
        ),
*/
        % new SCHEMA PARAMETER
        retractall(lb_Schema(_,_)),
        readMaxLargeness(MaxK),
        findMaxLevel(MaxLevel),
        retractall(minSup(_,_)),
        retractall(minConf(_,_)),
        asserisciMinSup(MaxLevel,1),
        asserisciMinConf(MaxLevel,1),
        retractall(verbose(_)),
        ( verbosity__( show_pruned_candidates_by_untypedness  , no) ->
                true
        ;
                assert(verbose(prunedIsA))
        ),
        ( verbosity__( show_pruned_candidates_by_theta_subsumption  ,
no ) ->
                true
        ;
                assert(verbose(prunedInfrequent))
        ),
        ( verbosity__(show_pruned_candidates_by_renaming , no ) ->
                true
        ;
                assert(verbose(prunedRidenomination))
        ),
        ( verbosity__(show_pruned_candidates_by_inheritance , no ) ->
                true
        ;
                assert(verbose(prunedInfrequentAncestor))
        ),
        ( verbosity__( show_rules , no ) ->
                true
        ;
                assert(verbose(showRules))
        ),
        ( verbosity__(show_infrequent_patterns , no ) ->
                true
        ;
                assert(verbose(showInfrequentPatterns))
        ),
        ( verbosity__(show_frequent_patterns , no ) ->
                true
        ;
                assert(verbose(showFrequentPatterns))
        ),
        ( verbosity__( show_candidates , no ) ->
                true
        ;
                assert(verbose(showCandidates))
        )
        .
asserisciMinSup( Max , L ) :-
  ( L =< Max ->
        (
                ( languageBias(min_sup( L , MS )) ->
                        assert(minSup(L,MS))
                ;
                        assert(minSup(L,0.5))
                ),
                LP1 is L+1,
                asserisciMinSup( Max , LP1 )
        )
  ;
        true
  ),
  retractall(languageBias)
  .
asserisciMinConf( Max , L ) :-
  (L =< Max ->
        (
                ( languageBias(min_conf( L , MC )) ->
                        assert(minConf(L,MC))
                ;
                        assert(minConf(L,0.8))
                ),
                LP1 is L+1,
                asserisciMinConf( Max , LP1 )
        )
  ;
        true
  ).
readVerbosity :-
        retractall(languageBias(verbosity(List))),
        %( verbosity( List ) ->
                assertVerbosity__( List ).
        %;
                % user hasn't used verbosity predicate
        %       true
        %).
assertVerbosity__( [] ).
assertVerbosity__( [  Item = YesNo  |  T ]  ) :-
        assertVerbosity__( T ),
        ( YesNo = no ->
                assert( verbosity__(Item,no))
        ;
                assert( verbosity__(Item,yes))
        ).
% legge il minimo supporto a livello L
leggiMinSup(L,MS):-
     minSup(L,MS).
% legge la confidenza minima a livello L
leggiMinConf(L,MC):-
     minConf(L,MC).
% legge la verbosity
leggiVerbose(Show):-
     verbose(Show).
% legge i parametri
lb_Get_Param(Param,Val):-
     param__(Param,Val).
readMaxLargeness(ML) :-
        lb_Get_Param(max_largeness,ML).
% Attualmente non utilizzato (tutto lo schema)
readSchema(K,MaxK):-
        K =< MaxK,
        (       languageBias( schema(K,Value) ) ->
                        assert(lb_Schema(K,Value)),
                        write(user_output,' + '),
                        write(user_output,Value)
                ;
                        assert(lb_Schema(K,schema_none)),
                        write(user_output,' + none')
        ),
        M is K+1,
        readSchema(M,MaxK).
readSchema(_,_).
lb_Get_Schema(K,Value):-
     lb_Schema(K,Value),!.
lb_Get_Schema(_,schema_none).
%schema(k,type)                 type = schema_none, schema_is_a,
schema_spatial, schema_aspatial
%controlla se un atomo rispetta lo schema
lb_Test_Schema(schema_none,_):-!.
lb_Test_Schema(schema_is_a,is_a( _ , _ )):-!.
lb_Test_Schema(schema_spatial,SAtom):-call(languageSpatialRelation(SAtom)),!.
lb_Test_Schema(schema_aspatial,SAtom):-call(languageNoSpatialRelation(SAtom)),!.

 Raffinamento di Ontologie.
E questa sarebbe una spiegazione? Bontà tua.
Temo di non poterti aiutare. Meno che mai ho voglia di mettermi a 
ravanare attraverso qualche centinaio di righe di Prolog...

Massimo Soricetti ha scritto:

Si hai proprio ragione,scusami tanto ma è un po' difficile da
spiegare.
Comunque ti ringrazio lo stesso.Ciao.