Discussion :

[james-mi]

Bonjour,

Je veux faire un projet d'analyse de texte, j'en suis au tout début, et je me pose une question sur la bonne stratégie pour mon premier module.

Il s'agit d'analyser une distance entre des phrases qui sont des listes de mots.

Je fais ici une approche préliminaire et simpliste. Ce que j'aimerais, c'est faire les bons choix dès le départ.

Donc dans un premier temps, les mots type word sont tout simplement des entiers, et l'analyse repose sur une distance quadratique.
Par le suite, le type word doit s'enrichir de choses plus complexes, c'est pour cela que j'ai choisi un type record.
Dans un premier temps, je vais développer mon concept sur des phrases de mots de type int.

Le retour que j'aimerais de votre part, pour le code ci-après, c'est :
- mon module est-il bien fichu ?
- j'ai 2 versions : "firstAttempt" et "sndAttempt" : laquelle est préféreable, en vue d'une complexification type word ?
- est-ce la bonne stratégie pour l'étendre par la suite à des type word et des distance : word -> word -> int bien plus complexes que ceux exposés ci-dessous ?

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
module type TextAnalysis_type = sig
         type lemma
         type word
         type phrase
         val make_word : int -> word
         val distance_bw : word -> word -> int
         val distance_bp : phrase -> phrase -> float
end
 
module TextAnalysis_firstAttempt : TextAnalysis_type = struct
  type lemma = int
  type word  = Word of int
  type phrase = word list
  let make_word lemma = Word(lemma)
  let distance_bw w1 w2 = (* distance between words *)
    let Word i1, Word i2 = w1, w2 in (i1-i2)*(i1-i2)
  let distance_bp p1 p2 = (* distance between phrases *)
    failwith "Not implemented yet"
end
 
module MyFirstTextAnalysis : TextAnalysis_type = TextAnalysis_firstAttempt
 
module TextAnalysis_sndAttempt : TextAnalysis_type = struct
  type lemma = int
  type word  = {lemma : lemma}
  type phrase = word list
  let make_word lemma = {lemma = lemma}
  let distance_bw w1 w2 = (* distance between words *)
    let i1, i2 = w1.lemma, w2.lemma in (i1-i2)*(i1-i2)
  let distance_bp phr1 phr2 = (* distance between phrases *)
    List.map2 distance_bw phr1 phr2
    |> TextAnalysisUtils.int_median
end
 
module MySndTextAnalysis : TextAnalysis_type = TextAnalysis_firstAttempt

Merci d'avance !!

[TchoubiTchoub]

Bonjour,

J'espère ne pas répondre trop tard.

Votre problème est très intéressant car vous allez rentrer dans le royaume des foncteurs.

Que votre type word soit un record ou un type algébrique ou quoi que ce soit d'autre, la seule chose qui vous importe pour vos phrases c'est de pouvoir calculer la distance entre deux mots.

Donc, définissons une signature WordSig

Code :

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

1
2
3
4
5
module type WordSig = sig
  type t
 
  val distance : t -> t -> float
end

Maintenant, une signature PhraseSig

Code :

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

1
2
3
4
5
module type PhraseSig = sig
  type t
 
  val distance : t -> t -> float
end

Je peux donc maintenant définir un foncteur MakePhrase qui prend un module de type WordSig en paramètre.

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
module MakePhrase (W : WordSig) : PhraseSig = struct
 
  type t = W.t list
 
 
  let float_median xs = 
    let xs = List.sort compare xs in
    let n = List.length xs in 
    let m = (n - 1) / 2 in
    let rec find_mids i = function
      | x :: y :: _ when i = m -> x, y
      | _ :: tl -> find_mids (i + 1) tl
      | _ -> assert false
    in
    let xm1, xm2 = find_mids 0 xs in
    (xm1 +. xm2) /. 2.
 
  let distance phr1 phr2 = (* distance between phrases *)
    List.map2 W.distance phr1 phr2
                |> float_median

Et maintenant je peux faire les modules Word que je veux, mon foncteur ne change pas.

Par exemple :

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
module WordInt : WordSig = struct
  type t = int
 
  let distance t1 t2 = let tt = t1 - t2 in float (tt * tt)
end
 
module WordRec : WordSig = struct
 
  type lemma = int
 
  type t = {lemma : lemma}
 
  let distance {lemma = l1} {lemma = l2} = let ll = l1 - l2 in float (ll * ll)
 
end
 
module PhraseInt = MakePhrase(WordInt)
 
module PhraseRec = MakePhrase(WordRec)

Voilà la bonne solution pour avoir un code modulaire. N'hésitez pas si vous voulez plus d'aide sur les foncteurs ;-)

[james-mi]

Bonjour,

J'espère ne pas répondre trop tard.

Euh, ben non, je suis très très lent moi ... je mets des fois des mois à travailler sur un problème solubles en quelques jours ...
donc déjà merci de ta réponse !

J'avais bien senti qu'il y avait quelque chose à faire sur les modules et les foncteurs, mais avec tes exemples c'est plus clair.
Voici ce que je comprends :
- une signature de module Word, qui est en fait la base de tout
- ce module sera implémenté "à la main"
- une signature de module Phrase, qui est dans un premier temps complètement abstrait par rapport à Word
- on ne fera pas l'implémentation de Phrase "à la main"
- l'implémentation de Phrase va se faire via un foncteur "automatiquement" à partir de celle de Word

Donc je vais démarrer comme ça, et j'aurai forcément des questions par la suite (pas forcément rapide la suite) ! Donc à suivre ...

[TchoubiTchoub]

C'est exactement ça. Pour faire une analogie, vous manipulez des foncteurs à chaque fois que vous programmez

En effet, quand on écrit f x = (float x +. 1.) /. 2. ce qu'on raconte c'est "si je donne un entier à f il va me renvoyer un flottant". Un foncteur c'est pareil "si je donne un module restreint par une certaine signature à mon foncteur alors j'obtiendrai un nouveau module avec une autre signature".

En fin de compte, c'est pas si compliqué