class Server():
def __init__(self):
self.config = Configure()
self.start_server, self.client_ip, self.server_name, self.server_pass = self.config.read_server()
if self.start_server == False:
sys.exit()
say('Starting Server')
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = ''
self.port = 5150
self.server.bind((self.host, self.port))
self.server.listen(5)
print 'Listing for a client...'
self.client, self.addr = self.server.accept()
print 'Accepted connection from ', self.addr
self.client.send(str.encode('Connection made with Andy'))
def get_cmd(self):
try:
self.data = self.client.recv(1024)
except:
print 'Lost Connection with ', self.addr
return None
print 'Recieved data from client: ', bytes.decode(self.data)
return bytes.decode(self.data)
def end(self):
print 'Closing connection...'
self.client.close()
class Server():
def __init__(self):
self.config = Configure()
self.start_server, self.client_ip, self.server_name, self.server_pass = self.config.read_server(
)
if self.start_server == False:
sys.exit()
say('Starting Server')
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = ''
self.port = 5150
self.server.bind((self.host, self.port))
self.server.listen(5)
print('Listing for a client...')
self.client, self.addr = self.server.accept()
print('Accepted connection from ', self.addr)
self.client.send(str.encode('Connection made with Andy'))
def get_cmd(self):
try:
self.data = self.client.recv(1024)
except:
print('Lost Connection with ', self.addr)
return None
print('Recieved data from client: ', bytes.decode(self.data))
return bytes.decode(self.data)
def end(self):
print('Closing connection...')
self.client.close()
def __init__(self):
self.config = Configure()
self.start_server, self.client_ip, self.server_name, self.server_pass = self.config.read_server(
)
if self.start_server == False:
sys.exit()
say('Starting Server')
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = ''
self.port = 5150
self.server.bind((self.host, self.port))
self.server.listen(5)
print('Listing for a client...')
self.client, self.addr = self.server.accept()
print('Accepted connection from ', self.addr)
self.client.send(str.encode('Connection made with Andy'))
class Util(object):
'''
工具类，这么个破东西，整个还像个样子，doubi
'''
config = Configure()
_m_days_o = [31, 28, 31, 30, 31, 30 ,31, 31, 30, 31, 30, 31]
_m_days_n = [31, 29, 31, 30, 31, 30 ,31, 31, 30, 31, 30, 31]
@staticmethod
def get_time():
if Util.config.get_time_type() == 0:
return Util._get_system_time()
else:
return Util._get_network_time()
@staticmethod
def get_day_before(cur_day):
if len(cur_day) != 3:
return cur_day
day = int(cur_day[2])
mon = int(cur_day[1])
year = int(cur_day[0])
new_day = cur_day[:]
if day != 1:
new_day[2] = str(day - 1)
return new_day
days = Util._get_days(cur_day)
new_day = cur_day[:]
if mon-1 != 0:
new_day[1] = str(mon-1)
new_day[2] = str(days[mon-1])
else:
new_day[0] = str(year-1)
new_day[1] = '12'
new_day[2] = '31'
return new_day
@staticmethod
def _get_days(cur_day):
if len(cur_day) != 3:
return Util._m_days_o
year = int(cur_day[0])
if (year%4 == 0 and year%100 != 0 ) or year%400 == 0:
return Util._m_days_n
return Util._m_days_o
@staticmethod
def _get_system_time():
ltime = time.localtime()
if ltime != None:
return [str(ltime.tm_year),"%02d" % ltime.tm_mon, "%02d" % ltime.tm_mday]
else:
return None
@staticmethod
def _get_network_time():
'''
Currently we just use local time
Otherwise we should specify an timezone
'''
return Util._get_system_time()
def __init__(self, group=None, target=None, name=None, *args, **kwargs):
super(BaseService, self).__init__(group=group, target=target, name=name, args = args, kwargs = kwargs)
self.exit = mp.Event()
self.dbsession = None
self.pname = name
self.conf = Configure()
self.url_pfx = self.conf.get_default('Service', 'UploadURL', 'http://pacs.winning.com.cn/platform')
self.url_path = ''
def __init__(self, path, default, quiet):
'''Constructs the bot object. Takes path, default, and quiet arguments from the command
line input and sets the bot accordingly. Initializes logging, creates instances of
necessary classes. Loads plugins, begins the connection.'''
self._config_path = path
self._default = default
self._quiet = quiet
self.logger = logging.getLogger("GorillaBot")
self._configuration = Configure(self._config_path, self._default,
self._quiet)
settings = self._configuration.get_configuration()
self.GorillaConnection = Connection(
self, settings["host"], settings["port"], settings["nick"],
settings["ident"], settings["realname"], settings["chans"],
settings["botop"], settings["fullop"])
self.GorillaCommander = CommandManager(self, self.GorillaConnection)
self.GorillaConnection._connect()
def calculate_index():
print '%s\tstart update index' % str(datetime.now())
cfg = Configure('./config/config.cfg')
article_repo = cfg.get_config('running', 'article_repo')
file_names = os.listdir(
os.path.join(article_repo,
datetime.today().strftime('%m%d%Y')))
doc_count = 0
for filename in file_names:
if not filename.endswith('_DONE'):
process(os.path.join(article_repo, filename), filename)
os.rename(os.path.join(article_repo, filename),
os.path.join(article_repo, filename + '_DONE'))
doc_count += 1
if doc_count:
update_tfidf(doc_count)
print '%s\tend update index' % str(datetime.now())
class Bot(object):
'''The Bot class is the core of the bot. It creates the connection and the responder. All messages
that are received come through here, and are dispatched accordingly.'''
def __init__(self, path, default, quiet):
'''Constructs the bot object. Takes path, default, and quiet arguments from the command
line input and sets the bot accordingly. Initializes logging, creates instances of
necessary classes. Loads plugins, begins the connection.'''
self._config_path = path
self._default = default
self._quiet = quiet
self.logger = logging.getLogger("GorillaBot")
self._configuration = Configure(self._config_path, self._default,
self._quiet)
settings = self._configuration.get_configuration()
self.GorillaConnection = Connection(
self, settings["host"], settings["port"], settings["nick"],
settings["ident"], settings["realname"], settings["chans"],
settings["botop"], settings["fullop"])
self.GorillaCommander = CommandManager(self, self.GorillaConnection)
self.GorillaConnection._connect()
def dispatch(self, line):
'''Determines the type of message received:
If the message is a ping, it pongs back.
If the message is from NickServ, it determines identification status.
If the message contains a reply code, it forwards it to parse_number.
If the message is a PRIVMSG, it forwards it to parse_message.'''
# Probably will want to remove this at some point in the future, but for now I'm going
# to hold on to it for debugging.
self.logger.debug(line)
# Responds to ping messages. Doesn't bother to send it to the CommandManager.
if "PING" in line[0]:
self.logger.debug("Ping received.")
self.GorillaConnection.pong(line[1][1:])
# Identifies messages from NickServ, sends to CommandManager
elif "NickServ" in line[0]:
self.GorillaCommander.nickserv_parse(line)
# Identifies server message codes, sends to CommandManager
elif len(line[1]) == 3:
self.GorillaCommander.process_numcode(line[1], line)
# Identifies PRIVMSGs, sends to CommandManager
elif line[1] == "PRIVMSG":
self.GorillaCommander.check_command(line)
# Nick changes
elif line[1] == "NICK":
self.GorillaCommander.nick_change(line)
class Bot(object):
'''The Bot class is the core of the bot. It creates the connection and the responder. All messages
that are received come through here, and are dispatched accordingly.'''
def __init__(self, path, default, quiet):
'''Constructs the bot object. Takes path, default, and quiet arguments from the command
line input and sets the bot accordingly. Initializes logging, creates instances of
necessary classes. Loads plugins, begins the connection.'''
self._config_path = path
self._default = default
self._quiet = quiet
self.logger = logging.getLogger("GorillaBot")
self._configuration = Configure(self._config_path, self._default, self._quiet)
settings = self._configuration.get_configuration()
self.GorillaConnection = Connection(self, settings["host"], settings["port"],
settings["nick"], settings["ident"],
settings["realname"], settings["chans"],
settings["botop"], settings["fullop"])
self.GorillaCommander = CommandManager(self, self.GorillaConnection)
self.GorillaConnection._connect()
def dispatch(self, line):
'''Determines the type of message received:
If the message is a ping, it pongs back.
If the message is from NickServ, it determines identification status.
If the message contains a reply code, it forwards it to parse_number.
If the message is a PRIVMSG, it forwards it to parse_message.'''
# Probably will want to remove this at some point in the future, but for now I'm going
# to hold on to it for debugging.
self.logger.debug(line)
# Responds to ping messages. Doesn't bother to send it to the CommandManager.
if "PING" in line[0]:
self.logger.debug("Ping received.")
self.GorillaConnection.pong(line[1][1:])
# Identifies messages from NickServ, sends to CommandManager
elif "NickServ" in line[0]:
self.GorillaCommander.nickserv_parse(line)
# Identifies server message codes, sends to CommandManager
elif len(line[1])==3:
self.GorillaCommander.process_numcode(line[1], line)
# Identifies PRIVMSGs, sends to CommandManager
elif line[1]=="PRIVMSG":
self.GorillaCommander.check_command(line)
# Nick changes
elif line[1] == "NICK":
self.GorillaCommander.nick_change(line)
def __init__(self):
self.config = Configure()
self.start_server, self.client_ip, self.server_name, self.server_pass = self.config.read_server()
if self.start_server == False:
sys.exit()
say('Starting Server')
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = ''
self.port = 5150
self.server.bind((self.host, self.port))
self.server.listen(5)
print 'Listing for a client...'
self.client, self.addr = self.server.accept()
print 'Accepted connection from ', self.addr
self.client.send(str.encode('Connection made with Andy'))
def freezeService(code):
c = Configure()
c.setStatus({
'message': '发生异常，系统自动冻结服务。',
'title': '服务已冻结',
'me': False,
'tomorrow': True,
'today': True,
'mon': False,
'detect': False,
'isRed': True
})
data = {
'service_name': {
'value': '全服务'
},
'reason': {
'value': '网络异常：code:' + code
},
'mess': {
'value': '服务已自动冻结'
}
}
pushRunningMessage('warn',data)
def __init__(self, path, default, quiet):
'''Constructs the bot object. Takes path, default, and quiet arguments from the command
line input and sets the bot accordingly. Initializes logging, creates instances of
necessary classes. Loads plugins, begins the connection.'''
self._config_path = path
self._default = default
self._quiet = quiet
self.logger = logging.getLogger("GorillaBot")
self._configuration = Configure(self._config_path, self._default, self._quiet)
settings = self._configuration.get_configuration()
self.GorillaConnection = Connection(self, settings["host"], settings["port"],
settings["nick"], settings["ident"],
settings["realname"], settings["chans"],
settings["botop"], settings["fullop"])
self.GorillaCommander = CommandManager(self, self.GorillaConnection)
self.GorillaConnection._connect()
def wrapper(*args, **kwargs):
cfg = Configure('./config/config.cfg')
mongo_url = cfg.get_config('mongodb', 'url')
mongo_port = int(cfg.get_config('mongodb', 'port'))
dbname = cfg.get_config('mongodb', 'dbname')
collection_name = cfg.get_config('mongodb', tablename)
client = MongoClient(mongo_url, mongo_port)
db=client[dbname]
collection = db[collection_name]
res = func(*args, c = collection, **kwargs)
return res
class BaseService(mp.Process):
"""
需要实现do_work内容,完成具体的业务流程，
需要实例赋值upload_url
调用endloop停止work
"""
def __init__(self, group=None, target=None, name=None, *args, **kwargs):
super(BaseService, self).__init__(group=group, target=target, name=name, args = args, kwargs = kwargs)
self.exit = mp.Event()
self.dbsession = None
self.pname = name
self.conf = Configure()
self.url_pfx = self.conf.get_default('Service', 'UploadURL', 'http://pacs.winning.com.cn/platform')
self.url_path = ''
def run(self):
if not self.pname:
self.pname = mp.current_process().name
self.init_logger()
self.dbsession = DBSession().get_session()
logging.info(self.pname + ' Starting')
self.do_work()
logging.info(self.pname + ' Exit')
def endloop(self):
logging.info(self.pname + ' Exiting')
self.exit.set()
def init_logger(self):
if not os.path.exists('./log'):
os.mkdir('./log')
logfile = TimedRotatingFileHandler('./log/'+'t_'+self.pname+'.log', when='D', backupCount=5)
formatter = logging.Formatter('[%(asctime)s P:%(process)-5d %(funcName)s:%(lineno)d %(levelname)5s] %(message)s', '%Y-%m-%d %H:%M:%S')
logfile.setFormatter(formatter)
logging.getLogger('').setLevel(logging.INFO)
logging.getLogger('').addHandler(logfile)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('[' + self.pname + '-%(levelname)5s] %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
def upload(self, data):
try:
logging.info('%s:%s',self.pname,json.dumps(data, ensure_ascii=False) if data else None)
success = False
errdesc = ''
ret = requests.post(self.url_pfx+self.url_path, json=data, timeout=2)
ret.raise_for_status()
if ret.json() and ret.json().get('msg','') == 'OK': # if ret.text and json.loads(ret.text).get('msg','') == 'OK':
success = True
else:
logging.error(ret.text)
# errdesc = 'upload failed'
except Exception as e:
logging.exception(e)
# errdesc += e.message
finally:
# logging.error(errdesc) if errdesc else None
return success
def do_work(self):
raise NotImplementedError()
sys.setdefaultencoding('utf-8')
import os
os.chdir(os.path.dirname(os.path.realpath(__file__)))
import hashlib
import time
import newspaper
import feedparser
from datetime import datetime
from random import shuffle
from config import Configure
from util import Util
CFG = Configure('./config/config.cfg')
ARTICLEREPO = os.path.join(CFG.get_config('running', 'article_repo'),
datetime.today().strftime('%m%d%Y'))
if not os.path.isdir(ARTICLEREPO):
os.makedirs(ARTICLEREPO)
def crawl_web_categorypage(url):
paper = newspaper.build(url, memoize_articles=False, language='en')
for category in paper.category_urls():
crawl_web(category)
def crawl_web(url):
paper = newspaper.build(url, memoize_articles=False, language='en')
def set_manual_transformation(self):
settings = Configure()
settings.set_pre_processing_params()
rules = settings.pre_processing_params['manual_encoding']
return rules
backup = int(not working)
if adhoc_interface == "ath0" and monitor_interface == "ath1":
working_iface_monitor = re.compile('[0]').sub('2', adhoc_interface)
backup_iface_monitor = re.compile('[1]').sub('3', monitor_interface)
elif adhoc_interface == "ath1" and monitor_interface == "ath0":
working_iface_monitor = re.compile('[1]').sub('3', adhoc_interface)
backup_iface_monitor = re.compile('[0]').sub('2', monitor_interface)
else:
print "Please specify [ath0, ath1] for each interface. "
sys.exit(0)
print "Current Interfaces: [wa: %s] [wm: %s] [ba: %s] [bm: %s]" % (working_iface_adhoc, working_iface_monitor, backup_iface_adhoc, backup_iface_monitor)
print "Current Interface: [wa: ath%s] [ba: ath%s]" % (working, backup)
cf = Configure(working_iface_adhoc, backup_iface_adhoc)
ff = FrameFilter(cf, snr_threshold, FILTER)
p = pcap.pcapObject()
p.open_live(backup_iface_monitor, 96, 0, 100)
while 1:
while ff.rx_frame < 101: # Approx. 100ms * 100 = 10s ; Only beacon frames counted
apply(ff.filter, p.next())
#ff.print_tx_filter(working_iface_adhoc) # maybe 1s
stime = time.time()
#print "loop starts %f" % stime
try:
for daddr in ['00:80:92:3e:18:11', '00:80:92:3e:18:18']:
print "XXXXXXXXXXXXXXXX"
def __init__(self):
self.config = Configure()
self.errors = []
self.meta = {'info':'', 'real_url':'', 'code':0}
def main(DEBUG=False):
#Start LEDs
write('load')
subprocess.Popen(['python', 'LED.py'])
#Read from configuration files and apply settings.
config = Configure()
start_andy_on_boot, social_mode, rebel_mode, wander_mode = config.read()
if start_andy_on_boot == False:
sys.exit()
#Say start up slogan and check for command.
say('Hello. My name is Andy. Please wait while my system starts up.')
getit = Get_cmd()
#Start server process
subprocess.Popen(['python', 'server.py'])
write(None)
#Enter main loop
while True:
print()
#Get the command and convert it to a list
cmd = getit.get().split()
write('load')
if DEBUG: print('COMMAND:', cmd)
#Remove unused words from command
num = 0
for word in cmd:
cmd[num] = word.lower()
num += 1
if len(cmd) == 0:
cmd.append('')
#Determin master command
if cmd[0] == 'what':
cmds.What(cmd, DEBUG)
elif cmd[0] == 'walk' or cmd[0] == 'turn':
cmds.Walk(cmd, DEBUG)
elif cmd[0] == 'stop':
cmds.Walk(cmd, DEBUG).stop()
elif cmd[0] == 'pickup' or cmd[0] == 'pick' and cmd[1] == 'up':
cmds.Arm(cmd, DEBUG).pickup()
elif cmd[0] == 'set' and cmd[1] == 'down':
cmds.Arm(cmd, DEBUG).setdown()
elif cmd[0] == 'where':
cmds.Where(cmd, DEBUG)
elif cmd[0] == 'take':
cmds.Take(cmd, DEBUG)
elif cmd[0] == 'set':
pass #TODO
elif cmd[0] == 'tell':
cmds.Tell(cmd, DEBUG)
elif cmd[0] == 'who':
cmds.Who(cmd, DEBUG)
elif cmd[0] == 'shutdown':
cmds.shutdown()
elif cmd[0] == 'sleep':
cmds.sleep()
elif cmd[0] == 'meet':
Meet(cmd, DEBUG)
else:
say('Not valid command')
write(None)
time.sleep(1)
from config import Configure
from model import Net
from data_process import data_loader
import torch
import torch.nn as nn
config = Configure()
args = config.get_args()
train_set, val_set, num_total_words = data_loader(args)
device = torch.device("cuda:2" if torch.cuda.is_available() else "cpu")
net = Net(num_total_words*args.max_features, args.embedding_size,
args.num_hiddens, args.num_layers, num_classes=len(args.catogories))
net.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=args.lr)
for epoch in range(args.num_epochs):
train_set, val_set, num_total_words = data_loader(args)
train_loss, val_loss = 0., 0.
train_acc, val_acc = 0., 0.
num_correct = 0
for step, (feature, label) in enumerate(train_set):
feature = torch.from_numpy(feature).to(device)
label = torch.from_numpy(label).to(device)
net.zero_grad()
scores = net(feature)
def main(DEBUG=False):
#Start LEDs
write('load')
subprocess.Popen(['python', 'LED.py'])
#Read from configuration files and apply settings.
config = Configure()
start_andy_on_boot, social_mode, rebel_mode, wander_mode = config.read()
if start_andy_on_boot == False:
sys.exit()
#Say start up slogan and check for command.
say('Hello. My name is Andy. Please wait while my system starts up.')
getit = Get_cmd()
#Start server process
subprocess.Popen(['python', 'server.py'])
write(None)
#Enter main loop
while True:
print
#Get the command and convert it to a list
cmd = getit.get().split()
write('load')
if DEBUG: print 'COMMAND:', cmd
#Remove unused words from command
num = 0
for word in cmd:
cmd[num] = word.lower()
num += 1
if len(cmd) == 0:
cmd.append('')
#Determin master command
if cmd[0] == 'what':
cmds.What(cmd, DEBUG)
elif cmd[0] == 'walk' or cmd[0] == 'turn':
cmds.Walk(cmd, DEBUG)
elif cmd[0] == 'stop':
cmds.Walk(cmd, DEBUG).stop()
elif cmd[0] == 'pickup' or cmd[0] == 'pick' and cmd[1] == 'up':
cmds.Arm(cmd, DEBUG).pickup()
elif cmd[0] == 'set' and cmd[1] == 'down':
cmds.Arm(cmd, DEBUG).setdown()
elif cmd[0] == 'where':
cmds.Where(cmd, DEBUG)
elif cmd[0] == 'take':
cmds.Take(cmd, DEBUG)
elif cmd[0] == 'set':
pass #TODO
elif cmd[0] == 'tell':
cmds.Tell(cmd, DEBUG)
elif cmd[0] == 'who':
cmds.Who(cmd, DEBUG)
elif cmd[0] == 'shutdown':
cmds.shutdown()
elif cmd[0] == 'sleep':
cmds.sleep()
elif cmd[0] == 'meet':
Meet(cmd, DEBUG)
else:
say('Not valid command')
write(None)
time.sleep(1)
import os
import time
import numpy as np
from shutil import copyfile
from datetime import datetime
from config import Configure
from utils.vocab import Vocab
from data.loader import DataLoader
from utils import scorer, constant, helper
from model.base import BaseModel
# make opt
opt = vars(Configure.c_gcn())
opt['num_class'] = len(constant.LABEL_TO_ID)
# load vocab
vocab_file = opt['vocab_dir'] + '/vocab.pkl'
vocab = Vocab(vocab_file, load=True)
opt['vocab_size'] = vocab.size
emb_file = opt['vocab_dir'] + '/embedding.npy'
emb_matrix = np.load(emb_file)
assert emb_matrix.shape[0] == vocab.size
assert emb_matrix.shape[1] == opt['emb_dim']
# load data
print("Loading data from {} with batch size {}...".format(
opt['data_dir'], opt['batch_size']))
train_batch = DataLoader(opt['data_dir'] + '/train.json',
from feature_selection import FeatureSelection
from config import Configure
import pandas as pd
print('\n Aplicando algoritmo de seleção de parâmetros')
settings = Configure()
settings.set_fs_params()
settings.set_pre_processing_params()
pp_params = settings.pre_processing_params
fs_params = settings.feature_selection_params
df1 = pd.read_csv(settings.pf1_folder)
df2 = pd.read_csv(settings.pf2_folder)
df3 = pd.read_csv(settings.pf3_folder)
mkt = pd.read_csv(settings.mkt_folder)
fs = FeatureSelection(mkt, df1, df2, df3, pp_params, fs_params)
values, features = fs.feature_selection_algorithm(m='RFECV')
columns = features.values[features.values != 'Unnamed: 0']
mkt = mkt[columns]
def __init__(self):
self.serverName, self.serverPort, self.clientPort, self.downloadPath = Configure(
).client_config()
from config import Configure
__author__ = "Andrew Gafiychuk"
if __name__ == '__main__':
# Test Singleton also
cfg2 = Configure(file="../config.cfg")
print(cfg2._singleton_mark)
cfg = Configure(file="../config.cfg")
print(cfg._singleton_mark)
print(cfg2 is cfg) # Must be a True
cfg.show_config()
config = cfg.getConfiguration()
print("=" * 100)
print("User: {0}".format(config["user"]))
print("Passowrd: {0}".format(config["password"]))
print("=" * 100)
print("Host: {0}".format(cfg.get_host()))
print("Port: {0}".format(cfg.get_port()))
def start_recording(config_name, recording_num_scale, flag_show_windows, auto_save, port=None, weathers=None, vehicle_nums=None):
config, config_file = Configure.get_config(config_name)
if port is None:
port = config['port']
cameras = config['cameras']
if vehicle_nums is None:
vehicle_nums = config['vehicle_num']
if weathers is None:
weathers = config['weathers']
all_conditions = [(w, v) for w in weathers for v in vehicle_nums]
if config["mode"] == "parallel":
for cond in all_conditions:
recorder = SRecorder(host=config['host'],
port=port,
save_root=config['save_root'],
weather_name=cond[0],
vehicle_num=cond[1],
flag_show_windows=flag_show_windows,
auto_save=auto_save,
config=config,
config_file = config_file
)
camera_keys = cameras.keys()
for _, k in zip(trange(len(cameras)), cameras.keys()):
recorder.create_rgb_camera(
width=cameras[k]["width"],
height=cameras[k]["height"],
x=cameras[k]["x"],
y=cameras[k]["y"],
z=cameras[k]["z"],
fov=cameras[k]["fov"],
pitch=cameras[k]["pitch"],
yaw=cameras[k]["yaw"],
roll=cameras[k]["roll"],
max_record_frame=int(cameras[k]["max_record_frame"]*recording_num_scale),
camera_tag=k
)
recorder.run()
elif config["mode"] == "serial":
for cond in all_conditions:
for k in cameras.keys():
recorder = SRecorder(host=config['host'],
port=port,
save_root=config['save_root'],
weather_name=cond[0],
vehicle_num=cond[1],
flag_show_windows=flag_show_windows,
auto_save=auto_save,
config=config,
config_file = config_file
)
recorder.create_rgb_camera(
width=cameras[k]["width"],
height=cameras[k]["height"],
x=cameras[k]["x"],
y=cameras[k]["y"],
z=cameras[k]["z"],
fov=cameras[k]["fov"],
pitch=cameras[k]["pitch"],
yaw=cameras[k]["yaw"],
roll=cameras[k]["roll"],
max_record_frame=int(cameras[k]["max_record_frame"]*recording_num_scale),
camera_tag=k
)
recorder.run()
elif adhoc_interface == "ath1" and monitor_interface == "ath0":
working_iface_monitor = re.compile('[1]').sub(
'3', adhoc_interface)
backup_iface_monitor = re.compile('[0]').sub(
'2', monitor_interface)
else:
print "Please specify [ath0, ath1] for each interface. "
sys.exit(0)
print "Current Interfaces: [wa: %s] [wm: %s] [ba: %s] [bm: %s]" % (
working_iface_adhoc, working_iface_monitor, backup_iface_adhoc,
backup_iface_monitor)
print "Current Interface: [wa: ath%s] [ba: ath%s]" % (working,
backup)
cf = Configure(working_iface_adhoc, backup_iface_adhoc)
ff = FrameFilter(cf, snr_threshold, FILTER)
p = pcap.pcapObject()
p.open_live(backup_iface_monitor, 96, 0, 100)
while 1:
while ff.rx_frame < 101: # Approx. 100ms * 100 = 10s ; Only beacon frames counted
apply(ff.filter, p.next())
#ff.print_tx_filter(working_iface_adhoc) # maybe 1s
stime = time.time()
#print "loop starts %f" % stime
try:
for daddr in ['00:80:92:3e:18:11', '00:80:92:3e:18:18']:
print "XXXXXXXXXXXXXXXX"
"""
Disable all elements while operations working.
"""
self.btn_fill.setDisabled(True)
self.btn_exp.setDisabled(True)
self.btn_scrapp.setDisabled(True)
self.btn_save.setDisabled(True)
self.cmb_ds.setDisabled(True)
self.cmb_exp.setDisabled(True)
self.cmb_save.setDisabled(True)
self.page_count_box.setDisabled(True)
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
logging.debug("[+]App started...")
# Configure main program params...
cfg = Configure()
app = QtWidgets.QApplication(sys.argv)
form = MainForm(config=cfg)
form.show()
logging.debug("[+]App set_enable...")
sys.exit(app.exec_())
def initConf(file):
try:
conf = Configure(file)
return conf
except Exception as ex:
raise ex
from data.dataloader import generate_loader
from config import Configure
from networks.RCNN import BiGruCNN
from framework import MyFrame
from utils import initLogging
name = 'HAN_rcnn_drop0.2'
mylog = 'logs/' + name + '.log'
path = 'weights/' + name + '.pkl'
initLogging(mylog)
device = 2
total_epochs = 30
valid_best_score = 0.
train_loader, valid_loader, testa_loader = generate_loader(train_bs=32)
opt = Configure()
net = BiGruCNN
loss_func = CrossEntropyLoss(size_average=True)
solver = MyFrame(net=net, loss=loss_func, opt=opt, lr=1e-3, device=device)
solver.load(path)
# solver.net.embedding.weight.requires_grad = True
no_optim_round = 0
for epoch in range(total_epochs):
# train
solver.train_mode()
train_loss = 0.
for X, y in tqdm(train_loader):
solver.set_input(X, y)
step_loss = solver.optimize()
train_loss += step_loss
"""
Run evaluation with saved models for student network.
"""
import json
from config import Configure
from utils.vocab import Vocab
from data.loader import DataLoader
from model.student import StudentModel
from utils import torch_utils, scorer, constant, helper
args = Configure.eval()
# load opt
model_file = 'saved_models/' + args.model_id + '/' + args.model
print("Loading model from {}".format(model_file))
opt = torch_utils.load_config(model_file)
student_model = StudentModel(opt)
student_model.load(model_file)
# load vocab
vocab_file = 'saved_models/' + args.model_id + '/vocab.pkl'
vocab = Vocab(vocab_file, load=True)
assert opt[
'vocab_size'] == vocab.size, "Vocab size must match that in the saved model."
# load data
data_file = opt['data_dir'] + '/{}.json'.format(args.dataset)
print("Loading data from {} with batch size {}...".format(
data_file, opt['batch_size']))
batch = DataLoader(data_file, opt['batch_size'], opt, vocab, evaluation=True)
import os
from tqdm import tqdm
from visdom import Visdom
import numpy as np
from torch.autograd import Variable
from torch.autograd import Function
import torch.backends.cudnn as cudnn
from dataset import SiameseWhaleDataset
from model import SiameseNetwork
from config import Configure
from utils import PairwiseDistance, DlibLoss, ContrastiveLoss
# Global config
config = Configure()
transform = transforms.Compose([
# Scale(96),
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(),
transforms.RandomRotation(15),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
# Train_dir
# Number of training example: n_batch * n_cls * n_same
train_dir = SiameseWhaleDataset(config.dataroot, config.n_batch, config.n_cls,
config.n_same, transform)
