00001 # Copyright (C) 1997-2004 The CDG Team <cdg@nats.informatik.uni-hamburg.de> 00002 # 00003 # This file is free software; as a special exception the author gives 00004 # unlimited permission to copy and/or distribute it, with or without 00005 # modifications, as long as this notice is preserved. 00006 # 00007 # This program is distributed in the hope that it will be useful, but 00008 # WITHOUT ANY WARRANTY, to the extent permitted by law; without even the 00009 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00010 00011 ## ---------------------------------------------------------------------------- 00012 ## YadaDifference - difference between two experiments. 00013 ## \ingroup YadaRunnableDocuments 00014 ## 00015 ## \author Michael Daum 00016 ## 00017 ## $Id: YadaDifference.tcl,v 1.4 2004/02/25 14:42:08 micha Exp $ 00018 ## ---------------------------------------------------------------------------- 00019 class YadaDifference { 00020 inherit YadaRunnableDocument 00021 00022 # variables ---------------------------------------------------------------- 00023 public variable betterAndFasterBackground "green1" 00024 public variable betterAndFasterForeground "black" 00025 public variable betterBackground "green2" 00026 public variable betterButSlowerBackground "green3" 00027 public variable betterButSlowerForeground "black" 00028 public variable betterForeground "black" 00029 public variable fasterBackground "lightblue" 00030 public variable fasterForeground "black" 00031 public variable harderBackground "deepskyblue3" 00032 public variable harderForeground "black" 00033 public variable sameBackground "gray" 00034 public variable sameForeground "black" 00035 public variable slowerBackground "yellow" 00036 public variable slowerForeground "black" 00037 public variable softerBackground "deepskyblue1" 00038 public variable softerForeground "black" 00039 public variable weirdBackground "pink" 00040 public variable weirdForeground "black" 00041 public variable worseAndSlowerBackground "red3" 00042 public variable worseAndSlowerForeground "white" 00043 public variable worseBackground "red1" 00044 public variable worseButFasterBackground "orange" 00045 public variable worseButFasterForeground "black" 00046 public variable worseForeground "white" 00047 00048 private variable _totalWordgraphs 0 00049 private variable _fasterWordgraphs 0 00050 private variable _betterWordgraphs 0 00051 private variable _betterAndFasterWordgraphs 0 00052 private variable _betterButSlowerWordgraphs 0 00053 private variable _softerWordgraphs 0 00054 private variable _harderWordgraphs 0 00055 private variable _sameWordgraphs 0 00056 private variable _worseButFasterWordgraphs 0 00057 private variable _worseAndSlowerWordgraphs 0 00058 private variable _worseWordgraphs 0 00059 private variable _slowerWordgraphs 0 00060 private variable _weirdWordgraphs 0 00061 00062 private variable _totalTime1 0 00063 private variable _score1 0 00064 private variable _totalTime2 0 00065 private variable _score2 0 00066 private variable _noSolutions1 0 00067 private variable _totalSolTime1 0 00068 private variable _totalSoftTime1 0 00069 private variable _noSolutions2 0 00070 private variable _totalSolTime2 0 00071 private variable _totalSoftTime2 0 00072 private variable _noErrors1 0 00073 private variable _noErrors2 0 00074 private variable _totalStructRecall1 0 00075 private variable _totalLexicalRecall1 0 00076 private variable _totalLabelledRecall1 0 00077 private variable _totalStructRecall2 0 00078 private variable _totalLexicalRecall2 0 00079 private variable _totalLabelledRecall2 0 00080 00081 private variable _typeOfColumn ; ## \type TclArray 00082 private variable _scoreOf ; ## \type TclArray 00083 private variable _structHitsOf ; ## \type TclArray 00084 private variable _lexicalHitsOf ; ## \type TclArray 00085 private variable _labelledHitsOf ; ## \type TclArray 00086 private variable _triesOf ; ## \type TclArray 00087 00088 private variable _prevExperimentName1 "" 00089 private variable _prevExperimentName2 "" 00090 00091 # methods ------------------------------------------------------------------ 00092 public method activationHandle {} 00093 public method load {args}; ## \type TclList 00094 public method save {{fileName ""}}; ## \type TclString 00095 public method step {{wordgraph ""}}; ## \type TclString 00096 public method clear {} 00097 public method runall {} 00098 public method run {} 00099 public method selectExperiment {experimentNo {experimentName ""}}; ## \type TclNumber, TclString 00100 00101 constructor {args} {}; ## \type TclList 00102 00103 private method _analyseDocument {document experiment}; ## \type DomDocument, YadaExperiment 00104 private method _judgeRow {row}; ## \type TclNumber 00105 private method _computeStatistics {} 00106 private method _judgeData {measure1a measure1b time1 solutionTime1 softTime1 measure2a measure2b time2 solutionTime2 softTime2}; ## \type TclNumber, TclNumber, TclNumber, TclNumber, TclNumber, TclNumber, TclNumber, TclNumber, TclNumber, TclNumber 00107 private method _getJudgeOfRow {row}; ## \type TclNumber 00108 private method _getWordgraphs {} 00109 private method _getSelectedExperiments {} 00110 private method _getTypeOfColumn {colNo} ; ## \type TclNumber 00111 private method _resetDataOf {wordgraphs}; ## \type TclList 00112 private method _jobConsumer {job}; ## \type YadaJob 00113 private method _getDoneWork {} 00114 private method _getUndoneWork {} 00115 00116 protected method _viewLogfile {} 00117 protected method _viewXmlfile {} 00118 protected method _traceProcess {} 00119 }; 00120 00121 ## ---------------------------------------------------------------------------- 00122 ## constructor 00123 ## ---------------------------------------------------------------------------- 00124 body YadaDifference::constructor {args} { 00125 00126 # reconfigure table 00127 $itk_component(table) configure -rows 300 -cols 18 \ 00128 -rowtagcommand [code $this _judgeRow] 00129 00130 # set types of columns 00131 array set _typeOfColumn { 00132 0 "dictionary" 00133 1 "integer" 00134 2 "real" 00135 3 "integer" 00136 4 "integer" 00137 5 "integer" 00138 6 "integer" 00139 7 "real" 00140 8 "real" 00141 9 "integer" 00142 10 "integer" 00143 11 "integer" 00144 12 "integer" 00145 13 "real" 00146 14 "real" 00147 15 "real" 00148 16 "real" 00149 17 "ascii" 00150 } 00151 00152 # experiments 00153 foreach i {1 2} { 00154 00155 itk_component add experiment${i}BoxLabel { 00156 label $itk_component(heading).experiment${i}BoxLabel \ 00157 -text "Experiment ${i}:" \ 00158 -anchor w 00159 } {} 00160 00161 itk_component add experiment${i}Box { 00162 iwidgets::combobox $itk_component(heading).experiment${i}Box \ 00163 -completion false \ 00164 -borderwidth 2 \ 00165 -margin 4 \ 00166 -selectioncommand [code $this selectExperiment $i] 00167 } {} 00168 00169 itk_component add score${i}Label { 00170 label $itk_component(heading).score${i}Label \ 00171 -text "Score:" \ 00172 -anchor w \ 00173 } {} 00174 00175 itk_component add score${i} { 00176 entry $itk_component(heading).score${i} \ 00177 -borderwidth 2 \ 00178 -state disabled \ 00179 -width 20 00180 } {} 00181 00182 itk_component add totalTime${i}Label { 00183 label $itk_component(heading).totalTime${i}Label \ 00184 -text "Time:" \ 00185 -anchor w 00186 } {} 00187 00188 itk_component add totalTime${i} { 00189 entry $itk_component(heading).totalTime${i} \ 00190 -borderwidth 2 \ 00191 -state disabled \ 00192 -width 20 00193 } {} 00194 00195 itk_component add noSolutions${i}Label { 00196 label $itk_component(heading).noSolutions${i}Label \ 00197 -text "No.Solutions:" \ 00198 -anchor w 00199 } {} 00200 00201 itk_component add noSolutions${i} { 00202 entry $itk_component(heading).noSolutions${i} \ 00203 -textvariable [scope _noSolutions${i}] \ 00204 -borderwidth 2 \ 00205 -state disabled \ 00206 -width 20 00207 } {} 00208 00209 itk_component add noErrors${i}Label { 00210 label $itk_component(heading).noErrors${i}Label \ 00211 -text "No.Errors:" \ 00212 -anchor w 00213 } {} 00214 00215 itk_component add noErrors${i} { 00216 entry $itk_component(heading).noErrors${i} \ 00217 -borderwidth 2 \ 00218 -state disabled \ 00219 -width 20 00220 } {} 00221 00222 itk_component add totalSolTime${i}Label { 00223 label $itk_component(heading).totalSolTime${i}Label \ 00224 -text "Sol.Time:" \ 00225 -anchor w 00226 } {} 00227 00228 itk_component add totalSolTime${i} { 00229 entry $itk_component(heading).totalSolTime${i} \ 00230 -borderwidth 2 \ 00231 -state disabled \ 00232 -width 20 00233 } {} 00234 00235 itk_component add totalSoftTime${i}Label { 00236 label $itk_component(heading).totalSoftTime${i}Label \ 00237 -text "Soft Time:" \ 00238 -anchor w 00239 } {} 00240 00241 itk_component add totalSoftTime${i} { 00242 entry $itk_component(heading).totalSoftTime${i} \ 00243 -borderwidth 2 \ 00244 -state disabled \ 00245 -width 20 00246 } {} 00247 00248 itk_component add totalStructRecall${i}Label { 00249 label $itk_component(heading).totalStructRecall${i}Label \ 00250 -text "Struct.Recall:" \ 00251 -anchor w 00252 } {} 00253 00254 itk_component add totalStructRecall${i} { 00255 entry $itk_component(heading).totalStructRecall${i} \ 00256 -borderwidth 2 \ 00257 -state disabled \ 00258 -width 20 00259 } {} 00260 00261 itk_component add totalLexicalRecall${i}Label { 00262 label $itk_component(heading).totalLexicalRecall${i}Label \ 00263 -text "Lex.Recall:" \ 00264 -anchor w 00265 } {} 00266 00267 itk_component add totalLabelledRecall${i}Label { 00268 label $itk_component(heading).totalLabelledRecall${i}Label \ 00269 -text "Label.Recall:" \ 00270 -anchor w 00271 } {} 00272 00273 itk_component add totalLabelledRecall${i} { 00274 entry $itk_component(heading).totalLabelledRecall${i} \ 00275 -borderwidth 2 \ 00276 -state disabled \ 00277 -width 20 00278 } {} 00279 00280 00281 itk_component add totalLexicalRecall${i} { 00282 entry $itk_component(heading).totalLexicalRecall${i} \ 00283 -borderwidth 2 \ 00284 -state disabled \ 00285 -width 20 00286 } {} 00287 00288 # bindings 00289 set entry [$itk_component(experiment${i}Box) component entry] 00290 bind $entry <Return> [code $this selectExperiment $i] 00291 bind $entry <Up> +[code $this selectExperiment $i] 00292 bind $entry <Down> +[code $this selectExperiment $i] 00293 } 00294 00295 # separator 00296 itk_component add separator { 00297 frame $itk_component(heading).separator \ 00298 -height 2 \ 00299 -borderwidth 2 \ 00300 -relief sunk 00301 } 00302 00303 # 00304 # judge bar 00305 # 00306 itk_component add judgeFrame { 00307 frame $itk_component(heading).judgeFrame 00308 } 00309 00310 itk_component add totalWordgraphs { 00311 iwidgets::entryfield $itk_component(judgeFrame).totalWordgraphs \ 00312 -labeltext "Total:" \ 00313 -textvariable [scope _totalWordgraphs] \ 00314 -labelpos w \ 00315 -borderwidth 2 \ 00316 -state disabled \ 00317 -disabledforeground black \ 00318 -width 5 00319 } {} 00320 00321 itk_component add judgeBar { 00322 YadaJudgeBar $itk_component(judgeFrame).judgeBar \ 00323 -height 15 \ 00324 -borderwidth 2 \ 00325 -relief sunk \ 00326 -betterAndFasterBackground $betterAndFasterBackground \ 00327 -betterBackground $betterBackground \ 00328 -betterButSlowerBackground $betterButSlowerBackground \ 00329 -fasterBackground $fasterBackground \ 00330 -softerBackground $softerBackground \ 00331 -sameBackground $sameBackground \ 00332 -harderBackground $harderBackground \ 00333 -slowerBackground $slowerBackground \ 00334 -worseButFasterBackground $worseButFasterBackground \ 00335 -worseBackground $worseBackground \ 00336 -worseAndSlowerBackground $worseAndSlowerBackground \ 00337 -betterForeground $betterForeground \ 00338 -betterAndFasterForeground $betterAndFasterForeground \ 00339 -betterButSlowerForeground $betterButSlowerForeground \ 00340 -fasterForeground $fasterForeground \ 00341 -softerForeground $softerForeground \ 00342 -sameForeground $sameForeground \ 00343 -harderForeground $harderForeground \ 00344 -slowerForeground $slowerForeground \ 00345 -worseButFasterForeground $worseButFasterForeground \ 00346 -worseAndSlowerForeground $worseAndSlowerForeground \ 00347 -worseForeground $worseForeground \ 00348 -weirdForeground $weirdForeground \ 00349 -weirdBackground $weirdBackground 00350 } {} 00351 00352 # packing 00353 grid columnconfigure $itk_component(heading) 1 -weight 1 00354 grid columnconfigure $itk_component(heading) 2 -pad 5 00355 grid columnconfigure $itk_component(heading) 3 -weight 1 00356 grid columnconfigure $itk_component(heading) 4 -pad 5 00357 grid columnconfigure $itk_component(heading) 5 -weight 1 00358 grid columnconfigure $itk_component(heading) 6 -pad 5 00359 grid columnconfigure $itk_component(heading) 7 -weight 1 00360 grid columnconfigure $itk_component(heading) 8 -pad 5 00361 grid columnconfigure $itk_component(heading) 9 -weight 1 00362 grid columnconfigure $itk_component(heading) 10 -pad 5 00363 grid columnconfigure $itk_component(heading) 11 -weight 1 00364 grid columnconfigure $itk_component(heading) 12 -pad 5 00365 grid columnconfigure $itk_component(heading) 13 -weight 1 00366 grid columnconfigure $itk_component(heading) 14 -pad 5 00367 00368 foreach i {1 2} { 00369 grid $itk_component(experiment${i}BoxLabel) \ 00370 -row 0 -column [expr ($i - 1) * 8] -sticky ew -pady 2 00371 grid $itk_component(experiment${i}Box) \ 00372 -row 0 -column [expr ($i - 1) * 8 + 1] -sticky ew -pady 2 -columnspan 5 00373 00374 grid $itk_component(totalTime${i}Label) \ 00375 -row 1 -column [expr ($i - 1) * 8] -sticky ew -pady 2 00376 grid $itk_component(totalTime${i}) \ 00377 -row 1 -column [expr ($i - 1) * 8 + 1] -sticky ew -pady 2 00378 00379 grid $itk_component(score${i}Label)\ 00380 -row 1 -column [expr ($i - 1) * 8 + 2] -sticky ew -pady 2 00381 grid $itk_component(score${i})\ 00382 -row 1 -column [expr ($i - 1) * 8 + 3] -sticky ew -pady 2 00383 00384 grid $itk_component(totalStructRecall${i}Label) \ 00385 -row 1 -column [expr ($i - 1) * 8 + 4] -sticky ew -pady 2 00386 grid $itk_component(totalStructRecall${i}) \ 00387 -row 1 -column [expr ($i - 1) * 8 + 5] -sticky ew -pady 2 00388 00389 grid $itk_component(totalSolTime${i}Label) \ 00390 -row 2 -column [expr ($i - 1) * 8 ] -sticky ew -pady 2 00391 grid $itk_component(totalSolTime${i}) \ 00392 -row 2 -column [expr ($i - 1) * 8 + 1] -sticky ew -pady 2 00393 00394 grid $itk_component(noErrors${i}Label) \ 00395 -row 2 -column [expr ($i - 1) * 8 + 2] -sticky ew -pady 2 00396 grid $itk_component(noErrors${i}) \ 00397 -row 2 -column [expr ($i - 1) * 8 + 3] -sticky ew -pady 2 00398 00399 grid $itk_component(totalLabelledRecall${i}Label) \ 00400 -row 2 -column [expr ($i - 1) * 8 + 4] -sticky ew -pady 2 00401 grid $itk_component(totalLabelledRecall${i}) \ 00402 -row 2 -column [expr ($i - 1) * 8 + 5] -sticky ew -pady 2 00403 00404 grid $itk_component(totalSoftTime${i}Label) \ 00405 -row 3 -column [expr ($i - 1) * 8 ] -sticky ew -pady 2 00406 grid $itk_component(totalSoftTime${i}) \ 00407 -row 3 -column [expr ($i - 1) * 8 + 1] -sticky ew -pady 2 00408 00409 grid $itk_component(noSolutions${i}Label) \ 00410 -row 3 -column [expr ($i - 1) * 8 + 2] -sticky ew -pady 2 00411 grid $itk_component(noSolutions${i}) \ 00412 -row 3 -column [expr ($i - 1) * 8 + 3] -sticky ew -pady 2 00413 00414 grid $itk_component(totalLexicalRecall${i}Label) \ 00415 -row 3 -column [expr ($i - 1) * 8 + 4] -sticky ew -pady 2 00416 grid $itk_component(totalLexicalRecall${i}) \ 00417 -row 3 -column [expr ($i - 1) * 8 + 5] -sticky ew -pady 2 00418 00419 } 00420 00421 grid $itk_component(separator) -sticky ew -row 4 -column 0 -pady 10 -columnspan 14 00422 grid $itk_component(judgeFrame) -sticky ew -row 7 -column 0 -pady 2 -columnspan 14 00423 00424 grid columnconfigure $itk_component(judgeFrame) 1 -weight 1 00425 00426 grid $itk_component(totalWordgraphs) -sticky w -row 0 -column 0 -pady 2 00427 grid $itk_component(judgeBar) -sticky ew -row 0 -column 1 -pady 2 00428 00429 eval itk_initialize $args 00430 .main registerDocument $this 00431 } 00432 00433 ## ---------------------------------------------------------------------------- 00434 ## _judgeRow 00435 ## ---------------------------------------------------------------------------- 00436 body YadaDifference::_judgeRow {row} { 00437 set judge [_getJudgeOfRow $row] 00438 set wordgraph [$itk_component(table) getCell $row,0] 00439 00440 if {$judge == "" || $_doneWordgraph($wordgraph) != 3} { 00441 if {[expr $row % 2]} { 00442 return "default" 00443 } else { 00444 return "colored" 00445 } 00446 } 00447 00448 return $judge 00449 } 00450 00451 00452 ## ---------------------------------------------------------------------------- 00453 ## clear 00454 ## ---------------------------------------------------------------------------- 00455 body YadaDifference::clear {} { 00456 chain ;# call YadaRunnableDocument::clear 00457 00458 # reset the table 00459 set table $itk_component(table) 00460 $table setCell \ 00461 0,0 "wordgraph" \ 00462 0,1 "values" \ 00463 0,2 "score" \ 00464 0,3 "errors" \ 00465 0,4 "time" \ 00466 0,5 "sol.time" \ 00467 0,6 "soft time" \ 00468 0,7 "lex.recall" \ 00469 0,8 "score" \ 00470 0,9 "errors" \ 00471 0,10 "time" \ 00472 0,11 "sol.time" \ 00473 0,12 "soft time" \ 00474 0,13 "lex.recall" \ 00475 0,14 "speed up" \ 00476 0,15 "sol.speed up" \ 00477 0,16 "soft speed up" \ 00478 0,17 "judge" 00479 00480 00481 $table tag config default -anchor e 00482 $table tag config colored -bg gray80 -anchor e 00483 $table tag config better -bg $betterBackground -fg $betterForeground -anchor e -relief flat 00484 $table tag config betterAndFaster -bg $betterAndFasterBackground -fg $betterAndFasterForeground -anchor e -relief flat 00485 $table tag config betterButSlower -bg $betterButSlowerBackground -fg $betterButSlowerForeground -anchor e -relief flat 00486 $table tag config faster -bg $fasterBackground -fg $fasterForeground -anchor e -relief flat 00487 $table tag config softer -bg $softerBackground -fg $softerForeground -anchor e -relief flat 00488 $table tag config harder -bg $harderBackground -fg $harderForeground -anchor e -relief flat 00489 $table tag config worseButFaster -bg $worseButFasterBackground -fg $worseButFasterForeground -anchor e -relief flat 00490 $table tag config worseAndSlower -bg $worseAndSlowerBackground -fg $worseAndSlowerForeground -anchor e -relief flat 00491 $table tag config worse -bg $worseBackground -fg $worseForeground -anchor e -relief flat 00492 $table tag config slower -bg $slowerBackground -fg $slowerForeground -anchor e -relief flat 00493 $table tag config same -bg $sameBackground -fg $sameForeground -anchor e -relief flat 00494 $table tag config weird -bg $weirdBackground -fg $weirdForeground -anchor e -relief flat 00495 00496 $table tag config sel -fg "" -bg "" -relief raised -bd 1 00497 $table tag config active -anchor w -fg black -bg gray -relief sunk -bd 1 00498 $table tag config title -font {-adobe-helvetica-medium-r-normal--12-*-*-*-*-*-*-*} -bg #a3a3a3 -fg white 00499 $table tag config runner -fg red3 -bg #a3a3a3 00500 $table tag config judge -anchor w -bg "" -fg "" 00501 $table tag raise runner title 00502 00503 $table width 0 15 1 5 00504 00505 # reset scores of selected wordgraphs 00506 _resetDataOf "[_getActiveWordgraphs]" 00507 00508 _computeStatistics 00509 00510 } 00511 00512 ## ---------------------------------------------------------------------------- 00513 ## load 00514 ## ---------------------------------------------------------------------------- 00515 body YadaDifference::load {args} { 00516 00517 set table $itk_component(table) 00518 set rmax [$table cget -rows] 00519 set wordgraphsInTable [$table getCell 0,0 $rmax,0] 00520 #$table configure -rowtagcommand "" 00521 00522 # build the list of all available data 00523 if {[llength $args] == 0} { 00524 set activeWordgraphs [_getActiveWordgraphs] 00525 } else { 00526 set activeWordgraphs $args 00527 } 00528 set allWordgraphs "" 00529 set experiments [_getSelectedExperiments] 00530 if {[llength $experiments] != 2} { 00531 return 00532 } 00533 set experiment1 [lindex $experiments 0] 00534 set experiment2 [lindex $experiments 1] 00535 00536 foreach wordgraph $activeWordgraphs { 00537 if {$_doneWordgraph($wordgraph) == 3} { 00538 continue 00539 } 00540 00541 set file1 [$experiment1 getXmlFileName $wordgraph] 00542 set file2 [$experiment2 getXmlFileName $wordgraph] 00543 if {![file exists $file1]} { 00544 set file1 "" 00545 } 00546 if {![file exists $file2]} { 00547 set file2 "" 00548 } 00549 set allFiles($wordgraph,1) $file1 00550 set allFiles($wordgraph,2) $file2 00551 if {$file1 != "" || $file2 != ""} { 00552 lappend allWordgraphs $wordgraph 00553 } 00554 } 00555 00556 # load all xml files 00557 set noLoadedFiles 0 00558 foreach wordgraph $allWordgraphs { 00559 00560 # did we press the break button 00561 if {$_gotBreak} { 00562 unbreakProcess 00563 print "WARNING: interrupted loading\n" 00564 break 00565 } 00566 00567 # load data for both experiments 00568 foreach i {1 2} { 00569 if {($_doneWordgraph($wordgraph) & $i) == $i} { 00570 continue 00571 } 00572 set file $allFiles($wordgraph,$i) 00573 if {$file == ""} { 00574 set _doneWordgraph($wordgraph) [expr $_doneWordgraph($wordgraph) & ~$i] 00575 continue 00576 } 00577 set _doneWordgraph($wordgraph) [expr $_doneWordgraph($wordgraph) | $i] 00578 00579 # say what we do 00580 print "INFO: loading file `$file'\n" 00581 00582 # analyse the file 00583 set fd [open "|zcat $file" r] 00584 set data [read $fd] 00585 close $fd 00586 if {[catch { 00587 set document [dom parse $data] 00588 _analyseDocument $document [subst \$experiment$i] 00589 } errMsg ]} { 00590 print "ERROR: invalid xml file\n" 00591 print "$errMsg\n$::errorInfo" 00592 } 00593 catch { 00594 $document delete 00595 set document "" 00596 } 00597 00598 incr noLoadedFiles 00599 update 00600 } 00601 } 00602 00603 # draw statistics 00604 $itk_component(judgeBar) draw \ 00605 $_fasterWordgraphs $_betterWordgraphs \ 00606 $_betterAndFasterWordgraphs $_betterButSlowerWordgraphs $_softerWordgraphs \ 00607 $_harderWordgraphs $_sameWordgraphs $_worseButFasterWordgraphs \ 00608 $_worseAndSlowerWordgraphs $_worseWordgraphs $_slowerWordgraphs \ 00609 $_weirdWordgraphs 00610 00611 print "INFO: loaded $noLoadedFiles files\n" 00612 #$table configure -rowtagcommand [code $this _judgeRow] 00613 resortRows 00614 _computeStatistics 00615 .main printStatus "" 00616 $table selection clear all 00617 } 00618 00619 ## ---------------------------------------------------------------------------- 00620 ## save 00621 ## ---------------------------------------------------------------------------- 00622 body YadaDifference::save {{fileName ""}} { 00623 return 00624 00625 if {$fileName == "" } { 00626 set types { 00627 {"Xml logfile" {.xml.gz}} 00628 {"CDG logfile" {.log.gz}} 00629 } 00630 set fileName [tk_getSaveFile -filetypes $types -parent .] 00631 if {$fileName == ""} { 00632 return 00633 } 00634 } 00635 00636 } 00637 00638 ## ---------------------------------------------------------------------------- 00639 ## _computeStatistics 00640 ## ---------------------------------------------------------------------------- 00641 body YadaDifference::_computeStatistics {} { 00642 chain 00643 00644 set table $itk_component(table) 00645 set rmax [$table cget -rows] 00646 set cmax [$table cget -cols] 00647 00648 set _totalWordgraphs 0 00649 set _fasterWordgraphs 0 00650 set _betterWordgraphs 0 00651 set _betterAndFasterWordgraphs 0 00652 set _betterButSlowerWordgraphs 0 00653 set _softerWordgraphs 0 00654 set _harderWordgraphs 0 00655 set _sameWordgraphs 0 00656 set _worseWordgraphs 0 00657 set _worseButFasterWordgraphs 0 00658 set _worseAndSlowerWordgraphs 0 00659 set _slowerWordgraphs 0 00660 set _weirdWordgraphs 0 00661 set _noErrors1 0 00662 set _noErrors2 0 00663 set _noSolutions1 0 00664 set _noSolutions2 0 00665 set _totalSolTime1 0 00666 set _totalSolTime2 0 00667 set _totalSoftTime1 0 00668 set _totalSoftTime2 0 00669 set _score1 0.0 00670 set _score2 0.0 00671 set _totalTime1 0 00672 set _totalTime2 0 00673 set _totalStructRecall1 0 00674 set _totalLexicalRecall1 0 00675 set _totalLabelledRecall1 0 00676 set _totalStructRecall2 0 00677 set _totalLexicalRecall2 0 00678 set _totalLabelledRecall2 0 00679 set totalTries1 0 00680 set totalStructHits1 0 00681 set totalLexicalHits1 0 00682 set totalLabelledHits1 0 00683 set totalTries2 0 00684 set totalStructHits2 0 00685 set totalLexicalHits2 0 00686 set totalLabelledHits2 0 00687 00688 for {set row 1} {$row < $rmax} {incr row} { 00689 00690 set dataRow [$table getCell $row,0 $row,$cmax] 00691 set noValues [lindex $dataRow 1] 00692 if {$noValues == ""} { 00693 continue 00694 } 00695 00696 set wordgraph [lindex $dataRow 0] 00697 set noErrors1 [lindex $dataRow 3] 00698 set time1 [lindex $dataRow 4] 00699 set solutionTime1 [lindex $dataRow 5] 00700 set softTime1 [lindex $dataRow 6] 00701 set noErrors2 [lindex $dataRow 9] 00702 set time2 [lindex $dataRow 10] 00703 set solutionTime2 [lindex $dataRow 11] 00704 set softTime2 [lindex $dataRow 12] 00705 set speedUp [lindex $dataRow 14] 00706 set solSpeedUp [lindex $dataRow 15] 00707 set softSpeedUp [lindex $dataRow 16] 00708 set judge [lindex $dataRow 17] 00709 00710 if {$_doneWordgraph($wordgraph) == 3} { 00711 incr _totalWordgraphs 00712 } 00713 incr _noErrors1 $noErrors1 00714 incr _noErrors2 $noErrors2 00715 incr _totalTime1 $time1 00716 incr _totalTime2 $time2 00717 incr _totalSolTime1 $solutionTime1 00718 incr _totalSoftTime1 $softTime1 00719 incr _totalSolTime2 $solutionTime2 00720 incr _totalSoftTime2 $softTime2 00721 00722 set _score1 [expr $_score1 + $_scoreOf($wordgraph,1)] 00723 if {$_scoreOf($wordgraph,1) > 0.0} { 00724 incr _noSolutions1 00725 } 00726 set _score2 [expr $_score2 + $_scoreOf($wordgraph,2)] 00727 if {$_scoreOf($wordgraph,2) > 0.0} { 00728 incr _noSolutions2 00729 } 00730 00731 incr totalTries1 $_triesOf($wordgraph,1) 00732 incr totalStructHits1 $_structHitsOf($wordgraph,1) 00733 incr totalLexicalHits1 $_lexicalHitsOf($wordgraph,1) 00734 incr totalLabelledHits1 $_labelledHitsOf($wordgraph,1) 00735 incr totalTries2 $_triesOf($wordgraph,2) 00736 incr totalStructHits2 $_structHitsOf($wordgraph,2) 00737 incr totalLexicalHits2 $_lexicalHitsOf($wordgraph,2) 00738 incr totalLabelledHits2 $_labelledHitsOf($wordgraph,2) 00739 00740 if {$judge != ""} { 00741 incr _${judge}Wordgraphs 00742 } 00743 } 00744 00745 if {$totalTries1 > 0} { 00746 set _totalStructRecall1 [expr $totalStructHits1 * 100.0 / $totalTries1 ] 00747 set _totalLexicalRecall1 [expr $totalLexicalHits1 * 100.0 / $totalTries1 ] 00748 set _totalLabelledRecall1 [expr $totalLabelledHits1 * 100.0 / $totalTries1 ] 00749 } 00750 if {$totalTries2 > 0} { 00751 set _totalStructRecall2 [expr $totalStructHits2 * 100.0 / $totalTries2 ] 00752 set _totalLexicalRecall2 [expr $totalLexicalHits2 * 100.0 / $totalTries2 ] 00753 set _totalLabelledRecall2 [expr $totalLabelledHits2 * 100.0 / $totalTries2 ] 00754 } 00755 00756 # show statistics 00757 foreach i {1 2} { 00758 set noSolutions [subst \$_noSolutions${i}] 00759 set totalTime [subst \$_totalTime${i}] 00760 set totalSolTime [subst \$_totalSolTime${i}] 00761 set totalSoftTime [subst \$_totalSoftTime${i}] 00762 set score [subst \$_score${i}] 00763 set noErrors [subst \$_noErrors${i}] 00764 set totalStructRecall [subst \$_totalStructRecall${i}] 00765 set totalLexicalRecall [subst \$_totalLexicalRecall${i}] 00766 set totalLabelledRecall [subst \$_totalLabelledRecall${i}] 00767 00768 $itk_component(totalTime${i}) configure -state normal 00769 $itk_component(totalSolTime${i}) configure -state normal 00770 $itk_component(totalSoftTime${i}) configure -state normal 00771 $itk_component(score${i}) configure -state normal 00772 $itk_component(noErrors${i}) configure -state normal 00773 $itk_component(totalStructRecall${i}) configure -state normal 00774 $itk_component(totalLexicalRecall${i}) configure -state normal 00775 $itk_component(totalLabelledRecall${i}) configure -state normal 00776 00777 $itk_component(totalTime${i}) delete 0 end 00778 $itk_component(totalSolTime${i}) delete 0 end 00779 $itk_component(totalSoftTime${i}) delete 0 end 00780 $itk_component(score${i}) delete 0 end 00781 $itk_component(noErrors${i}) delete 0 end 00782 $itk_component(totalStructRecall${i}) delete 0 end 00783 $itk_component(totalLexicalRecall${i}) delete 0 end 00784 $itk_component(totalLabelledRecall${i}) delete 0 end 00785 00786 $itk_component(score${i}) insert 0 [format "%.4f" $score] 00787 $itk_component(noErrors${i}) insert 0 $noErrors 00788 $itk_component(totalTime${i}) insert 0 "[timeToString $totalTime]" 00789 $itk_component(totalSolTime${i}) insert 0 "[timeToString $totalSolTime]" 00790 $itk_component(totalSoftTime${i}) insert 0 "[timeToString $totalSoftTime]" 00791 $itk_component(totalStructRecall${i}) insert 0 [format "%.4f%%" $totalStructRecall] 00792 $itk_component(totalLexicalRecall${i}) insert 0 [format "%.4f%%" $totalLexicalRecall] 00793 $itk_component(totalLabelledRecall${i}) insert 0 [format "%.4f%%" $totalLabelledRecall] 00794 00795 $itk_component(totalTime${i}) configure -state disabled 00796 $itk_component(totalSolTime${i}) configure -state disabled 00797 $itk_component(totalSoftTime${i}) configure -state disabled 00798 $itk_component(score${i}) configure -state disabled 00799 $itk_component(noErrors${i}) configure -state disabled 00800 $itk_component(totalStructRecall${i}) configure -state disabled 00801 $itk_component(totalLexicalRecall${i}) configure -state disabled 00802 $itk_component(totalLabelledRecall${i}) configure -state disabled 00803 } 00804 00805 # redraw the judge canvas 00806 $itk_component(judgeBar) draw \ 00807 $_fasterWordgraphs $_betterWordgraphs \ 00808 $_betterAndFasterWordgraphs $_betterButSlowerWordgraphs $_softerWordgraphs \ 00809 $_harderWordgraphs $_sameWordgraphs $_worseButFasterWordgraphs \ 00810 $_worseAndSlowerWordgraphs $_worseWordgraphs $_slowerWordgraphs \ 00811 $_weirdWordgraphs 00812 00813 } 00814 00815 ## ---------------------------------------------------------------------------- 00816 ## selectExperiment 00817 ## ---------------------------------------------------------------------------- 00818 body YadaDifference::selectExperiment {experimentNo {experimentName ""}} { 00819 set box $itk_component(experiment${experimentNo}Box) 00820 if {$experimentName == ""} { 00821 set experimentName [$box get] 00822 if {$experimentName == ""} { 00823 set experimentName "<none>" 00824 } 00825 } 00826 00827 set prevExperimentName [subst \$_prevExperimentName${experimentNo}] 00828 if {$prevExperimentName != $experimentName} { 00829 set _prevExperimentName${experimentNo} $experimentName 00830 foreach wordgraph [array names _doneWordgraph] { 00831 unset _doneWordgraph($wordgraph) 00832 } 00833 clear 00834 $box clear entry 00835 $box insert entry 0 "$experimentName" 00836 00837 } 00838 00839 set listOfEntries [[$box component list] get 0 end] 00840 set index [lsearch $listOfEntries $experimentName] 00841 00842 if {$index < 0} { 00843 selectExperiment $experimentNo "<none>" 00844 } else { 00845 $box selection set $index $index 00846 } 00847 } 00848 00849 ## ---------------------------------------------------------------------------- 00850 ## activationHandle 00851 ## ---------------------------------------------------------------------------- 00852 body YadaDifference::activationHandle {} { 00853 chain ;# call YadaRunnableDocument::activationHandle 00854 00855 set experimentNames [.main getActiveExperiments] 00856 00857 foreach i {1 2} { 00858 00859 # get the previous selection 00860 set box $itk_component(experiment${i}Box) 00861 set experimentName [$box get] 00862 00863 # default experiments to choose 00864 if {$experimentName == ""} { 00865 set experimentName "<none>" 00866 } 00867 00868 set listOfEntries [[$box component list] get 0 end] 00869 if {$listOfEntries != $experimentNames} { 00870 $box clear list 00871 eval $box insert list end $experimentNames 00872 $box insert entry 0 "$experimentName" 00873 } 00874 } 00875 } 00876 00877 ## ---------------------------------------------------------------------------- 00878 ## _judgeData 00879 ## ---------------------------------------------------------------------------- 00880 body YadaDifference::_judgeData {measure1a measure1b time1 solutionTime1 softTime1 measure2a measure2b time2 solutionTime2 softTime2} { 00881 00882 set significance [.main getSignificance] 00883 00884 # is there an annotation? if not then 00885 if {$measure1a == 0 && $measure2a == 0} { 00886 # ... use scores 00887 set measure1 $measure1b 00888 set measure2 $measure2b 00889 } else { 00890 # ... otherwise use recall 00891 set measure1 $measure1a 00892 set measure2 $measure2a 00893 } 00894 00895 # compare properties 00896 set measureDiff [expr $measure1 - $measure2 ] 00897 set speedUp [_computeSpeedup $time1 $time2] 00898 set solSpeedUp [_computeSpeedup $solutionTime1 $solutionTime2] 00899 set softSpeedUp [_computeSpeedup $softTime1 $softTime2] 00900 00901 # judge 00902 if {$measureDiff > 1e-5} { 00903 if {$solutionTime2 != 0.0} { ;# does experiment 2 give us anything 00904 if {$speedUp < [expr 1.0 / $significance]} { 00905 set judge "betterButSlower" 00906 } elseif {$speedUp > $significance} { 00907 set judge "betterAndFaster" 00908 } else { 00909 set judge "better" 00910 } 00911 } else { 00912 set judge "better" 00913 } 00914 } elseif {$measureDiff < -1e-5} { 00915 if {$solutionTime1 != 0.0} { ;# does experiment 1 give us anything 00916 if {$speedUp > $significance} { 00917 set judge "worseButFaster" 00918 } elseif {$speedUp < [expr 1.0 / $significance]} { 00919 set judge "worseAndSlower" 00920 } else { 00921 set judge "worse" 00922 } 00923 } else { 00924 set judge "worse" 00925 } 00926 } elseif {$speedUp < [expr 1.0 / $significance]} { 00927 set judge "slower" 00928 } elseif {$speedUp > $significance} { 00929 set judge "faster" 00930 } elseif {$solSpeedUp > $significance} { 00931 set judge "softer" 00932 } elseif {$solSpeedUp < [expr 1.0 / $significance]} { 00933 set judge "harder" 00934 } elseif {$softSpeedUp > $significance} { 00935 set judge "softer" 00936 } elseif {$softSpeedUp < [expr 1.0 / $significance]} { 00937 set judge "harder" 00938 } else { 00939 set judge "same" 00940 } 00941 00942 # weirdness check, this relys on measure1b and measure2b to be scores 00943 # measure a: recall 00944 # measure b: score 00945 if {[.main getWeirdness]} { 00946 if {( 00947 $measure1a == 100.0 && 00948 $measure2a < [expr $measure1a - 1e-10] && 00949 $measure1b <= $measure2b 00950 ) || ( 00951 $measure2a == 100.0 && 00952 $measure1a < [expr $measure2a - 1e-10] && 00953 $measure2b <= $measure1b 00954 )} { 00955 set judge "weird" 00956 } 00957 } else { 00958 if {( 00959 $measure2b != 0.0 && 00960 $measure2a < [expr $measure1a - 1e-10] && 00961 $measure1b <= $measure2b 00962 ) || ( 00963 $measure1b != 0.0 && 00964 $measure1a < [expr $measure2a - 1e-10] && 00965 $measure2b <= $measure1b 00966 )} { 00967 set judge "weird" 00968 } 00969 } 00970 00971 return $judge 00972 } 00973 00974 ## ---------------------------------------------------------------------------- 00975 ## _getSelectedExperiments 00976 ## ---------------------------------------------------------------------------- 00977 body YadaDifference::_getSelectedExperiments {} { 00978 00979 set experiments "" 00980 set experimentName [$itk_component(experiment1Box) get] 00981 if {$experimentName != "" && $experimentName != "<none>"} { 00982 lappend experiments [.main getExperiment $experimentName] 00983 } 00984 00985 set experimentName [$itk_component(experiment2Box) get] 00986 if {$experimentName != "" && $experimentName != "<none>"} { 00987 lappend experiments [.main getExperiment $experimentName] 00988 } 00989 00990 return $experiments 00991 } 00992 00993 ## ---------------------------------------------------------------------------- 00994 ## _getWordgraphs 00995 ## ---------------------------------------------------------------------------- 00996 body YadaDifference::_getWordgraphs {} { 00997 00998 set experiments [_getSelectedExperiments] 00999 if {[llength $experiments] != 2} { 01000 return "" 01001 } 01002 01003 set experiment1 [lindex $experiments 0] 01004 set experiment2 [lindex $experiments 1] 01005 01006 # shortcut for two experiments using the same grammar 01007 if {[$experiment1 cget -grammarName] == [$experiment2 cget -grammarName]} { 01008 return [.main getWordgraphsOfExperiment [$experiment1 cget -name]] 01009 } 01010 01011 # compute intersection of the used wordgraphs 01012 set wordgraphs1 [.main getWordgraphsOfExperiment [$experiment1 cget -name]] 01013 set wordgraphs2 [.main getWordgraphsOfExperiment [$experiment2 cget -name]] 01014 01015 set commonWordgraphs "" 01016 foreach wordgraph $wordgraphs1 { 01017 if {[lsearch $wordgraphs2 $wordgraph] >=0} { 01018 lappend commonWordgraphs $wordgraph 01019 } 01020 } 01021 01022 return $commonWordgraphs 01023 } 01024 01025 ## ---------------------------------------------------------------------------- 01026 ## _getJudge 01027 ## ---------------------------------------------------------------------------- 01028 body YadaDifference::_getJudgeOfRow {row} { 01029 set cmax [$itk_component(table) cget -cols] 01030 return [$itk_component(table) getCell $row,$cmax] 01031 } 01032 01033 ## ---------------------------------------------------------------------------- 01034 ## _getTypeOfColumn 01035 ## ---------------------------------------------------------------------------- 01036 body YadaDifference::_getTypeOfColumn {colNo} { 01037 return $_typeOfColumn($colNo) 01038 } 01039 01040 ## ---------------------------------------------------------------------------- 01041 ## _resetDataOf 01042 ## ---------------------------------------------------------------------------- 01043 body YadaDifference::_resetDataOf {wordgraphs} { 01044 chain $wordgraphs 01045 01046 foreach wordgraph $wordgraphs { 01047 foreach experimentNo {1 2} { 01048 set _scoreOf($wordgraph,$experimentNo) 0.0 01049 set _structHitsOf($wordgraph,$experimentNo) 0 01050 set _lexicalHitsOf($wordgraph,$experimentNo) 0 01051 set _labelledHitsOf($wordgraph,$experimentNo) 0 01052 set _triesOf($wordgraph,$experimentNo) 0 01053 } 01054 } 01055 } 01056 01057 ## ---------------------------------------------------------------------------- 01058 ## step 01059 ## ---------------------------------------------------------------------------- 01060 body YadaDifference::step {{wordgraph ""}} { 01061 01062 if {$wordgraph == ""} { 01063 set wordgraph [lindex [_getActiveWordgraphs] 0] 01064 if {$wordgraph == ""} { 01065 return 0 01066 } 01067 } 01068 01069 # check and load 01070 set experiments [_getSelectedExperiments] 01071 if {[llength $experiments] != 2} { 01072 return 0 01073 } 01074 set experiment1 [lindex $experiments 0] 01075 set experiment2 [lindex $experiments 1] 01076 01077 set file1 [$experiment1 getXmlFileName $wordgraph] 01078 set file2 [$experiment2 getXmlFileName $wordgraph] 01079 01080 set machine1 [.main getMachine [$experiment1 cget -machineName]] 01081 set machine2 [.main getMachine [$experiment2 cget -machineName]] 01082 01083 if {[file exists $file1] || [file exists $file2]} { 01084 load $wordgraph 01085 } 01086 01087 # construct the job 01088 if {![file exists $file1]} { 01089 set job1 [YadaJob ::#auto \ 01090 -wordgraphName $wordgraph \ 01091 -experiment $experiment1 \ 01092 -runner $this \ 01093 -machine $machine1 \ 01094 -consumerCommand [code $this _jobConsumer]] 01095 _registerJob $job1 01096 $machine1 queueJob $job1 01097 } 01098 if {![file exists $file2]} { 01099 set job2 [YadaJob ::#auto \ 01100 -wordgraphName $wordgraph \ 01101 -experiment $experiment2 \ 01102 -runner $this \ 01103 -machine $machine2 \ 01104 -consumerCommand [code $this _jobConsumer]] 01105 _registerJob $job2 01106 $machine2 queueJob $job2 01107 } 01108 01109 # start the job 01110 if {$machine1 != $machine2} { 01111 $machine1 startJob 01112 } 01113 $machine2 startJob 01114 01115 # wait 01116 set _isRunning 1 01117 while {$_isRunning} { 01118 vwait [scope _isRunning] 01119 } 01120 01121 # finish message 01122 if {$_gotBreak} { 01123 printMessage "interrupted job(s)" 01124 unbreakJob 01125 } else { 01126 printMessage "finished job(s)" 01127 } 01128 01129 return 1 01130 } 01131 01132 ## ---------------------------------------------------------------------------- 01133 ## run 01134 ## ---------------------------------------------------------------------------- 01135 body YadaDifference::run {} { 01136 set activeWordgraphs [_getActiveWordgraphs] 01137 01138 # get the current experiments 01139 foreach experiment [_getSelectedExperiments] { 01140 01141 # check and load 01142 .main printStatus "... checking experiment '[$experiment cget -name]'" 01143 $experiment check 01144 load 01145 .main printStatus "" 01146 if {[$experiment cget -isComplete]} { 01147 continue 01148 } 01149 01150 # construct all jobs 01151 set machine [.main getMachine [$experiment cget -machineName]] 01152 foreach wordgraph $activeWordgraphs { 01153 set job [YadaJob ::#auto \ 01154 -wordgraphName $wordgraph \ 01155 -experiment $experiment \ 01156 -runner $this \ 01157 -machine $machine \ 01158 -consumerCommand [code $this _jobConsumer]] 01159 _registerJob $job 01160 01161 # queue jobs of the same wordgraph 01162 lappend jobsOfWordgraph($wordgraph) $job 01163 } 01164 } 01165 01166 foreach wordgraph [lsort -dictionary [array names jobsOfWordgraph]] { 01167 set jobs $jobsOfWordgraph($wordgraph) 01168 foreach job $jobs { 01169 set machine [$job cget -machine] 01170 $machine queueJob $job 01171 set machines($machine) "horst" 01172 } 01173 } 01174 01175 foreach $machine [array names machines] { 01176 $machine startJob 01177 } 01178 01179 # wait 01180 set _isRunning 1 01181 while {$_isRunning} { 01182 vwait [scope _isRunning] 01183 } 01184 01185 # finish message 01186 if {$_gotBreak} { 01187 printMessage "interrupted job(s)" 01188 unbreakJob 01189 } else { 01190 printMessage "finished job(s)" 01191 } 01192 } 01193 01194 ## ---------------------------------------------------------------------------- 01195 ## runall 01196 ## ---------------------------------------------------------------------------- 01197 body YadaDifference::runall {} { 01198 set refExperimentName [$itk_component(experiment1Box) get] 01199 01200 # need a ref experiment to run all 01201 if {$refExperimentName == "" || $refExperimentName == "<none>"} { 01202 printMessage "ERROR: need a reference experiment to run all other experiments" error 01203 return 01204 } 01205 01206 set experimentNames [[$itk_component(experiment2Box) component list] get 0 end] 01207 set refExperiment [.main getExperiment $refExperimentName] 01208 01209 # construct possible jobs 01210 set experiments "" 01211 set refExperimentGrammarName [$refExperiment cget -grammarName] 01212 foreach experimentName $experimentNames { 01213 set experiment [.main getExperiment $experimentName] 01214 if {[$experiment cget -grammarName] != $refExperimentGrammarName || 01215 $experimentName == "<none>" || 01216 $experimentName == "" || 01217 $experimentName == $refExperimentName || 01218 ![$experiment cget -isActive]} { 01219 continue 01220 } 01221 01222 # force experiment checking 01223 .main printStatus "... checking experiment `$experimentName'" 01224 if {[$experiment check]} { 01225 continue ;# is complete 01226 } 01227 01228 # construct jobs 01229 lappend experiments $experiment 01230 set noJobs 0 01231 set grammar [.main getGrammar [$experiment cget -grammarName]] 01232 set machine [.main getMachine [$experiment cget -machineName]] 01233 foreach wordgraph [$grammar getSelection] { 01234 set xmlFile [$experiment getXmlFileName $wordgraph] 01235 # dont recompute existing data 01236 if {[file exists $xmlFile]} { 01237 continue 01238 } 01239 01240 set job [YadaJob ::#auto \ 01241 -wordgraphName $wordgraph \ 01242 -experiment $experiment \ 01243 -runner $this \ 01244 -machine $machine \ 01245 -consumerCommand [code $this _jobConsumer]] 01246 _registerJob $job 01247 incr noJobs 01248 } 01249 01250 print "INFO: $experimentName needs $noJobs jobs\n" 01251 } 01252 01253 # confirm batch of jobs 01254 if {![askRunall]} { 01255 foreach experiment [array names _currentJobs] { 01256 foreach job $_currentJobs($experiment) { 01257 _unregisterJob $job 01258 itcl::delete object $job 01259 update ;# this loop could be time consuming 01260 } 01261 } 01262 return 01263 } 01264 01265 # do it 01266 set _timer [clock seconds] 01267 foreach experiment $experiments { 01268 01269 # select experiment 01270 selectExperiment 2 [$experiment cget -name] 01271 load 01272 if {[$experiment cget -isComplete]} { 01273 foreach job $_currentJobs($experiment) { 01274 _unregisterJob $job 01275 itcl::delete object $job 01276 } 01277 continue 01278 } 01279 01280 # queue jobs of the current experiment 01281 foreach job $_currentJobs($experiment) { 01282 set machine [$job cget -machine] 01283 $machine queueJob $job 01284 } 01285 01286 # start 01287 $machine startJob 01288 01289 # wait 01290 set _isRunning 1 01291 while {$_isRunning} { 01292 vwait [scope _isRunning] 01293 } 01294 01295 # escape 01296 if {$_gotBreak} { 01297 break 01298 } 01299 } 01300 01301 # finish message 01302 if {$_gotBreak} { 01303 printMessage "interrupted job(s)" 01304 unbreakJob 01305 } else { 01306 printMessage "finished job(s)" 01307 } 01308 01309 } 01310 01311 01312 ## ---------------------------------------------------------------------------- 01313 ## _jobConsumer 01314 ## ---------------------------------------------------------------------------- 01315 body YadaDifference::_jobConsumer {job} { 01316 $job setState "consuming" 01317 set wordgraph [$job cget -wordgraphName] 01318 set experiment [$job cget -experiment] 01319 set machine [$job cget -machine] 01320 set experiments [_getSelectedExperiments] 01321 set experiment1 [lindex $experiments 0] 01322 set experiment2 [lindex $experiments 1] 01323 01324 01325 # remove the job from the list of current once 01326 unmarkWordgraph $wordgraph 01327 _unregisterJob $job 01328 $machine stopJob $job 01329 01330 # refresh the statistics 01331 if {$experiment == $experiment1} { 01332 set _doneWordgraph($wordgraph) [expr $_doneWordgraph($wordgraph) | 1] 01333 } elseif {$experiment == $experiment2} { 01334 set _doneWordgraph($wordgraph) [expr $_doneWordgraph($wordgraph) | 2] 01335 } else { 01336 # never reach 01337 error "error consuming foreign experiment '$experiment',\nknown experiments are '$experiment1', '$experiment2'" 01338 } 01339 01340 # analyse the new data 01341 set xmlFile [$experiment getXmlFileName $wordgraph] 01342 print "INFO: loading `$xmlFile'\n" 01343 set fd [open "|zcat $xmlFile" r] 01344 set data [read $fd] 01345 close $fd 01346 01347 if {[catch { 01348 set document [dom parse $data] 01349 _analyseDocument $document $experiment 01350 } errMsg ]} { 01351 print "ERROR: invalid xml file\n" 01352 print "$errMsg\n$::errorInfo" 01353 } 01354 catch { 01355 $document delete 01356 set document "" 01357 } 01358 01359 # start a new job 01360 if {!$_gotBreak} { 01361 if {[$machine startJob]} { 01362 return 01363 } 01364 } 01365 01366 # detect finish 01367 if {$_isRunning} { 01368 if {(![info exists _currentJobs($experiment1)] || 01369 [llength $_currentJobs($experiment1)] == 0) 01370 && 01371 (![info exists _currentJobs($experiment2)] || 01372 [llength $_currentJobs($experiment2)] == 0)} { 01373 set _isRunning 0 ;# signal vwait 01374 } 01375 } 01376 } 01377 01378 ## ---------------------------------------------------------------------------- 01379 ## _analyseDocument 01380 ## ---------------------------------------------------------------------------- 01381 body YadaDifference::_analyseDocument {document experiment} { 01382 01383 # default analysis 01384 YadaRunnableDocument::_analyseDocument $document $experiment 01385 01386 # the wordgraph is needed at least 01387 set wordgraph $_analyseResult(wordgraph) 01388 if {$wordgraph == ""} { 01389 print "ERROR: no information available in this run\n" 01390 return 01391 } 01392 01393 # compute derived data 01394 set row [_getRowOfWordgraph $wordgraph] 01395 set dataRow [$itk_component(table) getCell $row,3 $row,13] 01396 set noErrors1 [lindex $dataRow 0] 01397 set time1 [lindex $dataRow 1] 01398 set solutionTime1 [lindex $dataRow 2] 01399 set softTime1 [lindex $dataRow 3] 01400 set noErrors2 [lindex $dataRow 6] 01401 set time2 [lindex $dataRow 7] 01402 set solutionTime2 [lindex $dataRow 8] 01403 set softTime2 [lindex $dataRow 9] 01404 01405 if {$_triesOf($wordgraph,1) == 0} { 01406 set lexicalRecall1 0 01407 } else { 01408 set lexicalRecall1 [expr $_lexicalHitsOf($wordgraph,1) * 100.0 / $_triesOf($wordgraph,1)] 01409 } 01410 if {$_triesOf($wordgraph,2) == 0} { 01411 set lexicalRecall2 0 01412 } else { 01413 set lexicalRecall2 [expr $_lexicalHitsOf($wordgraph,2) * 100.0 / $_triesOf($wordgraph,2)] 01414 } 01415 01416 # save score and edge data 01417 if {[$itk_component(experiment1Box) get] == [$experiment cget -name]} { 01418 set experimentNo 1 01419 } else { 01420 set experimentNo 2 01421 } 01422 set _scoreOf($wordgraph,$experimentNo) $_analyseResult(score) 01423 set _structHitsOf($wordgraph,$experimentNo) $_analyseResult(structHits) 01424 set _lexicalHitsOf($wordgraph,$experimentNo) $_analyseResult(lexicalHits) 01425 set _labelledHitsOf($wordgraph,$experimentNo) $_analyseResult(labelledHits) 01426 set _triesOf($wordgraph,$experimentNo) $_analyseResult(tries) 01427 01428 # overwrite the given experiment data 01429 set score1 $_scoreOf($wordgraph,1) 01430 set score2 $_scoreOf($wordgraph,2) 01431 set time${experimentNo} $_analyseResult(totalTime) 01432 set solutionTime${experimentNo} $_analyseResult(solutionTime) 01433 set softTime${experimentNo} $_analyseResult(softTime) 01434 set noErrors${experimentNo} [expr $_analyseResult(tries) - $_analyseResult(lexicalHits) ] 01435 set lexicalRecall${experimentNo} [expr $_analyseResult(lexicalHits) * 100.0 / $_analyseResult(tries)] 01436 01437 if {($_doneWordgraph($wordgraph) & 1) == 1} { 01438 if {($_doneWordgraph($wordgraph) & 2) == 2} { 01439 set speedUp [_computeSpeedup $time1 $time2] 01440 set solSpeedUp [_computeSpeedup $solutionTime1 $solutionTime2] 01441 set softSpeedUp [_computeSpeedup $softTime1 $softTime2] 01442 set judge [_judgeData \ 01443 $lexicalRecall1 $score1 $time1 $solutionTime1 $softTime1 \ 01444 $lexicalRecall2 $score2 $time2 $solutionTime2 $softTime2] 01445 if {$judge == "weird"} { 01446 print "ERROR: wordgraph '$wordgraph' is weird: score1=$score1 score2=$score2 lexicalRecall1=$lexicalRecall1 lexicalRecall2=$lexicalRecall2\n" 01447 } 01448 } else { 01449 set noErrors2 0 01450 set time2 0 01451 set solutionTime2 0 01452 set softTime2 0 01453 set lexicalRecall2 0 01454 set speedUp 1.0 01455 set solSpeedUp 1.0 01456 set softSpeedUp 1.0 01457 set judge "" 01458 } 01459 } else { 01460 set noErrors1 0 01461 set time1 0 01462 set solutionTime1 0 01463 set softTime1 0 01464 set lexicalRecall1 0 01465 set speedUp 1.0 01466 set solSpeedUp 1.0 01467 set softSpeedUp 1.0 01468 set judge "" 01469 } 01470 01471 # add the collected data to the table 01472 _insertData $wordgraph \ 01473 $_analyseResult(noValues) \ 01474 [format "%4.3e" $score1] \ 01475 $noErrors1 \ 01476 $time1 \ 01477 $solutionTime1 \ 01478 $softTime1 \ 01479 [format "%3.2f" $lexicalRecall1] \ 01480 [format "%4.3e" $score2] \ 01481 $noErrors2 \ 01482 $time2 \ 01483 $solutionTime2 \ 01484 $softTime2 \ 01485 [format "%3.2f" $lexicalRecall2] \ 01486 [format "%.2g" $speedUp] \ 01487 [format "%.2g" $solSpeedUp] \ 01488 [format "%.2g" $softSpeedUp] \ 01489 $judge 01490 } 01491 01492 ## ---------------------------------------------------------------------------- 01493 ## _getDoneWork 01494 ## ---------------------------------------------------------------------------- 01495 body YadaDifference::_getDoneWork {} { 01496 set result "" 01497 foreach {wordgraph experimentNo} [array names _doneWordgraph] { 01498 if {$_doneWordgraph($wordgraph) == 3} { 01499 lappend result $wordgraph 01500 } 01501 } 01502 01503 return $result 01504 } 01505 01506 ## ---------------------------------------------------------------------------- 01507 ## _getUndoneWork 01508 ## ---------------------------------------------------------------------------- 01509 body YadaDifference::_getUndoneWork {} { 01510 set result "" 01511 01512 foreach wordgraph [array names _doneWordgraph] { 01513 if {$_doneWordgraph($wordgraph) != 3} { 01514 lappend result $wordgraph 01515 } 01516 } 01517 01518 return $result 01519 } 01520 01521 ## ---------------------------------------------------------------------------- 01522 ## _viewLogfile: wrapper to YadaRunnableDocument::_viewLogfile 01523 ## ---------------------------------------------------------------------------- 01524 body YadaDifference::_viewLogfile {} { 01525 chain [_getSelectedExperiments] 01526 } 01527 01528 ## ---------------------------------------------------------------------------- 01529 ## _viewXmlfile: wrapper to YadaRunnableDocument::_viewXmlfile 01530 ## ---------------------------------------------------------------------------- 01531 body YadaDifference::_viewXmlfile {} { 01532 chain [_getSelectedExperiments] 01533 } 01534 01535 ## ---------------------------------------------------------------------------- 01536 ## _traceProcess 01537 ## ---------------------------------------------------------------------------- 01538 body YadaDifference::_traceProcess {} { 01539 # TODO 01540 }