本文整理汇总了Python中utils.Logger.set方法的典型用法代码示例。如果您正苦于以下问题:Python Logger.set方法的具体用法?Python Logger.set怎么用?Python Logger.set使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类utils.Logger
的用法示例。
在下文中一共展示了Logger.set方法的8个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: select_ofdm_params
# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
def select_ofdm_params(self):
parsed = {}
# parse, calculate mean and avg
for tup, blk in self.bulk_corr.items():
fft_length = tup[0]
cp_length = tup[1]
if blk:
m, e = calculate_avg_std( blk )
parsed[ tup ] = (m, e, m/e)
ofdm_tup = None
max_sum = float("-inf")
for tup, data in parsed.iteritems():
if data[0] > max_sum:
ofdm_tup = tup
max_sum = data[0]
if ofdm_tup:
self.LOGGER[ofdm_tup][1] += 1.0
Logger.set("correlator", "sel_" + self.LOGGER[ofdm_tup][0], self.LOGGER[ofdm_tup][1])
self.LOGGER["sel_total"] += 1.0
if ofdm_tup == THE_TUPLE:
self.LOGGER["sel_hit"] += 1.0
else:
self.LOGGER["sel_error"] += 1.0
Logger.set("correlator", "sel_hit" , self.LOGGER["sel_hit"])
Logger.set("correlator", "sel_error", self.LOGGER["sel_error"])
Logger.set("correlator", "sel_total", self.LOGGER["sel_total"])
示例2: decision
# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
def decision(self, data_l, data_m):
"""
Function called from a signal processing block.
@param data_l Learner decision regarding channel occupancy.
@param data_m Manager decision regarding channel occupancy.
"""
self.strategy.wait()
self._iteraction += 1
final_dec = data_l
if self._valid_feedback:
final_dec = data_m
self._time += 19.3
self._count += 1
Logger.set('feedback_algorithm', 'total_feedback', self._count)
Logger.append('feedback_algorithm', 'activation', int(data_m))
# set feedback in our learning algorithm
self.learner.feedback = data_m
# Increase feedback interval if both algorithms are correct
if data_l == data_m:
self.strategy.increase_time()
# else decrease time
else:
self.strategy.decrease_time()
else:
Logger.append('feedback_algorithm', 'activation', -1)
self._time += 0.2
self._valid_feedback = False
if self.strategy.feedback():
self._manager.enable(True)
self._valid_feedback = True
Logger.append('feedback_algorithm', 'time', self._time)
Logger.append('feedback_algorithm', 'count', self._count)
Logger.append('bayes_decision', 'hypothesis', final_dec)
示例3: work
# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
def work(self, input_items, output_items):
"""
@param input_items
@param output_items
"""
for idx in range(len(input_items[0])):
self._iteraction += 1
ed_dec = input_items[0][idx][0]
wf = input_items[1][idx]
final_dec = ed_dec
if ed_dec == 0:
final_dec = 1
final_dec = self._algorithm.decision(wf)[0]
Logger.set('feedback_algorithm', 'total_feedback', self._count)
Logger.append('bayes_decision', 'hypothesis', final_dec)
return len(input_items[0])
示例4: OptionParser
# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
if __name__ == "__main__":
parser = OptionParser()
parser.add_option("", "--test-duration", type="int", default=600,
help="Test Duration.")
parser.add_option("", "--iteration", type="int", default=0,
help="Iteration")
parser.add_option("", "--sending-duration", type="int", default=5,
help="Sending duration during each transmittion.")
(options, args) = parser.parse_args()
globs.options = options
Logger._enable = True
Logger.register('bs', ['channel_count', 'links', 'it_dur', 'total_iterations', 'interference_count',
'interference_time', 'interference_hit_count', 'interference_hit_time', 'decision_time',
'tx_and_rx_pkts'])
main(options)
Logger.set('bs', 'channel_count', globs.p_channels_count)
Logger.set('bs', 'total_iterations', globs.p_total_iterations)
Logger.set('bs', 'interference_count', globs.p_channels_interference_count)
Logger.set('bs', 'interference_time', globs.p_channels_interference_time)
Logger.set('bs', 'interference_hit_count', globs.p_channels_interference_hit_count)
Logger.set('bs', 'interference_hit_time', globs.p_channels_interference_hit_time)
Logger.dump('./results/', 'bs_burst_' + str(options.sending_duration) + '_it_' + str(options.iteration))
os._exit(1)
示例5: parse_file
# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
THE_TUPLE = (options.fft_length, options.cp_length)
MAX_PARSED_SAMPLES = options.max_parsed
import yaml
noise = yaml.load(open("noise.txt", "r"))
options.threshold = noise[options.ebn0][0.9]
Logger._enable = True
print "#### TESTING WITH EBN0 %f, IT %d" % (options.ebn0, options.it)
tin = time.clock()
tb.start()
parse_file(options)
#Save correlation to a file
tfin = time.clock()
Logger.set('global', 'clock', tfin - tin)
Logger._enable = False
tb.stop()
tb.wait()
print "### STOPPED"
d = "from_file/ebn0_%d/" % options.ebn0
sd = "%d_%d" % (options.fft_length, options.cp_length)
Logger.dump(d, sd, options.it)
radio.estimator.dump(options)
示例6: cognitive_radio_loop
# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
def cognitive_radio_loop(options, radio, channel_list):
"""
Program loop here.
@param options
@param radio A RadioDevice instance.
@param channel_list List of Channel objects.
"""
# Export my server
command = callback_radio(radio)
my_rpc = RPCExporter(addr=("143.54.83.30", 8000 + options.my_id))
my_rpc.register_function('command', command)
my_rpc.start()
# Wait broker start
while not command.run:
1
####
#Import OTHER RADIOS RPCS
####
rpc_arr = []
for i in [0, 1, 2, 3]:
rpc_cli = RPCImporter(addr="http://%s:%d" % (HOSTS_IP[i], 8000 + i))
rpc_cli.register_function('command')
rpc_arr.append(rpc_cli)
# Import PassiveRadio RPC calls
bs_rpc = RPCImporter(addr="http://%s:9000" % (options.broker_ip))
bs_rpc.register_function('command')
# Register parameters for transmission
Logger.register('radio', ['tx_pkts', 'rx_pkts', 'rx2_pkts', 'channel', 'operation', 'receiver', 'starving',
'total_tx', 'total_rx', 'total_starving'])
# loop
pkt_len = options.pkt_len
payload = struct.pack('%sB' % pkt_len, *[options.my_id] * pkt_len)
print '##### Entering Transmitter loop'
c_starving = 0
while command.run:
"""
######## FUNCOES:
---- BW do canal
---- Channel's bandwidth.
radio.get_bandwidth()
---- Num. simbolos na modulacao
--- Number of symbols in the modulation.
radio.{tx,rx}.symbols()
---- B/S da modulacao
---- B/S of the modulation
radio.{tx,rx}.bits_per_symbol()
---- Pkt/s NO ULTIMO SEGUNDO
---- Pkt/s in the last second.
radio.{tx,rx}.counter.get_pkts()
---- b/s NO ULTIMO SEGUNDO.
---- b/s in the last second.
radio.{tx,rx}.counter.get_bps()
---- Pacotes acumulados desde a ultima chamada.
---- Accumulated packages since the last call.
radio.{tx,rx}.counter.get_pkt_accumulated(clear = False)
---- Troca de canal. channel eh um objeto Channel
---- Channel changing. channel is a Channel object.
radio.set_channel(channel)
#################
"""
# sense
while not command.sense and command.run:
1
if not command.run:
break
sense_data = []
radio.set_gain(0)
for channel in channel_list:
decision, energy = radio.ss.sense_channel(channel, 0.1)
sense_data.append((decision, float(energy), channel.get_channel()))
bs_rpc.command([options.my_id, 'sense_data', sense_data])
# CHOOSE RECEIVER
#while not command.request_transmission:
# 1
# Select a receiver randomly
#opt = [0, 1, 2, 3]
#opt.remove(options.my_id)
#receiver = random.choice(opt)
#print '##### DEVICE %d requesting TX to %d' % (options.my_id, receiver)
#.........这里部分代码省略.........
示例7: receiver_loop
# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
def receiver_loop(tb, channel_list, channel, options):
"""
UP LOOP
@param tb
@param channel_list
@param channel
@param options
"""
import xmlrpclib
from SimpleXMLRPCServer import SimpleXMLRPCServer
class MyNamespace:
"""
"""
pass
g_namespace = MyNamespace()
g_namespace.tb = tb
g_namespace.options = options
g_namespace.server_run = True
class StoppableXMLRPCServer(SimpleXMLRPCServer):
"""Override of TIME_WAIT"""
allow_reuse_address = True
def __init__(self, options):
SimpleXMLRPCServer.__init__(self, options)
self.stop = False
def serve_forever(self):
while not self.stop:
self.handle_request()
print 'exiting server'
def shutdown(self):
self.stop = True
return 0
server = StoppableXMLRPCServer((options.slave_addr, 8000))
g_namespace.th = Thread(target=server.serve_forever )
# Flag que indica quando a execucao deve parar
# Flag that indicates when the execution must stop.
g_namespace.run = False
g_namespace.interferer_channel = 0
def set_channel(channel):
"""
RPC for changing the channel.
@param channel
"""
print "Received command to handoff to channel ", channel
if not g_namespace.options.tx_only:
g_namespace.tb.tx.center_freq = channel_list[channel]
g_namespace.tb.rx.center_freq = channel_list[channel]
g_namespace.interferer_channel = channel
return 1
def close_app():
"""
Closes the app.
"""
print "Received command to close"
g_namespace.run = False
return 1
def client_started():
"""
Notifies that the execution has started.
"""
g_namespace.run = True
return 1
Logger.register('receiver', ['channel', 'pkt', 'start_time'])
Logger.set('receiver', 'start_time', time.time())
# Registra funcoes no servidor XML e inicia thread do servidor
# Registers functions in the XML server and starts the server thread.
server.register_function(set_channel, 'set_channel')
server.register_function(close_app, 'close_app')
server.register_function(client_started, 'client_started')
g_namespace.th.start()
print "Receiver listening for commands in port 8000"
print "\t... Waiting for client_started call"
while g_namespace.run == False:
1;
print "\t...client connected"
global t_rcv, t_cor
channel = 0
#.........这里部分代码省略.........
示例8: open
# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
tb, radio, correlator = OpERAUtils.device_definition(options)
Logger._enable = True
tin = time.clock()
tb.start()
try:
print "### STARTED"
while correlator.enable:
print correlator.total_parsed
time.sleep(1)
except KeyboardInterrupt:
pass
# Save correlation to a file
tfin = time.clock()
Logger.set("global", "clock", tfin - tin)
Logger._enable = False
tb.stop()
tb.wait()
print "### STOPPED"
radio.estimator.dump(options)
CONVERT_FILES[fad][att] += 1
with open("parsed_files_lte.log", "w+") as fd:
fd.write(yaml.dump(CONVERT_FILES))
import shutil