Modélisation d'un petit problème logique avec Prolog [Résolu]

[blackmisery]

Malheureusement non. Les classes a et b sont deux classes distinctes, mais sont assez difficilement distinguables. Pour l'exécution, je mets les règles dans un fichier .pl que j'exécute, puis j'essaie avec les objets que j'ai :
classe (X, 0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1).

Un à un pour voir si c'est correctement classifié.

Comment se fait l'insertion de ce "findall" et quelle en est la finalité?

[Trap D]

findall recherche toutes les faits acceptés par une règle.

Une bonne lecture : http://pcaboche.developpez.com/artic...l-bagof-setof/

[blackmisery]

findall me sort R = [a, a, b, b] et c'est normal puisque mon objet vérifie les deux premières règles concernant la classe a, mais en ayant moins de variables que les deux suivantes (celles qui sont les plus correctes).

J'ai essayé setof, cela me sort [a,b], donc juste une élimination des doublons.

J'affiche ce que j'ai noté en console (avec les valeurs réelles cette fois)

setof(X, Var1^Var2^Var3^Var4^Var5^Var6^Var7^Var8^Var9^Var10^Var11^Var12^classe(X,0.84,85,177,1.68,0.004,1.143,556,50.62,71,1.64,0.0079), R).

J'ai lu que plus on mettait l'opérateur ^, plus les variables n'étaient pas liées, moins il y aurait de résultats.

Je sèche un peu là

[Trap D]

Non, les Var^s'utilisent comme ça

Code :

setof(X, Var4^Var5^Var6^Var7^Var8^Var9^Var10^Var11^Var12^classe(X,0.84,85,177,Var4,Var5,Var6,Var7,Var8,Var9,Var10,Var11,Var12), R).

Ansi on recherche toutes les classes qui vérifient que les 3 premieères valeurs sont 0.84,85,177.

[blackmisery]

Cela n'a pas l'air de vouloir fonctionner comme il se doit,

cela me sort un sympathique

ERROR: </2: Arguments are not sufficiently instantiated

Bref, je me suis dis que si j'allais vite en conclusion, je pouvais mettre

setof(X,classe(X), R). Pour que toutes les variables ne soient pas liées et qu'il puisse chercher dans d'autres règles, plus convenables (bien entendu cela ne marche pas hein).

Idéalement, je pense que la meilleure solution consisterait à appliquer ce raisonnement :

- Quelles sont les règles qui vérifient l'appartenance de l'objet à telle ou telle classe? (Par exemple 5)

- Parmi ces 5, quelles sont celles qui ont le plus de variables utilisées? (Par exemple la 3ème et la 4ème règle utilisent 8 variables, la 1ère et la deuxième en utilisent 6, et la 5ème utilise 3 variables).

- Les classer par ordre (plus variables --> moins de variables)

- Sortir la classe à partir de la première règle.

Je pense que là on sera bons. Il faut que je sache comment modéliser tout ça avec mon ami Prolog

[Trap D]

Pourrais-t afficher les codes que tu utilises pour les affichages ? Tu fais tout en ligne de commande ?

[blackmisery]

Yes, en ligne de commande.

Je poste ici le code source avec les valeurs et les noms réels :

http://www.blackmisery.com/thesis/classes.pl

Et voici un exemple que j'ai utilisé :

setof(X, BoundingL^BoundingR^AreaL^AreaR^PerimeterR^PerimeterL^CompactnessL^CompactnessR^SolidityL^SolidityR^classe(X,0.8406476,566,BoundingL,BoundingR,AreaL,AreaR,PerimeterR,PerimeterL,CompactnessL,CompactnessR,SolidityL,SolidityR), R).

en mode console bien entendu.


En espérant que ça puisse aider!

[Trap D]

Pour bien comprendre, quelle est la réponse attendue à la requete

Code :

setof(X, BoundingL^BoundingR^AreaL^AreaR^PerimeterR^PerimeterL^CompactnessL^CompactnessR^SolidityL^SolidityR^classe(X,0.8406476,566,BoundingL,BoundingR,AreaL,AreaR,PerimeterR,PerimeterL,CompactnessL,CompactnessR,SolidityL,SolidityR), R).

[blackmisery]

Je suis supposé avoir la classe "petite". Par contre, dans toutes les classes où je suis censé obtenir "grande", j'obtiens toujours "petite" parce que justement y a une règle à 3 variables qui est vérifiée presque toujours.

Voilà un exemple d'objets supposés être de la classe "grande":


1.489393939,844,74.87005769,112,2.434069612,0.006147892,1.492313339,849,77.87005769,112,2.434069612,0.006147892


1.510714286,835,73.9411255,109,2.603643725,0.006277788,1.450712226,845,74.9411255,109,2.603643725,0.006277788

0.986869748,576,66.52691193,125,1.568707483,0.005192528,1.255555556,557,42.14213562,45,1.666666667,0.011479842


1.326923077,552,43.79898987,75,1.895522388,0.007022002,1.255555556,557,42.14213562,45,1.666666667,0.011479842


Si tu as besoin de ma base de test réelle, tu n'as qu'à le dire Ce sera avec plaisir.

[blackmisery]

Trap D toujours là?

[Trap D]

Trap D toujours là. stop. Trap D occupé. stop. Trap verra la semaine prochaine stop.

[blackmisery]

Salut Trap D,

quand tu auras un peu de temps, tu me diras de ce que tu penses de ces interrogations :

- Peut-on sous Prolog compter le nombre de variables dans les règles? Dans notre (mon) cas, on impose à ce que les règles ayant le plus de variables soient traitées en premier. Peut-on d'ailleurs pondérer des règles ou leur affecter un poids? Même manuellement...


- Est-ce possible de représenter sous Prolog la notion d'intervalle pour une variable dans une règle?

Exemple : [0.1<V1<0.3, 0.2<V2<0.9....]

Cela me permettra d'éliminer certaines règles, mais risquerait de fausser le résultat. Peut être que si le nombre est plus réduit je développerai une structure conditionnelle (hors Prolog) du genre SI ALORS SINON SI ALORS etc.

A bientôt!

[Trap D]

Salut

J'ai un peu regardé et j'arrive à ceci :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
classe(sain,ExtentR,BoundingR,PerimeterR,AreaR,SolidityR,CompactnessR,ExtentL,BoundingL,PerimeterL,AreaL,SolidityL,CompactnessL) :-
	(   nonvar(ExtentR), nonvar(PerimeterR), nonvar(ExtentL),
	    ExtentR<0.737,PerimeterR<0.356,ExtentL<0.571) ;

	(   nonvar(SolidityL), nonvar(PerimeterR), nonvar(CompactnessL),
	    PerimeterL<0.702,SolidityL<0.187,CompactnessL>0.687);

	(   nonvar(SolidityR), nonvar(BoundingL), nonvar(SolidityL),
	    SolidityR<0.591,BoundingL>0.51,SolidityL<0.625);

	(   nonvar(CompactnessR), nonvar(BoundingR), nonvar(BoundingL),
	    BoundingR>0.699,CompactnessR>0.144,BoundingL>0.701);

	(   nonvar(CompactnessR), nonvar(BoundingL), nonvar(SolidityL),
	    CompactnessR<0.478,BoundingL<0.622,SolidityL<0.62);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(BoundingL), nonvar(PerimeterL), nonvar(AreaL),
	    nonvar(SolidityL),
	    BoundingR>0.28,AreaR>0.169,BoundingL<0.695,PerimeterL>0.691,AreaL>0.667,SolidityL<0.699);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(CompactnessR), nonvar(ExtentL), nonvar(AreaL),
	    nonvar(BoundingL),
	    BoundingR>0.681,AreaR<0.045,CompactnessR>0.131,ExtentL>0.72,BoundingL>0.707,AreaL<0.706);

	(   nonvar(BoundingR), nonvar(SolidityR), nonvar(ExtentL), nonvar(SolidityL), nonvar(AreaL),
	    nonvar(CompactnessL),
	    BoundingR<0.015,SolidityR>0.542,ExtentL>0.614,AreaL<0.708,SolidityL>0.573,CompactnessL<0.706);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(ExtentL), nonvar(CompactnessR), nonvar(PerimeterL),
	    nonvar(CompactnessL),
	    BoundingR<0.171,AreaR<0.265,CompactnessR>0.423,ExtentL<0.713,PerimeterL<0.89,CompactnessL<0.649);

	(   nonvar(BoundingR), nonvar(SolidityL), nonvar(ExtentL),
	    BoundingR<0.497,ExtentL<0.615,SolidityL<0.612);

	(   nonvar(ExtentR), nonvar(BoundingR), nonvar(ExtentL), nonvar(AreaL), nonvar(SolidityL),
	    nonvar(CompactnessL),
	    ExtentR<0.489,BoundingR>0.497,ExtentL>0.615,AreaL>0.614,SolidityL>0.612,CompactnessL<0.619);

	(   nonvar(ExtentR), nonvar(SolidityR), nonvar(ExtentL), nonvar(BoundingL), nonvar(SolidityL),
	    nonvar(CompactnessL),
	    ExtentR>0.318,SolidityR<0.608,ExtentL>0.674,BoundingL>0.729,SolidityL>0.664,CompactnessL>0.82);

	(   nonvar(PerimeterL), nonvar(SolidityR), nonvar(AreaL), nonvar(BoundingL), nonvar(SolidityL),
	    nonvar(CompactnessL),
	    SolidityR>0.069,BoundingL>0.65,PerimeterL<0.71,AreaL<0.363,	SolidityL>0.665,CompactnessL<0.701);

	(   nonvar(BoundingR), nonvar(SolidityR), nonvar(CompactnessR), nonvar(BoundingL), nonvar(SolidityL),
	    nonvar(CompactnessL),nonvar(CompactnessR), nonvar(PerimeterL), nonvar(AreaL),
	    BoundingR>0.716,SolidityR<0.069,CompactnessR<0.149,ExtentL>0.682,BoundingL>0.65,PerimeterL>0.71,
	    AreaL<0.363,SolidityL>0.665,CompactnessL>0.701);

	(   nonvar(ExtentR), nonvar(PerimeterR), nonvar(AreaR), nonvar(BoundingL), nonvar(SolidityL),
	    nonvar(AreaL),
	    ExtentR<0.03,PerimeterR>0.703,AreaR<0.711,BoundingL<0.65,AreaL>0.363,SolidityL<0.665);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(BoundingL), nonvar(PerimeterL), nonvar(SolidityL),
	    nonvar(AreaL),
	    BoundingR>0.28,AreaR>0.169,BoundingL<0.695,PerimeterL>0.715,AreaL>0.686,SolidityL<0.699);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(BoundingL), nonvar(PerimeterL), nonvar(SolidityL),
	    nonvar(AreaL),
	    BoundingR>0.132,AreaR<0.985,BoundingL<0.139,PerimeterL>0.691,AreaL>0.686,SolidityL<0.1).

classe(petite,ExtentR,BoundingR,PerimeterR,AreaR,SolidityR,CompactnessR,ExtentL,BoundingL,PerimeterL,AreaL,SolidityL,CompactnessL) :-
	(   nonvar(BoundingR), nonvar(CompactnessR), nonvar(ExtentL),
	    BoundingR<0.672,CompactnessR<0.623,ExtentL<0.399);

	(   nonvar(AreaR), nonvar(BoundingL), nonvar(ExtentL),
	    AreaR>0.036,ExtentL<0.707,BoundingL<0.706);

	(   nonvar(SolidityL), nonvar(BoundingL), nonvar(CompactnessL),
	    BoundingL>0.67,SolidityL>0.674,CompactnessL>0.308);

	(   nonvar(BoundingR), nonvar(BoundingL), nonvar(ExtentL),
	    BoundingR>0.461,ExtentL>0.621,BoundingL>0.633);

	(   nonvar(BoundingR), nonvar(SolidityL), nonvar(ExtentL),
	    BoundingR>0.569,ExtentL>0.58,SolidityL>0.583);

	(   nonvar(BoundingR), nonvar(BoundingL), nonvar(CompactnessR),
	    BoundingR<0.699,CompactnessR<0.144,BoundingL<0.701);

	(   nonvar(ExtentR), nonvar(BoundingL), nonvar(CompactnessR),
	    ExtentR<0.623,CompactnessR<0.42,BoundingL<0.66);

	(   nonvar(SolidityR), nonvar(PerimeterL), nonvar(CompactnessR),
	    SolidityR<0.973,CompactnessR>0.152,PerimeterL>0.172);

	(   nonvar(ExtentR), nonvar(PerimeterR), nonvar(BoundingR),nonvar(CompactnessR), nonvar(ExtentL),
	    nonvar(PerimeterL), nonvar(SolidityL),nonvar(CompactnessL),
	    ExtentR>0.006,BoundingR>0.379,PerimeterR>0.762,AreaR>0.046,	CompactnessR<0.357,ExtentL<0.667,
	    PerimeterL<0.924,SolidityL<0.652,CompactnessL>0.648);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(SolidityR),nonvar(CompactnessR), nonvar(ExtentL),
	    nonvar(BoundingL), nonvar(PerimeterL),nonvar(AreaL),nonvar(SolidityL),
	    BoundingR>0.649,AreaR>0.698,SolidityR<0.467,CompactnessR>0.357, ExtentL>0.667,
	    BoundingL<0.658,PerimeterL>0.117,AreaL>0.59,SolidityL>0.652);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(SolidityL),nonvar(PerimeterL), nonvar(AreaL),
	    nonvar(BoundingL),
	    BoundingR>0.28,AreaR>0.985,BoundingL<0.695,PerimeterL>0.691,AreaL>0.667,SolidityL<0.699).

classe(grande,ExtentR,BoundingR,PerimeterR,AreaR,SolidityR,CompactnessR,ExtentL,BoundingL,PerimeterL,AreaL,SolidityL,CompactnessL) :-
	(   nonvar(BoundingR), nonvar(BoundingL), nonvar(ExtentL),
	    BoundingR>0.461,ExtentL>0.621,BoundingL>0.633);

	(   nonvar(ExtentL), nonvar(SolidityL),
	    ExtentL>0.58,SolidityL>0.583);

	(   nonvar(BoundingR), nonvar(BoundingL), nonvar(SolidityR),
	    BoundingR>0.12,SolidityR>0.066,BoundingL<0.991);

	(   nonvar(BoundingR), nonvar(PerimeterR), nonvar(SolidityL),
	    BoundingR>0.718,PerimeterR>0.129,SolidityL<0.684);

	(   nonvar(BoundingL), nonvar(CompactnessR), nonvar(SolidityR),
	    SolidityR>0.716,CompactnessR>0.691,BoundingL>0.099);

	(   nonvar(BoundingL), nonvar(CompactnessR), nonvar(ExtentR),
	    ExtentR>0.623,CompactnessR>0.42,BoundingL>0.66);

	(   nonvar(SolidityR), nonvar(CompactnessR), nonvar(PerimeterL),
	    SolidityR>0.973,CompactnessR<0.152,PerimeterL<0.172);

	(   nonvar(ExtentR), nonvar(ExtentL), nonvar(BoundingL),
	    ExtentR>0.99,ExtentL<0.056,BoundingL<0.131);

	(   nonvar(ExtentR), nonvar(PerimeterR), nonvar(CompactnessR),
	    nonvar(ExtentL), nonvar(SolidityL),	nonvar(CompactnessL),
	    ExtentR<0.006,PerimeterR<0.762,CompactnessR<0.357,
	    ExtentL<0.667,SolidityL<0.652,CompactnessL<0.648);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(SolidityR),nonvar(CompactnessR),
	    nonvar(ExtentL), nonvar(BoundingL),	nonvar(PerimeterL),nonvar(AreaL),nonvar(SolidityL),
	    BoundingR>0.649,AreaR>0.698,SolidityR<0.467,CompactnessR>0.357,
	    ExtentL>0.667,BoundingL<0.658,PerimeterL>0.117,AreaL>0.59,SolidityL>0.652);

	(   nonvar(BoundingR), nonvar(AreaR), nonvar(BoundingL),
	    nonvar(PerimeterL),nonvar(AreaL),nonvar(SolidityL),
	    BoundingR>0.28,AreaR>0.169,BoundingL<0.695,PerimeterL>0.691,AreaL>0.667,SolidityL<0.699);

	(   nonvar(ExtentR), nonvar(BoundingR), nonvar(PerimeterR), nonvar(SolidityR),nonvar(CompactnessR),
	    nonvar(BoundingL),	nonvar(PerimeterL),nonvar(CompactnessL),nonvar(SolidityL),
	    ExtentR>0.585,BoundingR<0.723,PerimeterR>0.441,SolidityR>0.568,CompactnessR>0.695,
	    BoundingL<0.67, PerimeterL>0.363,SolidityL<0.674,CompactnessL<0.308);

	(   nonvar(BoundingR), nonvar(PerimeterR), nonvar(AreaR), nonvar(SolidityR),nonvar(ExtentL),
	    nonvar(BoundingL),	nonvar(PerimeterL),nonvar(AreaL),nonvar(SolidityL),
	    BoundingR>0.28,PerimeterR>0.526,AreaR>0.985,SolidityR>0.452,ExtentL<0.72,BoundingL<0.695,
	    PerimeterL>0.691,AreaL>0.667,SolidityL<0.699).

Comme tu peux le voir, on regarde à chaque fois si les arguments testés sont unifiés à une valeur ou non.
A l'aide de ce code, j'arrive à chaque fois comme résultat à [grande, petite] pour les exemples numériques que tu m'as fourni avec cette recherche :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
t :-
setof(X, classe(X, 
		1.326923077,552,43.79898987,75,1.895522388,0.007022002,1.255555556,
		557,42.14213562,45,1.666666667,0.011479842
/*
	        0.986869748,576,66.52691193,125,1.568707483,0.005192528,1.255555556,557,
	        42.14213562,45,1.666666667,0.011479842

	        1.510714286,835,73.9411255,109,2.603643725,0.006277788,
	        1.450712226,845,74.9411255,109,2.603643725,0.006277788

	        1.489393939,844,74.87005769,112,2.434069612,0.006147892,1.492313339,849,
		77.87005769,112,2.434069612,0.006147892
*/
	    ), R),
	writeln(R).

[blackmisery]

Salut Trap D, content d'avoir tes retours

Le souci de mon côté, c'est que nous sommes dans le domaine médical, et il s'agit ici de fractures. Du coup avoir une fracture grande OU petite pour un nez ce ne serait pas très très bien pour le médecin

Je sais que la plupart des grandes fractures sont considérées comme petites parce qu'elles satisfont des règles où la classe est petite. Ce sont généralement des classes à 3 variables uniquement.

Serait-ce possible de rendre l'ordre des règles obligatoire? Du genre on commence par les règles avec le maximum de variables pour aller jusqu'à celles qui en ont le moins?

[Trap D]

On peut toujours rendre l'ordre des régles obligatoire.
Tu voudrais un genre de système expert non ?

[blackmisery]

Exactement!

[Trap D]

- Est-ce possible de représenter sous Prolog la notion d'intervalle pour une variable dans une règle?

Exemple : [0.1<V1<0.3, 0.2<V2<0.9....]

Tout à fait :

Code :

0.1 < V, V < 0.3