Class: FeldtRuby::Optimize::StdOutLogger

Inherits:
Object
  • Object
show all
Defined in:
lib/feldtruby/optimize/stdout_logger.rb

Defined Under Namespace

Classes: DummyStream

Instance Method Summary collapse

Constructor Details

#initialize(optimizer, verbose = true) ⇒ StdOutLogger

Returns a new instance of StdOutLogger.



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 11

def initialize(optimizer, verbose = true)
	@optimizer = optimizer
	@verbose = verbose
	@start_time = Time.now # To ensure we have a value even if optimizer forgot calling note_optimization_starts
	@events = Hash.new(0)
	# Old version of Time does not take a data as argument so use utc for those cases
	if RUBY_VERSION < "1.9"
		@last_report_time = Hash.new(Time.utc(1970, "jan", 1))
	else			
		@last_report_time = Hash.new(Time.new("1970-01-01")) # Maps event strings to the last time they were reported on, used by anote.
	end
	if verbose
		@outstream = STDOUT
	else
		@outstream = DummyStream.new
	end
end

Instance Method Details

#adaptive_note(frequency, msg, values = []) ⇒ Object

Adaptive notes are recorded as any (normal) notes but is only reported to the user in a readable manner i.e. the frequency of reporting them is limited.



55
56
57
58
59
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 55

def adaptive_note(frequency, msg, values = [])
	should_print = elapsed_since_last_reporting_of(msg) > frequency
	@last_report_time[msg] = Time.now if should_print
	internal_note should_print, msg, values
end

#anote(msg, *values) ⇒ Object 



61
62
63
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 61

def anote(msg, *values)
	adaptive_note(2.0, msg, values)
end

#elapsed_since_last_reporting_of(msg) ⇒ Object 



65
66
67
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 65

def elapsed_since_last_reporting_of(msg)
	Time.now - @last_report_time[msg]
end

#elapsed_time ⇒ Object 



140
141
142
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 140

def elapsed_time
	Time.now - @start_time
end

#event_stat_in_relation_to_step(eventCount) ⇒ Object 



84
85
86
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 84

def event_stat_in_relation_to_step(eventCount)
	"#{eventCount} times (%.3f times/step)" % (eventCount.to_f / num_steps)
end

#event_summary_to_str ⇒ Object 



80
81
82
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 80

def event_summary_to_str()
	"Event counts:\n    " + @events.to_a.map {|key,count| "#{key}: #{event_stat_in_relation_to_step(count)}"}.join("\n    ")
end

#info_about_candidate(candidate, qualityValue, subQualityValues, nameString = "new") ⇒ Object 



88
89
90
91
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 88

def info_about_candidate(candidate, qualityValue, subQualityValues, nameString = "new")
	info_str = nameString ? "#{nameString} = #{candidate.inspect}\n  " : "  "
	info_str + candidate._quality_value.inspect
end

#internal_note(shouldPrint, msg, values) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 34

def internal_note(shouldPrint, msg, values)
	@events[msg] += 1
	if (values.all? {|e| String === e})
		vstr = values.join("\n  ")
	else
		vstr = values.inspect
	end
	if msg == "."
		# Just a tick so no event stat etc
		log_print( msg ) if shouldPrint
	else
		log( "#{event_stat_in_relation_to_step(@events[msg])}: #{msg}\n  #{vstr}", true ) if shouldPrint
	end
end

#log(str, newlineBefore = false, newlineAfter = true) ⇒ Object 



120
121
122
123
124
125
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 120

def log(str, newlineBefore = false, newlineAfter = true)
	@outstream.puts "" if newlineBefore
	@outstream.print "#{Time.timestamp({:short => true})} #{num_steps}: (#{Time.human_readable_timestr(elapsed_time)}), #{str}"
	@outstream.puts "" if newlineAfter
	@outstream.flush
end

#log_print(str) ⇒ Object 



127
128
129
130
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 127

def log_print(str)
	@outstream.print str
	@outstream.flush
end

#note(msg, *values) ⇒ Object 



49
50
51
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 49

def note(msg, *values)
	internal_note true, msg, values
end

#note_another_optimization_step(stepNumber) ⇒ Object 



107
108
109
110
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 107

def note_another_optimization_step(stepNumber)
	@events['Optimization steps'] += 1 # we note it by hand since we are printing something different than the event name
	adaptive_note(0.1, '.')
end

#note_end_of_optimization(optimizer) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 69

def note_end_of_optimization(optimizer)
	best_msg = info_about_candidate(optimizer.best, optimizer.best_quality_value, 
		optimizer.best_sub_quality_values, "best")
	note("End of optimization", "Optimizer: #{optimizer.class}", 
		best_msg, 
		event_summary_to_str(),
		"Time used = #{Time.human_readable_timestr(elapsed_time)}, " + 
		"Steps performed = #{num_steps}, " + 
		"#{Time.human_readable_timestr(time_per_step, true)}/step")
end

#note_new_best(newBest, newQv, newSubQvs, oldBest = nil, oldQv = nil, oldSubQvs = nil) ⇒ Object 



98
99
100
101
102
103
104
105
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 98

def note_new_best(newBest, newQv, newSubQvs, oldBest = nil, oldQv = nil, oldSubQvs = nil)
	new_best_msg = info_about_candidate(newBest, newQv, newSubQvs, "new")
	if oldBest
		new_best_msg += ",\n  supplants old best\n  #{oldQv.inspect}"
		new_best_msg += "\n  #{newQv.improvement_in_relation_to(oldQv)}\n"
	end
	anote("Found new best", new_best_msg)
end

#note_new_better(betterMsg, newBetter, newQv, newSubQvs) ⇒ Object 



93
94
95
96
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 93

def note_new_better(betterMsg, newBetter, newQv, newSubQvs)
	new_better_msg = info_about_candidate(newBetter, newQv, newSubQvs, nil)
	anote(betterMsg, new_better_msg)
end

#note_optimization_starts ⇒ Object 



29
30
31
32
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 29

def note_optimization_starts
	log("Optimization with optimizer #{@optimizer.class.inspect} started")
	@start_time = Time.now
end

#note_termination(message) ⇒ Object 



116
117
118
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 116

def note_termination(message)
	log(message, true)
end

#num_steps ⇒ Object 



132
133
134
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 132

def num_steps
	@events['Optimization steps']
end

#quality_values_to_str(qv, subQvs) ⇒ Object 



112
113
114
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 112

def quality_values_to_str(qv, subQvs)
	"q = %.4f, subqs = %s" % [qv, subQvs.map {|v| v.round_to_decimals(4)}.inspect]
end

#time_per_step ⇒ Object 



136
137
138
 
# File 'lib/feldtruby/optimize/stdout_logger.rb', line 136

def time_per_step
	elapsed_time / num_steps
end