Discussion :

[MrSiuol]

Bonjour,

j'aimerai savoir comment compiler une ligne de code dans un programme déjà compilé ?
J'ai vu qu'il y avait une commande 'compile' dans la doc, et qu'elle était sensé fonctionner comme eval:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#lang racket/base
(compile '(print (+ 5 6)))
(read)

Mais à l'évidence... .... ça ne fonctionne pas (comme eval)

J'en profite pour poser une 2e question (les personnes connectées étant si rares sur ce forum):
je m'essaye à la programmation génétique, et j'ai commencé -avec succès- avec une petite formule mathématique à trouver: f(x)=0,75x^2-5x+3 ==> (plus (multi (moins (multi (divis x 8) 6) 5) x) 3)
Mais je ne vois pas comment passer des opérateurs mathématiques à des commandes tel que des boucles ou des conditions, sans avoir d'erreur comme des boucles infinies, ...
Connaissez-vous des articles ou auriez vous des idées ?

Merci d'avance

[byjav]

Dans le REPL de DrRacket je fais comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
> (define foo (compile '(print (+ 5 6))))
> foo
<quelque chose peu lisible>
> (eval foo)
11

Alors, il semble que ça marche. La variable foo contient du code en forme de code machine, pas en forme d'une liste.

Il paraît que la deuxième question appartient à la programmation génétique proprement dite, alor je ne m'en débrouille pas.

[MrSiuol]

Le problème, c'est que j'aimerai faire la même chose dans un déjà compilé programme.

[jack-ft]

j'aimerai savoir comment compiler une ligne de code dans un programme déjà compilé ?

Pourquoi veux-tu faire ça?

Comme je l'ai déjà indiqué dans des posts précédents, il me semble qu'il vaudrait mieux d'abord résoudre ton problème de programmation génétique avant de chercher à l'optimiser (compilation).

J'ai vu qu'il y avait une commande 'compile' dans la doc, et qu'elle était sensé fonctionner comme eval:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#lang racket/base
(compile '(print (+ 5 6)))
(read)

Mais à l'évidence... .... ça ne fonctionne pas (comme eval)

Ça me paraît un peu étrange de compiler une expression?!?!
De mon temps, on compilait des fonctions, ce qui permettait de transformer une fonction interprétée en une fonction compilée.
C'est-à-dire transformer une fonction dont le code est une liste (une expression) en fonction dont le code est "compilé" (genre de l'assembleur ou du code machine).
Une fonction dont le code est une liste doit être interprétée par un interpréteur, qui analyse chaque élément (car cdr) de la liste, récursivement, et fait son boulot d'interprétation.
L'exécution d'une fonction dont le code est compilé ne passe pas par l'interpréteur et va donc plus vite.
Je passe rapidement car àmha ce n'est pas le sujet (voir post suivant).

[jack-ft]

J'en profite pour poser une 2e question (les personnes connectées étant si rares sur ce forum):
je m'essaye à la programmation génétique, et j'ai commencé -avec succès- avec une petite formule mathématique à trouver: f(x)=0,75x^2-5x+3 ==> (plus (multi (moins (multi (divis x 8) 6) 5) x) 3)

Si je me souviens bien, dans le code que tu avais présenté, tu avais codé cette formule mathématique avec tes propres mains.

Le but de l'exercice proposé n'est PAS de coder soi-même cette fonction, mais plutôt de lancer un programme qui va trouver tout seul cette fonction!
Je cite (http://www-lisic.univ-littoral.fr/~f...netique.html):

La programmation génétique permet dans une certaine mesure de répondre au rêve de tout informaticien, à savoir créer un programme automatiquement pour résoudre un problème donné.

C'est beaucoup plus difficile (et beaucoup plus intéressant)!

En tout cas, si j'avais du temps à y passer, ça m'intéresserait, mais j'ai d'autres priorités en ce moment.

Je vois assez bien le schéma que j'utiliserais (un mix de parthénogenèse (pour l'optimisation des coefficients) et de reproduction sexuée (pour l'évolution vers des formes plus complexes)).

Mais je ne vois pas comment passer des opérateurs mathématiques à des commandes tel que des boucles ou des conditions, sans avoir d'erreur comme des boucles infinies, ...

Euh... je ne comprends pas bien la question.

L'idée de choisir "lisp", c'est qu'on a à sa disposition un interpréteur (il s'agit de la fonction "eval") qui est très pratique et très puissant.

Connaissez-vous des articles

un moteur de recherche, peut-être?

ou auriez vous des idées ?

L'article donne des pistes intéressantes:

Voici un algorithme synthétique pour la PG :

1. Génération aléatoire de la population (1 individu = 1 programme)
2. Évaluation du fitness de chacun des individus de la population (évaluation de l'adéquation des programmes au problème à résoudre)
3. Application des opérateurs de croisement, mutation, reproduction sur la population afin de créer une nouvelle population
4. Sélection des individus les mieux adaptés
5. Répéter les étapes 2 et 3 un certain nombre de fois

Pourquoi ne pas commencer par là?

Chacun des points proposés me paraît au moins faisable (sinon facile)!

[MrSiuol]

En fait le programme que j'ai fait pour l'instant n'intègre que les mutations et est déjà très lent.... ....à moins que se soit moi qui l'ait mal codé... (je n'exclu pas cette piste, commissaire )

Je me demande si utiliser des croisement entre programmes augment vraiment les résultats ?
De même pour le classement, ne faut-il pas garder que le meilleur programme ?
Il y a aussi des constantes que j'ai mises -un peu au hasard- pour les mutation aléatoires, que j'aurais définir plus précisément, ça se calcule, ou il faut les définir de manière empirique ?
( l'idéale aurait été de les définir elles-mêmes de façon génétique, mais c'est impossible au vu de sa lenteur )

Programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
152
153
154
155
#lang Racket

#|

+-----------------==0==-----------------+
|                                       |
|  LE PROGRAMME DOIT ETRE INTERPRETE !  |
|                                       |
+-----------------==0==-----------------+

Fait à partir de: http://www-lisic.univ-littoral.fr/~f...genetique.html
|#


;; Initailisation:
(define (ResultFnc x) (+ (* 0.75 x x) (* -5 x) 3))

(define Result '((0 3) (1 -1.25) (2 -4) (5 -3.25) (6 0) (7 4.75) (8 11) (9 18.75) (10 28)))

(define root '(+ (+ (- (* (divis 2 1) 1) 1) x) 1))

;; Fonctions de bases:
(define (plus a b)
  (+ a b))

(define (moins a b)
  (- a b))

(define (multi a b)
  (* a b))

(define (divis a b)
  (if (= b 0)
      0
      (/ a b)))

;; EvaluateurConst:
(define (EvaluateurConst prog)
  (map (lambda (fnc)
         (list
          fnc
          (apply + (map (lambda (a) (abs (- (cadr a) (eval (list (append '(lambda (x)) (list fnc)) (car a))))))
                        Result))))
       prog))


;; EvalVariance
;;.
(define (EvalVariance prog)
  (map (lambda (fnc)
         (list
          fnc
          (abs (- (/ (apply + (map (lambda (a)
                                     (expt (- (cadr a)
                                              (eval (list (append '(lambda (x)) (list fnc)) (car a))))
                                           2))
                                   Result))
                     (length Result))
                  (expt (/ (apply + (map (lambda (a)
                                           (- (cadr a)
                                              (eval (list (append '(lambda (x)) (list fnc)) (car a)))))
                                         Result))
                           (length Result))
                        2)))))
       prog))

;; EvalVariConst
(define (EvalVariConst prog)
   (map (lambda (fnc)
         (list
          fnc
          (abs (* (expt (+ (abs (- (/ (apply + (map (lambda (a)
                                     (expt (- (cadr a)
                                              (eval (list (append '(lambda (x)) (list fnc)) (car a))))
                                           2))
                                   Result))
                     (length Result))
                  (expt (/ (apply + (map (lambda (a)
                                           (- (cadr a)
                                              (eval (list (append '(lambda (x)) (list fnc)) (car a)))))
                                         Result))
                           (length Result))
                        2))) 1) 2)
                  (apply + (map (lambda (a) (abs (- (cadr a) (eval (list (append '(lambda (x)) (list fnc)) (car a))))))
                        Result))))))
       prog))

;; Mutateur:
(define operateur '(+ - * divis))
(define nOpr (length operateur))

(define (Mutateur prog)
  (let ((aleaFnc 5) (aleaDnn 3) (aleaDnnMax 10) (aleaX 3))
    (let recusion ((pg prog))
      (list
       #| Fonction |#
       (if (= (random aleaFnc) 0)
           (list-ref operateur (random nOpr))
           (car pg))
       #| Donnée I  |#
       (if (list? (cadr pg))
           (recusion (cadr pg))
           (if (= (random aleaDnn) 0)
               (if (= (random aleaX) 0)
                   'x
                   (random aleaDnnMax))
               (cadr pg)))
       #| Donnée II |#
       (if (list? (caddr pg))
           (recusion (caddr pg))
           (if (= (random aleaDnn) 0)
               (if (= (random aleaX) 0)
                   'x
                   (random aleaDnnMax))
               (caddr pg)))))))

;; Croiseur
(define (Croiseur prog1 prog2 nProg)
  (let ((aleaFnc 5) (aleaDnn 3) (aleaDnnMax 10) (aleaX 3))
    (let recursion ((pg nProg))
      (recursion (+ pg 1)))))

;; Multiplicateur
(define (Multiplicateur prog nProg)
  (let loop ((generation (list prog)) (i 1))
    (if (= i nProg)
        generation
        (loop (append generation (list (Mutateur prog))) (+ i 1)))))

;; Tri
(define (Tri progs)
  (sort progs (lambda (x y) (<= (cadr x) (cadr y)))))

#|;; Test
(Multiplicateur '(+ 7 9) 5)
(print (mutateur '(+ (* 5 (+ 1 4)) 9)))
(Evaluateur '((plus (moins (produc (divise 1 x) 1) 1) 1)))
(print (Tri '(((plus 7 9) 116.5) ((plus 7 8) 111.5) ((plus 7 9) 116.5) ((plus 7 9) 116.5) ((plus 5 9) 106.5))))
(print (EvalVariance '((multi (moins (divis (multi 8 x) 9) 6) x))))
;;|#

;; Main
(define (main nTour nProg)
  (let loop ((generation (EvalVariConst (list root))) (ng 0))
    #| ((programme score) ...) |#
    (if (= ng nTour)
        (begin
          (printf "Score:~a\n Programme:~a\n\n" (cadar generation) (caar generation))
          (cadar generation))
        (loop (Tri (EvalVariConst (Multiplicateur (caar generation) nProg))) (+ ng 1)))))



(main 100 100)