Bonjour à tous,
Le script suivant permet le calcul de l'IDF d'un mot (pour un mot w, idf(w) = log(nombre des phrases dans mon corpus / nombre des phrases contenant le mot w)  
 
d'après les tests que je l'ai fait, ce script marche bien  , cependant il est long , comment je peux l'optimiser.
voici le code

#calcul le IDF d'un mot
 
    use strict;
    use warnings;
    use autodie;
 
 
my $nbre_ligne = 4159480;
 
 
 
open my $fh_resultat, ">:utf8", '/home/lenovo/Bureau/MesTravaux/IDF/out';
use constant CORPUS_MOT => '/home/lenovo/Bureau/MesTravaux/IDF/test';
use constant CORPUS_Phrases => '/home/lenovo/Bureau/MesTravaux/IDF/phrases';
 
my @tab_MOT_CORPUS = do {
    open my $fh1, "<:utf8", CORPUS_MOT;
    map { split } <$fh1>;
 
};
 
open my $fh2, "<:utf8", CORPUS_Phrases;
 
my @tab_phrase_CORPUS = <$fh2>;
 
my $size = 0;
chomp @tab_phrase_CORPUS;
foreach my $mot (@tab_MOT_CORPUS) {
my $nb_phrase = 0;
my $log;
my $idf;
foreach my $ph (@tab_phrase_CORPUS) {
my @tab = split(/ /, $ph);
chomp @tab ;
$size = $#tab;
foreach my $val(@tab) {
 if($mot eq $val) 
{
$nb_phrase = $nb_phrase + 1;
last;
}
}
}
#calcul log 
if($nb_phrase == 0) {$idf =0;} 
else
{
$idf = (log($nbre_ligne/$nb_phrase))/log(10);}
print $fh_resultat "$mot:$nb_phrase:$idf\n";
}

my $nbre_ligne = 4159480;
non!
my @tab_phrase_CORPUS = <$fh2>;
my $nbre_ligne = scalar(@tab_phrase_CORPUS);
 
Ensuite:
foreach my $mot (@tab_MOT_CORPUS) {
...
foreach my $ph (@tab_phrase_CORPUS) {
 
surtout pas! ca fait parcourir ton gros fichier scalar(@tab_MOT_CORPUS) fois.
 
 
Il ne faut parcourir @tab_phrase_CORPUS qu'une seule fois.
et passer par un hash pour accumuler les valeurs
Bref faire un truc dans ce gout la (pas testé):
 
use List::Util qw(uniqstr);
use Array::Utils qw(intersect);
 
my %tab_MOT_CORPUS;
{
    open my $fh1, "<:utf8", CORPUS_MOT;
    while (<$fh1> ) {
        chop;
        foreach (split) {
            $tab_MOT_CORPUS{$_}=0;
        }
    }
}
# on a créé un hash de clés les mots du corpus et de valeurs 0
 
my @mots_corpus = keys %tab_MOT_CORPUS;
my $nbre_ligne = 0;
foreach (@tab_phrase_CORPUS) {
    $nbre_ligne++;
    chop;
    my @mots = split;
    @mots = uniqstr (@mots);
    @mots = intersect(@mots_corpus, @mots);
    # mots contient la liste des mots de la phrase qui sont dans le corpus, chacun étant distinct
    foreach (@mots) {
        $tab_MOT_CORPUS{$_}++;
        # pour chacun, on incrémente le nb de lignes ou il figure
    }
}
 
Note:
Je me demande si un truc plus basique serait pas plus efficace en fait:
my %lignes;
my $nbre_phrases = 0;
{
    open my $fh, "<:utf8", CORPUS_MOT;
    while (<$fh1> ) {
        $nbre_phrases++;
        chop;
        my @mots = split;
        foreach (uniqstr(@mots)) {
            $lignes{$_}++;
        }
    }
    close $fh;
}
 
et ensuite
sub idf($) {
    my $mot= shift;
    if ($nbre_phrase and $lignes{$mot}) {
        return log($lignes{$mot}/$nb_phrase)/log(10);
    }
    else {
        return 0;
    }
}
 
Bref on construit un hash global pour tous les mots de ton corpus de texte, plutôt que de perdre du temps a chaque ligne a le filtrer vis a vis de ton corpus de mots. Ça ira plus vite, mais ça bouffera un peu plus de mémoire (mais pas plus que ton my @tab_phrase_CORPUS = <$fh2>; a priori).
 
A+,

bonsoir gilou, merci beaucoup pour la réponse
j'ai testé avec la première version, mais j'ai eu en sortie : "uniqstr" is not exported by the List::Util module
 
j'ai cherché sur google, mais j'ai pas réussi à trouver une solution ..

Probablement parce que votre module List::Util n'est pas à jour.
Si je regarde sur CPAN, c'est dedans:
http://search.cpan.org/~pevans/Sca [...] st/Util.pm

use List::Util qw(
      reduce any all none notall first
 
      max maxstr min minstr product sum sum0
 
      pairs unpairs pairkeys pairvalues pairfirst pairgrep pairmap
 
      shuffle uniq uniqnum uniqstr
    );

uniqstr fait partie des fonctions exportées.
 
A+,

Bon, j'ai eu le temps de regarder cela d'un peu plus près, vu que je bosse pas aujourd'hui.
Suite a vos mails en MP, je ferais ainsi:

#!/usr/bin/env perl
use strict;
use warnings;
use autodie;
 
# Pour virer la BOM utf8 (inutile mais hélas mise par MS-Windows, et qui s'incruste au premier mot du corpus).
use File::BOM qw(open_bom);
 
sub build_corpus($) {
    open_bom my $fh, shift;
    my %corpus;
    while (<$fh> ) {
        chomp;
        next if (/^\s*$/); 
        $corpus{$_} = {};
    }
    close $fh;
    return \%corpus;
}
 
sub parse_data($$) {
    my $corpus = shift;
    open_bom my $fh, shift;
    my $linenum;
    while (<$fh> ) {
        chomp;
        next if (/^\s*$/);
        ++$linenum; # ou le mettre avant le chomp si on ne veut aussi compter les lignes vides
        foreach (split /\b/) {
            next if (/\s+/);
            if ($corpus->{$_}) {
                $corpus->{$_}{$linenum}++;
            }
        }
    }
    close $fh;
    return $linenum;
}
 
sub idf($$$) {
    my ($corpus, $nblignes, $mot) = (shift, shift, shift);
    if ($corpus->{$mot}) {
        my $matchlines = scalar(keys %{$corpus->{$mot}});
        if ($matchlines) {
            return log($matchlines/$nblignes)/log(10);
        }
        else {
            # ou ce que vous voulez pour un mot du corpus sans occurence dans les données
            return 0;
        }
    }
    else {
        # mot pas dans le corpus
        return 0;
    }
}
 
sub save_result($$$) {
    my ($corpus, $nblignes) = (shift, shift);
    open my $fh, '>:utf8', shift;
    foreach (sort(keys %{$corpus})) {
        print $fh $_, " : ", idf($corpus, $nblignes, $_), "\n";
    }
    close $fh;
}
 
###############
# les données #
###############
my $corpus_file = "file1.txt";
my $data_file = "file2.txt";
my $result_file = "file3.txt";
 
#################
# le traitement #
#################
print "Lecture du corpus...";
my $corpus = build_corpus($corpus_file);
print "OK. ", scalar(keys %{$corpus}), " mots lus\n";
 
print "Lecture des lignes...";
my $nblignes = parse_data($corpus, $data_file);
print "OK. ", $nblignes, " lignes lues\n";
 
print "Ecriture des resultats...";
save_result($corpus, $nblignes, $result_file);
print "OK.\n";

 
Vu la taille de votre corpus, 1M de mots et 4M de lignes, c'est ce que je pense être le plus efficace.
Le seul endroit ou ca risque de ne pas satisfaire vos besoins, c'est le split /\b/.
En effet, si vos données sont en unicode, il n'est pas certain que cela ne splitte pas sur tout caractère accentué ou inhabituel.
Auquel cas, il faudra remplacer le /\b/ par une expression régulière plus adaptée (\b{wb}\ ?).
En tout cas, j'ai testé vite fait avec un mot comme Sørensen ou حاطه et il y avait pas de pb avec \b
Pour les perfs, on lit chaque ligne une seule fois, donc ça devrait rester acceptable.
 
Bon par contre si on a du bidirectionnel, faudra faire évoluer ce code, sinon on aura des choses style:  
حاطه : -0.477121254719662  
 
A+,