INPUT: 3.8 KB
Newer Older
Quentin David's avatar
Quentin David committed
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
INPUT:

article1.txt
article2.txt
article3.txt

Collection corpus:
[Documents][3]

Documents 1:

documentid




INPUT : C'est possible d'avoir plusieurs fichiers

PROCESSUS/ PIPELINE : C'est mieux de rassembler en un unique fichier texte "corpus"
( fusion + concatenation, perte de l'arborescence )

VISUALISATION: Il faut retrouver l'arborescence et un format de lecture pour chaque fichier
( retour vers le source décrit lors de la création du corpus, ou division des documents à partir du conllu )


Corpus public:
type: public
createdBy: jojo
creationDate: osef
metadata: osef
documents[]

Où est contenu le texte de ce corpus ?


MetaCollection PipelineXCorpus:
pipelineId
corpusId
conllu
outputs[]
annotations[]

Documents:
documentid
source1 (path vers un fichier) 
source2 (dérivation du conllu)
conlluBuffer (tokenization) [1 COLONNE: FORME, avec indexligne = token ()]


Source1 peut etre de différent types : XML, HTML, txt, pdf
Pour passer au conllu, on passe par un format String



Input:

article1.txt
article2.txt
article3.txt

Pipeline: p1

Validate

-> Creation de Corpus:
corpusId: _c1_
createdBy: moi
creationDate: now
type: private
{metadata } : null
documents:[
  {
    documentid: _d1_,
    source: article1.txt,
    conlluBuffer: null
  },
  {
    documentid: _d2_,
    source: article2.txt,
    conlluBuffer: null
  },
  {
    documentid: _d3_,
    source: article3.txt,
    conlluBuffer: null
  }
]

-> Creation de pipeline: pipelineId: _p1_

-> Construction de conlluBuffer

À partir des fichiers sources on construit ConlluBuffer qui n'est d'autre que le fichier source tokenisé.
Donc une seule colonne qui correspond au token/forme

_c1_.documents[0].conlluBuffer= translatedAsConllu(article1.txt)

-> Construction de CorpusProcess

CorpusProcess est l'assemblage d'un corpus & d'une pipeline, lancé par un utilisateur.
Durant l'initialisation, il y a concaténation des différents conlluBuffer de chaque document du corpus afin
de créer un unique fichier conllu.

corpusProcessId: _cp1_
corpusId: _c1_
pipelineId: _p1_
userId: moi
conllu: { // On concatène les conllu buffer des différents Documents pour créer cette propriété
  [{
    columnId: _conllu1_,
    columnTitle: FORM
    columnContent: .... // tokenization de l'ensemble des documents du corpus
  }],
  annotatedDocuments: [{
    documentId: _d1_,
    corpusProcessId: _cp1_,
    annotations: []
  },
  {
    documentId: _d2_,
    corpusProcessId: _cp1_,
    annotations: []
  },
  {
    documentId: _d3_,
    corpusProcessId: _cp1_,
    annotations: []
  }],
  outputs: [],
  currentProcessingModule: null,
  status: Not started yet
}

-> Démarrage de la chaine de traitement

En suivant les instructions de la pipeline _p1_, on démarre le premier module avec les paramètres correspondant.
_cp1_ est mis à jour

currentProcessingModule: _m1_,
status: Started
conllu: ajouter à la liste
{
  columnId: _conllu2_,
  columnTitle: Module1,
  columnContent: Annotations du Module1
}
outputs: ajouter à la liste
{
  processId: _process1_,
  moduleName: Module1,
  content: Output éventuellement retourné par Module1
}

-> Prochain module... & fin de la pipeline

Une fois un process terminé, on peut démarrer le suivant et updater _cp1_.currentProcessingModule.
Quand la pipeline est terminée sans erreur, _cp1_.status est mis à jour: Finished

-> Construction des annotations

À partir de la propriété conllu de _cp1_, on peut construire pour chaque colonne les annotations.
On sépare donc la colonne conllu en documents, puis on construit le format annotation.
On l'ajoute ensuite aux documents respectifs:
Ajout à _cp1_.annotatedDocuments[0].annotations:
{
  processId: _process1_,
  columnId: _conllu2_,
  moduleName: Module1,
  content: {
    title: Annotation du Module1,
    description: Voicil'annotation.,
    data: annotationData du Module1
  },
  color: blue
}