aac-metrics 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52fb3c41b9427605e9a78c258c5f4e5d7303c98f8988b52aba750597cb164900
-  data.tar.gz: 60ccc8a6c1dd2c25d29dd159134c7953e133a1f7a0bb9d710696807f853e8139
+  metadata.gz: 177d88edba43f47e65e7080652f63cb7405056e7ba8d1d7f50e415082ecbecb9
+  data.tar.gz: 0420f4f6af64452a82a5546d35b99240771094389c9fdb88938ccd862803ac03
 SHA512:
-  metadata.gz: ac227f5770623d9df36635c92f71aa7a122404fa40f006dce31432be0bd17b6199c0c16ec6a4f5c777f19255106bf1c7f8811bfe4972996b9d12980a75b2911a
-  data.tar.gz: fd2ef145c944fea960a30282b6f3960f313d5f6f44d0db13f3a4581909744e127455010371d5b4138e546132a2e8d4cfb26ec291793f9ff83b970b54d47aeed9
+  metadata.gz: c28f80c87ca6e0a151913f4c6637b76d54e5b8658afb415c2ae3a9062289cc2d958e28f9108dfd7750723bbf3a15826555e48c44453f9ba049ce6e65955803a9
+  data.tar.gz: 8601390c7d6e9f78ab69157e71a0d4bab67dae0af250c5068a03b71108113ba17b815ec588d34554126ee1b264a8fbc07c8a86c17b3f59da96a16389b604c1a9

data/lib/aac-metrics/loader.rb

@@ -187,7 +187,10 @@ module AACMetrics::Loader
                   puts "Link found with no access #{btn['load_board'].to_json}"
                 end
                 new_btn['load_board']['temporary_home'] = true if new_btn['load_board'] && btn['load_board']['temporary_home']
+                new_btn['load_board']['temporary_home'] = true if new_btn['load_board'] && btn['ext_coughdrop_home_lock']
                 new_btn['load_board']['add_to_sentence'] = true if new_btn['load_board'] && btn['load_board']['add_to_sentence']
+                new_btn['load_board']['add_to_sentence'] = true if new_btn['load_board'] && btn['ext_coughdrop_add_to_vocalization']
+                new_btn['load_board']['add_to_sentence'] = true if new_btn['load_board'] && btn['ext_coughdrop_add_vocalization']
               elsif btn['action']
                 # TODO: track keyboard actions and don't
                 # treat action buttons for metrics
@@ -327,6 +330,7 @@ module AACMetrics::Loader
     path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'sets', "common_words.#{locale}.json"))    
     res = JSON.parse(File.read(path)) rescue nil
     if !res || res['version'] != AACMetrics::VERSION || res['files'] != files
+      # When version changes or the file list changes, regenerate
       efforts = {}
       common_words = nil
       common_paths.each do |path|
@@ -342,7 +346,8 @@ module AACMetrics::Loader
       end
       common_words -= ['']
       efforts.each do |word, vals|
-        if vals.length == common_paths.length
+        # If a word is in 80% of the common vocabs, include it in the list
+        if vals.length >= (common_paths.length * 0.8)
           efforts[word] = vals.sum.to_f / vals.length
         else
           efforts.delete(word)
@@ -398,7 +403,7 @@ module AACMetrics::Loader
     list = JSON.parse(File.read(path))
     list.each do |set|
       set['categories'].each do |cat|
-        all_words += cat['words']
+        all_words += cat['words'].sort unless cat['id'] == 'aggregate'
       end
     end
     all_words.uniq!

data/lib/aac-metrics/metrics.rb

@@ -1,14 +1,8 @@
 # TODO:
 # Qualitative evaluation criteria:
-# - this set looks easy to learn for communicators
-# - this set looks easy to learn for supporters
-# - this vocabulary organization of this set makes sense
 # - this set provides clear locations for user-specific words to be added
 # - this set supports the use of grammatical forms (tenses and other inflections)
 # - this set provides predefined simplification for beginning communicators
-# - this set allows for long-term vocabulary growth over time
-# - this vocabulary looks like it will work well for young users
-# - this vocabulary looks like it will work well for adult users
 
 # Effort algorithms for scanning/eyes
 module AACMetrics::Metrics
@@ -139,7 +133,8 @@ module AACMetrics::Metrics
       analysis_version: AACMetrics::VERSION,
       locale: locale,
       total_boards: total_boards,
-      total_buttons: buttons.length,
+      total_buttons: buttons.map{|b| b[:count] || 1}.sum,
+      total_words: buttons.map{|b| b[:label] }.uniq.length,
       reference_counts: set_refs,
       grid: {
         rows: root_rows,
@@ -360,6 +355,7 @@ module AACMetrics::Metrics
                   label: word,
                   level: board[:level],
                   effort: effort,
+                  count: ((existing || {})[:count] || 0) + 1
                 }
                 # If a board set has any temporary_home links,
                 # then that can possibly affect the effort
@@ -458,6 +454,7 @@ module AACMetrics::Metrics
     compare = AACMetrics::Metrics.analyze(compset, false)
     res[:comp_boards] = compare[:total_boards]
     res[:comp_buttons] = compare[:total_buttons]
+    res[:comp_words] = compare[:total_words]
     res[:comp_grid] = compare[:grid]
     
     compare_words = []
@@ -625,11 +622,11 @@ module AACMetrics::Metrics
         end
 
         # Calculate the effort for the target and comp sets
-        effort, level = best_match(word, target_efforts, nil, synonyms)
+        effort, level, fallback = best_match(word, target_efforts, nil, synonyms)
         reffort = effort
         list_effort += effort
 
-        effort, level = best_match(word, comp_efforts, nil, synonyms)
+        effort, level, fallback = best_match(word, comp_efforts, nil, synonyms)
         comp_effort += effort
         # puts "#{word} - #{reffort.round(1)} - #{effort.round(1)}"
       end
@@ -657,11 +654,13 @@ module AACMetrics::Metrics
     res[:sentences] = []
     sentences.each do |words|
       sequence = best_combo(words, target_efforts, target_levels, synonyms)
-      target_effort_score = sequence.map{|w, e| e }.sum.to_f / words.length.to_f
+      target_effort_score = sequence[:list].map{|w, e| e }.sum.to_f / words.length.to_f
+      typing = sequence[:fallback]
       sequence = best_combo(words, comp_efforts, comp_levels, synonyms)
-      comp_effort_score = sequence.map{|w, e| e }.sum.to_f / words.length.to_f
+      comp_effort_score = sequence[:list].map{|w, e| e }.sum.to_f / words.length.to_f
+      comp_typing = sequence[:fallback]
 
-      res[:sentences] << {sentence: words.join(' '), words: words, effort: target_effort_score, comp_effort: comp_effort_score}
+      res[:sentences] << {sentence: words.join(' '), words: words, effort: target_effort_score, typing: typing, comp_effort: comp_effort_score, comp_typing: comp_typing}
     end
     res[:care_components][:sentences] = res[:sentences].map{|s| s[:effort] }.sum.to_f / res[:sentences].length.to_f * 3.0
     target_effort_tally += res[:care_components][:sentences]
@@ -669,14 +668,16 @@ module AACMetrics::Metrics
     comp_effort_tally += res[:care_components][:comp_sentences]
 
     res[:fringe_words] = []
+    res[:missing]['fringe'] = {name: "Fringe Large Possible Corpus", list: []}
     fringe.each do |word|
       target_effort_score = 0.0
       comp_effort_score = 0.0
 
-      effort, level = best_match(word, target_efforts, nil, synonyms)
+      effort, level, fallback = best_match(word, target_efforts, nil, synonyms)
       target_effort_score += effort
+      res[:missing]['fringe'][:list] << word if fallback
 
-      effort, level = best_match(word, comp_efforts, nil, synonyms)
+      effort, level, fallback = best_match(word, comp_efforts, nil, synonyms)
       comp_effort_score += effort
       res[:fringe_words] << {word: word, effort: target_effort_score, comp_effort: comp_effort_score}
     end
@@ -686,13 +687,15 @@ module AACMetrics::Metrics
     comp_effort_tally += res[:care_components][:comp_fringe]
 
     res[:common_fringe_words] = []
+    res[:missing]['common_fringe'] = {name: "High-Use Fringe Corpus", list: []}
     common_fringe.each do |word|
       target_effort_score = 0.0
       comp_effort_score = 0.0
-      effort, level = best_match(word, target_efforts, nil, synonyms)
+      effort, level, fallback = best_match(word, target_efforts, nil, synonyms)
       target_effort_score += effort
+      res[:missing]['common_fringe'][:list] << word if fallback
 
-      effort, level = best_match(word, comp_efforts, nil, synonyms)
+      effort, level, fallback = best_match(word, comp_efforts, nil, synonyms)
       comp_effort_score += effort
       res[:common_fringe_words] << {word: word, effort: target_effort_score, comp_effort: comp_effort_score}
     end
@@ -730,11 +733,16 @@ module AACMetrics::Metrics
         end
       end
     end
+    used_fallback = false
+
     # Fallback penalty for missing word
     fallback_effort = spelling_effort(word)
-    effort = fallback_effort if !effort || fallback_effort < effort
+    if !effort || fallback_effort < effort
+      used_fallback = true
+      effort = fallback_effort 
+    end
 
-    [effort, level || 0]
+    [effort, level || 0, used_fallback]
   end
 
   def self.best_combo(words, efforts, levels, synonyms)
@@ -758,26 +766,28 @@ module AACMetrics::Metrics
             options << {
               next_idx: idx + combo[:size],
               list: option[:list] + [[combo[:partial], combo[:effort]]],
-              temporary_home_id: combo[:temporary_home_id]
+              temporary_home_id: combo[:temporary_home_id],
+              fallback: option[:fallback]
             }
           end
-          effort, level = best_match(words[idx], efforts, levels, synonyms)
+          effort, level, fallback = best_match(words[idx], efforts, levels, synonyms)
           option[:temporary_home_id] = effort.instance_variable_get('@temp_home_id')
+          option[:fallback] = true if fallback
           effort += BOARD_CHANGE_PROCESSING_EFFORT if idx > 0 && level && level > 0
           if home_id
             effort += BOARD_HOME_EFFORT + BOARD_CHANGE_PROCESSING_EFFORT
-            other_effort, other_level = best_match(words[idx], efforts["H:#{home_id}"] || {}, levels["H:#{home_id}"] || {}, synonyms)
+            other_effort, other_level, other_fallback = best_match(words[idx], efforts["H:#{home_id}"] || {}, levels["H:#{home_id}"] || {}, synonyms)
             new_home_id = other_effort.instance_variable_get('@temp_home_id') || home_id
             other_effort += BOARD_CHANGE_PROCESSING_EFFORT if idx > 0 && other_level && other_level > 0
             other_list = option[:list] + [[words[idx], other_effort]]
-            options << {next_idx: idx + 1, list: other_list, temporary_home_id: new_home_id}
+            options << {next_idx: idx + 1, list: other_list, temporary_home_id: new_home_id, fallback: option[:fallback] || other_fallback}
           end
           option[:list] << [words[idx], effort]
           option[:next_idx] = idx + 1
         end
       end
     end
-    options.sort_by{|o| o[:list].map{|w, e| e}.sum }.reverse[0][:list]
+    options.sort_by{|o| o[:list].map{|w, e| e}.sum }.reverse[0]
   end
 
   # Checks if any buttons will work for multiple words in a sentence

data/sets/ac99-3db3a9ef48.obfset

@@ -87509,7 +87509,7 @@
       },
       {
         "id": "btn10",
-        "label": "$3fd14da919"
+        "label": "$c18788c2f2"
       },
       {
         "id": "btn11",