import tensorflow as tf
import data_prepare
from tensorflow.contrib import learn
import numpy as np
from esim import esim_model
import config as config
from tqdm import tqdm
from sklearn.metrics import f1_score
from sklearn import metrics
import os
con = config.Config()
parent_path = os.path.dirname(os.getcwd())
data_pre = data_prepare.Data_Prepare()
class TrainModel(object):
'''
训练模型
保存模型
'''
def pre_processing(self):
train_texta, train_textb, train_tag = data_pre.readfile(
parent_path + '/data/train.txt')
data = []
data.extend(train_texta)
data.extend(train_textb)
data_pre.build_vocab(
data, parent_path + '/save_model/esim' + '/vocab.pickle')
# 加载词典
self.vocab_processor = learn.preprocessing.VocabularyProcessor.restore(
def __init__(self, conf=config.Config()):
self.Config = conf
def run_parallel (options) :
'''
Starts station search procedure
:type options: instance
:param options: parameter to initialize the networklist class
'''
isClient = (options.args != None)
if not init (options) :
return False
if isClient : # Run client
clt = StationListClient (options)
clt.run ()
return True
else : # Run server
# Create directory for clients
#
clientDir = os.path.join (options.evpath, 'keyfiles-' + str (time.time()))
Logfile.add ('Create keyfile directory ', clientDir, ' ')
create_dir (clientDir)
# Build network list
#
C = config.Config (options.evpath)
Origin = C.parseConfig ('origin')
Conf = Globals.ConfigDict
checkConfigFile (Conf)
globalCfg = ConfigObj (dict = Conf)
originCfg = ConfigObj (dict = Origin)
ot = originCfg.Time() # str (Origin['time'])
elat = originCfg.lat() # Origin['lat']
elon = originCfg.lon() # Origin['lon']
minDist = globalCfg.Distance ('mindist') # Conf ['mindist']
maxDist = globalCfg.Distance ('maxdist') # Conf ['maxdist']
duration = globalCfg.Duration () # Conf ['duration']
paramList = [ot, maxDist,minDist,elat,elon]
BL = []
if 'blacklist' in Conf :
K = (Conf ['blacklist']).split(',')
BL = ['# Network Code']
BL.extend(K)
T = NetworkList (ot,elat,elon,minDist,maxDist,duration, blacklist = BL,mail=Conf['mail'])
SERVER_NAME = 'network'
# Handle Iris networks
#
inetworks = T.getIRISList()
#inetworks = ['BF']
if len (inetworks) == 0 : Logfile.error ('No iris networks found')
else :
args = Server.joinClientArgs ([IRIS_TAG, clientDir], paramList)
ctrl = Server.ServerCtrl (nRetries = 1, nParallel=1, waitTime=1.0, printStat=False)
srv = Server.ServerBase (SERVER_NAME, checkProcessError, ctrl)
#if WINDOWS : srv.control.ClientProc = MainProc
if not srv.run (inetworks, args) : return False
#endif
# Handle Geofon networks
#
gnetworks = T.getWEBDCList()
#gnetworks = ['AF']
#gnetworks = ['FR']
#gnetworks = []
if len (gnetworks) == 0 :
Logfile.error ('No geofon networks found')
else :
# Access network infos now from Geofo
#
args = Server.joinClientArgs ([GEOFON_TAG, clientDir], paramList)
ctrl = Server.ServerCtrl (nRetries = 4, nParallel=1, waitTime=2.0, printStat=False)
srv = Server.ServerBase (SERVER_NAME, checkProcessError, ctrl)
#if WINDOWS : srv.control.ClientProc = MainProc
if not srv.run (gnetworks, args) : return False
#endif
# Print statistic
nIres = len (inetworks)
nWebDC = len (gnetworks)
nAll = nIres + nWebDC
if nIres != 0 : Logfile.add (' ', 'Processed ' + str(nIres) + ' IRES networks')
if nWebDC != 0 : Logfile.add ( 'Processed ' + str(nWebDC) + ' WEBDC networks')
if nAll == 0 : return Logfile.error ('No networks found')
if nIres == 0 : err = 'No IRIS network found'
elif nWebDC == 0 : err = 'No WEBDC network found'
else : err = None
if err != None : Logfile.add (err)
# showNextStep
#
evpath = options.evpath.split('/')[-1]
keyfoldername = clientDir.split('/')[-1]
Logfile.add (' ', 'NEXT PROCESSING STEP:', ' ')
Logfile.add (' 1) change keyfolder value in global.conf to ' + keyfoldername)
Logfile.add (' 2) python arraytool.py getdata ' + evpath, ' ')
return True
# Test
results[manifest.split('/')[-1]] = result_for_manifest(model, criterion, manifest, decoder, target_decoder, confs['batch_size'], confs['num_workers'])
if not PRINT_LATEX_TABLE:
print(f'Model: {model_path.split("/")[-1]}')
for name, res in results.items():
print(f'\nResults for {name}:')
print('; '.join([f'{k}: {v:.3f}' for k, v in res.items()]))
else:
print(' & '.join(['model']+list([k[:-4] for k in results.keys()])))
val_dict = {}
for k in list(results.values())[0].keys():
val_dict[k] = []
for res in results.values():
[val_dict[k].append(f'{v:.1f}') for k, v in res.items()]
for val in val_dict.values():
print(' & '.join([Path(model_path).stem.split('_')[0]]+val)+r' \\')
if __name__ == '__main__':
import config
confs = config.Config()
args = sys.argv[1:]
if PRINT_LATEX_TABLE:
eprint('\nLatex output selected, change PRINT_LATEX_TABLE in script to False for regular output.')
for model_path in args:
main(model_path, confs)
pr_x.append(float(correct) / conf.total_recall)
auc = sklearn.metrics.auc(x = pr_x, y = pr_y)
for i in range(len(pr_x)):
if pr_x[i] >= 0.4:
print("precision at [email protected]")
p_4 = pr_y[i]
print(pr_x[i])
print(pr_y[i])
break
print("test auc_local: ", auc)
print("p_4", p_4)
return auc, p_4, pr_x, pr_y, test_result
if __name__ == "__main__":
conf = config.Config()
os.environ['CUDA_VISIBLE_DEVICES'] = conf.gpu
conf.load_train_data()
conf.load_test_data()
tree = Tree(conf)
conf.global_num_classes = tree.n_class
base_model = PCNN_ATT(conf)
policy = Policy(conf, tree.n_class, base_model)
policy.cuda()
policy_optimizer = torch.optim.SGD(policy.parameters(), lr = conf.policy_lr, weight_decay = conf.policy_weight_decay)
for name,parameters in policy.named_parameters():
print(name, parameters.size())
criterion = torch.nn.CrossEntropyLoss()
if conf.is_training :
train()
def get_config_options(self):
conf = config.Config("/home/user1/intership/restricted_mails.conf")
self.config_options = conf.config_options
def __init__(self):
self.cmds = commands.Commands()
self.cfg = config.Config()
self.owm = pyowm.OWM(self.cfg.get_api_key('forecast'))
def __init__(self):
C = config.Config()
self.samplenumber = C.samplenumber
self.optimizer = C.optimizer
self.classes = C.classes
self.data_length = self.samplenumber
def EMD_Parallel_Models(self):
C = config.Config()
input_shape = (self.data_length, 1)
x1 = Input(input_shape)
x2 = Input(input_shape)
x3 = Input(input_shape)
#x4 = Input(input_shape)
#x5 = Input(input_shape)
#x6 = Input(input_shape)
if C.architect == 'RESNet50':
#channel 1
y1 = ResNet50(x1, self.data_length, self.classes, name='IMF1_')
#channel 2
y2 = ResNet50(x2, self.data_length, self.classes, name='IMF2_')
#channel 3
y3 = ResNet50(x3, self.data_length, self.classes, name='IMF3_')
#channel 4
y4 = ResNet50(x4, self.data_length, self.classes, name='IMF4_')
#channel 5
y5 = ResNet50(x5, self.data_length, self.classes, name='IMF5_')
#channel 6
y6 = ResNet50(x6, self.data_length, self.classes, name='IMF6_')
elif C.architect == 'AlexNet':
y1 = model_Alexnet_single_channel(x1,
self.data_length,
self.classes,
name='IMF1_')
#channel
y2 = model_Alexnet_single_channel(x2,
self.data_length,
self.classes,
name='IMF2_')
#channel 3
y3 = model_Alexnet_single_channel(x3,
self.data_length,
self.classes,
name='IMF3_')
#channel 4
#y4 = model_Alexnet_single_channel(x4,self.data_length,self.classes,name='IMF4_')
#channel 5
#y5 = model_Alexnet_single_channel(x5,self.data_length,self.classes,name='IMF5_')
#channel 6
#y6 = model_Alexnet_single_channel(x6,self.data_length,self.classes,name='IMF6_')
elif C.architect == 'VGGNet19':
y1 = model_VGG19(x1, self.data_length, self.classes, name='IMF1_')
#channel
y2 = model_VGG19(x2, self.data_length, self.classes, name='IMF2_')
#channel 3
y3 = model_VGG19(x3, self.data_length, self.classes, name='IMF3_')
#channel 4
y4 = model_VGG19(x4, self.data_length, self.classes, name='IMF4_')
#channel 5
y5 = model_VGG19(x5, self.data_length, self.classes, name='IMF5_')
#channel 6
y6 = model_VGG19(x6, self.data_length, self.classes, name='IMF6_')
elif C.architect == 'Inception':
y1 = model_GoogleNet(x1,
self.data_length,
self.classes,
name='IMF1_')
#channel
y2 = model_GoogleNet(x2,
self.data_length,
self.classes,
name='IMF2_')
#channel 3
y3 = model_GoogleNet(x3,
self.data_length,
self.classes,
name='IMF3_')
#channel 4
y4 = model_GoogleNet(x4,
self.data_length,
self.classes,
name='IMF4_')
#channel 5
y5 = model_GoogleNet(x5,
self.data_length,
self.classes,
name='IMF5_')
#channel 6
y6 = model_GoogleNet(x6,
self.data_length,
self.classes,
name='IMF6_')
print 'Y returned'
#y = concatenate([y1,y2,y3,y4,y5,y6],axis=-1,name = 'concat2')#Concatenated final 6 IMF softmax outputs = 48 neurons
y = concatenate(
[y1, y2, y3], axis=-1, name='concat2'
) #Concatenated final 6 IMF softmax outputs = 48 neurons
y = Dense(24,
init='uniform',
activation='relu',
W_constraint=maxnorm(3),
name='Concatenated_Dense_1')(y)
y = Dropout(0.2, name='Concatenated_Dropout_1')(y)
y = Dense(16,
init='uniform',
activation='relu',
W_constraint=maxnorm(3),
name='Concatenated_Dense_2')(y)
y = Dropout(0.2, name='Concatenated_Dropout_2')(y)
y = Dense(self.classes,
init='uniform',
activation='softmax',
name='Final_softmax_layer')(y)
#model = Model(inputs=[x1,x2,x3,x4,x5,x6], outputs=y,name=C.architect+'_Parallel')
model = Model(inputs=[x1, x2, x3],
outputs=y,
name=C.architect + '_Parallel')
print 'Model created'
#plot_model(model, to_file='./Outputs/Model_Figures/'+C.architect+'_Parallel',show_shapes=True, show_layer_names=True)
return model
import sys
import os
import argparse
# import IPython
# sys.excepthook = IPython.core.ultratb.FormattedTB(mode='Verbose', color_scheme='Linux', call_pdb=1)
parser = argparse.ArgumentParser()
parser.add_argument('--model_name', type = str, default = 'BiLSTM', help = 'name of the model')
parser.add_argument('--save_name', type = str)
parser.add_argument('--train_prefix', type = str, default = 'dev_train')
parser.add_argument('--test_prefix', type = str, default = 'dev_dev')
args = parser.parse_args()
model = {
'CNN3': models.CNN3,
'LSTM': models.LSTM,
'BiLSTM': models.BiLSTM,
'ContextAware': models.ContextAware,
}
con = config.Config(args)
con.set_max_epoch(200)
con.load_train_data()
con.load_test_data()
# con.set_train_model()
con.train(model[args.model_name], args.save_name)
would undergo clustering.
"""
# Parsing and processing arguments
arguments = cluster.src.arguments.Arguments()
parser = argparse.ArgumentParser()
parser.add_argument(
'elements',
type=arguments.url,
help=
'The URL of a YAML of parameters; refer to the README notes. The argument '
'parser returns a blob of elements')
args = parser.parse_args()
# Get the data parameters encoded
group, kernels, design, original = arguments.parameters(
elements=args.elements)
"""
Configuration, Instances
"""
# config
configurations = config.Config()
directory = os.path.join(configurations.warehouse, group)
# Instances
interface = cluster.model.interface.Interface(group=group,
kernels=kernels,
directory=directory)
directories = cluster.src.directories.Directories()
main()
return parameters
import time
for optimizer in range(0, 3):
for enum in range(1, 3):
for mnum in range(1, 3):
start = time.time()
data = get_parameters().copy()
data['config']['optimizer'] = optimizer
data['energy_sources'] = data['energy_sources'][:enum]
data['markets'] = data['markets'][:mnum]
myconfig = config.Config(**data['config'])
energy_sources = [
energy_source.EnergySource(**kwargs)
for kwargs in data['energy_sources']
]
markets = [market.Market(**kwargs) for kwargs in data['markets']]
mpc = mpc_solver.MPCSolver(config=myconfig,
markets=markets,
energy_sources=energy_sources)
results = mpc.solve([[30, 200] for i in range(len(markets))],
['free' for i in range(len(markets))])
revenue = 0
penalty = 0
for time_k in range(len(results)):
revenue += sum(
def get_config():
cfg = config.Config()
cfg.add('exp_id', type=str, required=True,
help='Name of experiment ID')
cfg.add('batch_size', type=int, default=128,
help='Training batch size')
cfg.add('test_batch_size', type=int, default=64,
help='Testing batch size')
cfg.add('init_lr', type=float, default=0.03,
help='Initial learning rate')
cfg.add('gpu', type=str, required=True,
help='Value for CUDA_VISIBLE_DEVICES')
cfg.add('gpu_offset', type=int, default=0,
help='GPU offset, useful for KMeans')
cfg.add('image_dir', type=str, required=True,
help='Directory containing dataset')
cfg.add('q_cap', type=int, default=102400,
help='Shuffle queue capacity of tfr data')
cfg.add('data_len', type=int, default=DATA_LEN_IMAGENET_FULL,
help='Total number of images in the input dataset')
# Training parameters
cfg.add('weight_decay', type=float, default=1e-4,
help='Weight decay')
cfg.add('instance_t', type=float, default=0.07,
help='Temperature in softmax.')
cfg.add('instance_k', type=int, default=4096,
help='Closes neighbors to sample.')
cfg.add('lr_boundaries', type=str, default=None,
help='Learning rate boundaries for 10x drops')
cfg.add('train_num_steps', type=int, default=None,
help='Number of overall steps for training')
cfg.add('kmeans_k', type=str, default='10000',
help='K for Kmeans')
cfg.add('model_type', type=str, default='resnet18',
help='Model type, resnet or alexnet')
cfg.add('task', type=str, default='LA',
help='IR for instance recognition or LA for local aggregation')
# Saving parameters
cfg.add('port', type=int, required=True,
help='Port number for mongodb')
cfg.add('db_name', type=str, required=True,
help='Name of database')
cfg.add('col_name', type=str, required=True,
help='Name of collection')
cfg.add('cache_dir', type=str, required=True,
help='Prefix of saving directory')
cfg.add('fre_valid', type=int, default=10009,
help='Frequency of validation')
cfg.add('fre_filter', type=int, default=10009,
help='Frequency of saving filters')
cfg.add('fre_cache_filter', type=int,
help='Frequency of caching filters')
# Loading parameters
cfg.add('load_exp', type=str, default=None,
help='The experiment to load from, in the format '
'[dbname]/[collname]/[exp_id]')
cfg.add('load_port', type=int,
help='Port number of mongodb for loading (defaults to saving port')
cfg.add('load_step', type=int,
help='Step number for loading')
return cfg
'''
import MOD
import GPIO
import SER2
import gsm
import sms
import sms_prot
import sms_msg
import command
import config
#
# Defines
#
CFG = config.Config()
#
# Variables
#
OUT1_OFF_TIME = 0;
OUT1_STATE = 0
IN1_STATE = 0
def executeCommand(command):
global OUT1_STATE
global OUT1_OFF_TIME
ok = 0
if(command.getCommand() == 'OUT1'):
if(command.getParameter() == '0'):
GPIO.setIOvalue(6, 0)
parser = argparse.ArgumentParser()
parser.add_argument('--verbose',
help='more logs',
action='store_true',
default=False)
parser.add_argument('--port', help='port number', type=int, default=80)
parser.add_argument('--host', help='host name', default='localhost')
parser.add_argument('--tls', help='enable TLS', action='store_true')
parser.add_argument('--list',
help='list of available tests',
action='store_true')
parser.add_argument('--test', help='test to run')
# init config
config.current = config.Config(parser)
available_tests = [
DumbHttp2ServerTest(config.current.host, config.current.port,
config.current.tls),
DumbHttp2ClientTest(config.current.port, config.current.tls),
Http1UpgradeTest(config.current)
]
if config.current.list:
# print out all available tests with a short description
for test in available_tests:
print('{0}: {1}'.format(test.name(), test.description()))
elif config.current.test:
# run specified tests
for test in available_tests:
def main():
c = config.Config(os.getcwd() + '/config/config.json')
bot = deltabot.DeltaBot(c)
bot.go()
def get_storage(self):
conf_obj = config.Config("/home/user1/intership/crawler.conf")
conf = conf_obj.config_options
connection = DatabaseConnection(conf)
self.storage = Storage(connection)
from flask import Flask, jsonify, request
import auto_gauge
import config
import led_backpacks
import widget
# Global configuration:
CONFIG_FILENAME = 'config.ini' # Name of configuration file.
SERVER_HOST = '0.0.0.0' # Host to listen on, by default publically accessible.
SERVER_PORT = 5000 # Server port.
# Global application state:
app = Flask(__name__) # The flask application.
config = config.Config(CONFIG_FILENAME) # Dashboard configuration.
widgets = config.get_widgets() # Master widget list.
hw_lock = threading.Lock() # Use a lock to serialize access to any
# hardware. This prevents issues with
# multiple requests trying to write to
# the I2C bus at the same time and
# conflicting.
# API server routes and functions:
@app.route('/widgets', methods=['GET'])
def widgets_get():
"""Serialize list of widgets into a JSON result."""
# Generate a list of widgets with attributes we want to publish.
result = map(
lambda x: {
features = np.stack([mfcc] * 3)
else:
mfcc = librosa.feature.mfcc(data,
sr,
n_fft=config_['n_fft'],
hop_length=config_['hop_length'],
n_mfcc=config_['n_mels'])
delta = librosa.feature.delta(mfcc)
accelerate = librosa.feature.delta(mfcc, order=2)
features = np.stack((mfcc, delta, accelerate)) # (3, 64, xx)
utils.save_data(pname, features)
def wav_to(wavelist: str, config_):
df = pd.read_csv(wavelist)
pool = Pool(10)
# function for feature extraction
tsfm = {'wave': tsfm_wave, 'logmel': tsfm_logmel, 'mfcc': tsfm_mfcc}
tsfm = tsfm.get(config_['data_transform']['to'])
tsfm = partial(tsfm, config_=config_)
pool.map(tsfm, df.iterrows())
if __name__ == '__main__':
utils.make_dirs()
config_ = config.Config() # make changes in params
path = get_wavlist(config_)
wav_to(path, config_)
def get_config(section="Pyhole"):
"""Return the default config object"""
return config.Config(get_conf_file(), section)
def get_config():
"""TODO: Modify config.py"""
cfg = config.Config()
cfg.add('exp_id', type=str, required=True, help='Name of experiment ID')
cfg.add('batch_size', type=int, default=32, help='Training batch size')
cfg.add('gpu',
type=str,
required=True,
help='Value for CUDA_VISIBLE_DEVICES')
# Not sure what this is used for
cfg.add('gpu_offset',
type=int,
default=0,
help='GPU offset, useful for KMeans?')
cfg.add('data_len',
type=int,
default=BREAKFAST_TRAIN_LEN,
help='Total number of videos in the training set')
cfg.add('val_len',
type=int,
default=BREAKFAST_TEST_LEN,
help='Total number of videos in the test set')
cfg.add('pure_test',
type=bool,
default=False,
help='Whether just testing.')
cfg.add('pure_train',
type=bool,
default=False,
help='Whether just training.')
# Model
cfg.add('model_type', type=str, default='vgg_16', help='vgg_16')
cfg.add('emb_size', type=int, default=4096, help='Size of the embedding')
cfg.add('num_units',
type=int,
default=4096,
help='Number of units in LSTM')
cfg.add('train_window_size',
type=int,
default=5,
help='Window size for adaptive learning')
# Data
cfg.add(
'meta_path',
type=str,
default='/data4/shetw/breakfast/metafiles/videos_train_split1.meta',
help='Path to metafile')
cfg.add('test_meta_path',
type=str,
default='/data4/shetw/breakfast/metafiles/videos_test_split1.meta',
help='Path to test metafile')
cfg.add('frame_root',
type=str,
default='/data4/shetw/breakfast/extracted_frames',
help='Root path to frames')
cfg.add('num_frames',
type=int,
default=1500,
help='Number of frames fed into the LSTM')
cfg.add('crop_size',
type=int,
default=224,
help='Size of the cropped input')
cfg.add('flip_frame',
type=bool,
default=False,
help='Whether to flip frames or not (for infant videos)')
cfg.add('file_tmpl',
type=str,
default="Frame_{:06d}.jpg",
help='Size of the cropped input')
cfg.add('shuffle',
type=bool,
default=True,
help='Shuffle the dataset or not during training')
# Saving parameters
cfg.add('port', type=int, required=True, help='Port number for mongodb')
cfg.add('host', type=str, default='localhost', help='Host for mongodb')
cfg.add('db_name', type=str, required=True, help='Name of database')
cfg.add('col_name', type=str, required=True, help='Name of collection')
cfg.add('cache_dir',
type=str,
required=True,
help='Prefix of cache directory for tfutils')
cfg.add('fre_valid',
type=int,
default=10009,
help='Frequency of validation')
cfg.add('fre_metric',
type=int,
default=1000,
help='Frequency of saving metrics')
cfg.add('fre_filter',
type=int,
default=10009,
help='Frequency of saving filters')
cfg.add('fre_cache_filter', type=int, help='Frequency of caching filters')
# Loading parameters
cfg.add('load_exp',
type=str,
default=None,
help='The experiment to load from, in the format '
'[dbname]/[collname]/[exp_id]')
cfg.add('load_port',
type=int,
help='Port number of mongodb for loading (defaults to saving port')
cfg.add('load_step', type=int, help='Step number for loading')
cfg.add(
'resume',
type=bool,
help='Flag for loading from last step of this exp_id, will override'
' all other loading options.')
cfg.add('from_ckpt',
type=str,
default=None,
help='The ckpt file path to be loaded from')
# Learning rate
cfg.add('init_lr', type=float, default=5e-9, help='Initial learning rate')
cfg.add('big_lr',
type=float,
default=1e-8,
help='Bigger learning rate in adaptive training')
cfg.add('small_lr',
type=float,
default=1e-9,
help='Smaller learning rate in adaptive training')
cfg.add('target_lr',
type=float,
default=None,
help='Target leraning rate for ramping up')
cfg.add('lr_boundaries',
type=str,
default=None,
help='Learning rate boundaries for 10x drops')
cfg.add('ramp_up_epoch',
type=int,
default=1,
help='Number of epoch for ramping up')
return cfg
class MotionDetectorWebcam:
gHighestSeenChange = 1
gMidiChange = 0
gSync = 0
gRun = True
# use default value before setConfig has been called
conf = config.Config()
def start(self, conf):
self.conf = conf
threading.Thread(target=self.heartbeat_thread).start()
threading.Thread(target=self.video_thread).start()
def __init__(self):
#use JACK
mido.set_backend('mido.backends.rtmidi/UNIX_JACK')
return
def die(self):
self.gRun = False
def video_thread(self):
# open midi port
self.out_port = mido.open_output('Output',
client_name='Motion Detector (OUT)')
logging.info('Output port: {}'.format(self.out_port))
camera = cv2.VideoCapture(0)
time.sleep(0.25)
if self.conf.C_DISPLAY_VIDEO == 1:
cv2.namedWindow("M2M Motion", cv2.WINDOW_NORMAL)
# initialize the first frame in the video stream
previousFrame = None
gray = None
# loop over the frames of the video
while self.gRun:
(grabbed, frame) = camera.read()
# if the frame could not be grabbed, then we have reached the end
# of the video
if not grabbed:
break
# save the previous frame and grab a new
previousFrame = gray
# resize the frame, convert it to grayscale, and blur it
frame = imutils.resize(frame, width=500)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
# skip diff if this was the first frame
if previousFrame is None:
continue
# compute the absolute difference between the current frame and
# previous frame
frameDelta = cv2.absdiff(previousFrame, gray)
thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]
# dilate the thresholded image to fill in holes, then find contours
# on thresholded image
thresh = cv2.dilate(thresh, None, iterations=2)
# compress image array to one int
currentChange = sum(sum(thresh))
# update the highest found if needed
if currentChange >= self.gHighestSeenChange:
self.gHighestSeenChange = currentChange
# calucate the amount of change and make it into a MIDI (0-127)
percent = float(currentChange) / float(self.gHighestSeenChange)
self.gMidiChange = int(percent * 127)
# send a MIDI message based on timing
if self.conf.C_TRIGGER_BY_TIMING == 1:
if self.gSync == 0:
self.gSync = self.conf.C_VIDEO_FPS / self.conf.C_MIDI_MPS
logging.debug("Sending " + str(self.gMidiChange))
cc = Message('control_change',
channel=13,
control=1,
value=int(self.gMidiChange))
self.out_port.send(cc)
else:
self.gSync = self.gSync - 1
# slowly readjust the highest found
if self.conf.C_READJUST_AMOUNT != 0 and self.gHighestSeenChange >= int(
self.conf.C_READJUST_AMOUNT):
self.gHighestSeenChange = self.gHighestSeenChange - self.conf.C_READJUST_AMOUNT
# show display if needed
if self.conf.C_DISPLAY_VIDEO == 1:
cv2.putText(thresh,
"Movement in MIDI: {}".format(self.gMidiChange),
(10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(255, 255, 255), 2)
cv2.imshow("M2M Motion", thresh)
# check for keyboard input
cv2.waitKey(1) & 0xFF
ms = 1000 / self.conf.C_VIDEO_FPS
time.sleep(ms / 1000.0) # 1000.0 because we want a float
# cleanup the camera and close any open windows
camera.release()
cv2.destroyAllWindows()
logging.info("Leaving Video thread.")
def heartbeat_thread(self):
in_port = mido.open_input('Heartbeat',
client_name='Motion Detector (HB)')
logging.info("Incoming port: {}".format(in_port))
global gMidiChange
while self.gRun:
for msg in in_port.iter_pending():
if self.conf.C_TRIGGER_BY_HEARTBEAT == 0:
continue
logging.debug("[HB] Sending " + str(self.gMidiChange))
cc = Message('control_change',
channel=13,
control=1,
value=int(self.gMidiChange))
self.out_port.send(cc)
time.sleep(0.1)
logging.info("Leaving Heartbeat thread.")
menu = input('Which information do you want to know : ')
if menu == '1':
i = index.Index(driver_path)
i.print_index()
elif menu == '2':
stockgraph.run()
elif menu == '3':
r = rate.Rate(driver_path)
r.print_rate()
elif menu == '4':
r = rate.Rate(driver_path)
r.calculate_rate()
elif menu == '5':
realtimePrice.run_mystock()
break
elif menu == '6':
import sys
sys.exit()
else:
print('invalid number!! write valid number')
except KeyboardInterrupt as e:
print('시스템이 강제로 종류 되었습니다.\n')
break
if __name__ == '__main__':
conf = config.Config('./fin.conf')
driver = conf.fallback['driver']['path']
run(driver)
def main(argv):
ld("argv", argv)
program_version = "v{}".format(__version__)
program_build_date = str(__updated__)
program_version_message = "{}, built {}".format(program_version,
program_build_date)
args = lib_argparse.parser(program_version_message)
ld(args)
#initialize class to hold configuration:
conf = config.Config()
#parse arguments:
#check verbose/debug mode:
if args.verbose or DEBUG:
conf.debug = True
set_log_level('debug')
#get folder contents:
conf.input_folder = args.input_folder
try:
folder_contents = lib_tree.Parse(conf.input_folder)
ld("folder_contents", folder_contents)
except lib_exceptions.FolderNotFound as err:
lc(err.msg)
conf.audio_files = folder_contents.audio_files
ld("conf.audio_files",
conf.audio_files) # TODO: check if audio files present
conf.cover = folder_contents.cover
ld("conf.cover", conf.cover)
if not conf.cover:
lw("No cover files specified or found. No artwork will be used.")
get_metadata(args, conf)
#simple text editor to display and edit metadata:
lib_editor.Editor(conf)
#set metadata for each audio file:
track_no = 0
files_with_tags = list()
for file in conf.audio_files:
track_no += 1
file_tags = {
"file":
file,
"cover":
conf.cover,
"title":
conf.title_full(track=track_no),
"sort_title":
conf.title_sort,
"artist":
"{} (read by {})".format(conf.authors_string,
conf.narrators_string),
"album_artist":
conf.authors_string,
"album":
conf.series_title or conf.title,
"track_no":
track_no,
"total_no":
len(conf.audio_files),
"disk_no":
conf.series_position,
"year":
conf.date,
"description":
conf.description,
"copyright":
conf.copyright
}
files_with_tags.append(file_tags)
#replace previous audio files with the full dict:
conf.audio_files = files_with_tags
ld(conf.audio_files)
#setup paths for binary tools:
main_path = os.path.split(os.path.realpath(__file__))[0]
if platform.system() == "Windows":
tools_path = os.path.join(main_path, "tools\win")
mp4box_path = os.path.join(tools_path, "MP4Box.exe")
ap_path = os.path.join(tools_path, "AtomicParsley.exe")
else:
tools_path = os.path.join(main_path, "tools/mac")
mp4box_path = os.path.join(tools_path, "MP4Box")
ap_path = os.path.join(tools_path, "AtomicParsley")
ld("main_path", main_path)
ld("tools_path", tools_path)
ld("mp4box_path", mp4box_path)
ld("ap_path", ap_path)
#for each file in the list of files to process
#first prepare the blank file to tag (remux),
#then tag with given metadata:
for file_data in conf.audio_files:
#create a separate instance of each class for each file
#this way all command line arguments and subprocess instances are separated:
mux = lib_mux.MP4Box(mp4box_path)
tag = lib_tag.APTagger(ap_path)
try:
if mux.remux(file_data["file"], file_data["track_no"]):
if tag.tag(file_data):
print("Finished tagging file: {}".format(
file_data["file"]))
#remove class instances:
del mux
del tag
except FileNotFoundError as err:
lc(err)
except lib_exceptions.MP4BoxError as err:
lc(err)
print("Done!")
import os, glob, time
import torch
from torch.utils.data import Dataset, DataLoader
from obspy import read, UTCDateTime
import numpy as np
import config
# preprocess params
cfg = config.Config()
decim_rate = cfg.decim_rate
samp_rate = 100. / decim_rate
freq_band = cfg.freq_band
win_trig = cfg.win_trig
win_p = cfg.win_p
win_s = cfg.win_s
npts_trig = int(sum(win_trig) * samp_rate) + 1
temp_win = [int(sum(win) * samp_rate) + 1 for win in [win_trig, win_p, win_s]]
def preprocess(st):
# time alignment
start_time = max([tr.stats.starttime for tr in st])
end_time = min([tr.stats.endtime for tr in st])
st = st.slice(start_time, end_time)
# signal process
st = st.decimate(decim_rate)
st = st.detrend('demean').detrend('linear').taper(max_percentage=0.05,
max_length=10.)
flt_type = freq_band[0]
freqmin = freq_band[1]
if len(freq_band) == 2:
import torch.nn as nn
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
import numpy as np
from sklearn.metrics import accuracy_score
from utils.function import init_logging, init_environment, get_lr, \
print_loss_sometime
from utils.metric import mean_class_recall
import config
import dataset
import model
from loss import class_balanced_loss
configs = config.Config()
configs_dict = configs.get_config()
# Load hyper parameter from config file
exp = configs_dict["experiment_index"]
cuda_ids = configs_dict["cudas"]
num_workers = configs_dict["num_workers"]
seed = configs_dict["seed"]
n_epochs = configs_dict["n_epochs"]
log_dir = configs_dict["log_dir"]
model_dir = configs_dict["model_dir"]
batch_size = configs_dict["batch_size"]
learning_rate = configs_dict["learning_rate"]
backbone = configs_dict["backbone"]
eval_frequency = configs_dict["eval_frequency"]
resume = configs_dict["resume"]
optimizer = configs_dict["optimizer"]
def create_app(test_config=None):
log = logging.getLogger(__name__)
discovery = OIDCDiscovery()
# a = connexion.FlaskApp(__name__, specification_dir='v1/spec/')
# a.add_api('v1.yaml', arguments={
# "tokeninfo_url": discovery["introspection_endpoint"],
# "authorization_url": discovery["authorization_endpoint"],
# "accesstoken_url": discovery["token_endpoint"]
# })
# app = a.app
app = Flask(__name__)
conf = config.Config()
if test_config is None:
app.config.update(conf.data)
else:
# load the test config if passed in
app.config.update(conf.data)
app.config.update(test_config)
##Routes##
v1.Register(app)
Compress(app)
## Template the spec and write it to a temporary location
tmpFile = "%s/v1.yaml" % conf.data['workingFolder']
f = open("v1/spec/v1.yaml", "r")
t = Template(f.read())
f = open(tmpFile, "w")
f.write(
t.render(server_url="/v1",
tokeninfo_url=discovery["introspection_endpoint"],
authorization_url=discovery["authorization_endpoint"],
accesstoken_url=discovery["token_endpoint"]))
api_doc(app, config_path=tmpFile, url_prefix='/api/doc', title='API doc')
@app.before_request
def before_request():
from timeit import default_timer as timer
g.request_start_time = timer()
g.request_time = lambda: "%s" % (timer() - g.request_start_time)
resp = Response()
resp.headers['Content-Type'] = ["application/json"]
@app.after_request
def after_request(response):
set_cors_headers_on_response(response)
log.debug('Rendered in %ss', g.request_time())
return response
@app.errorhandler(HTTPStatus.NOT_FOUND)
def not_found(param):
content = jsonify({"error": "Not Found", "code": HTTPStatus.NOT_FOUND})
return make_response(content, HTTPStatus.NOT_FOUND)
@app.errorhandler(HTTPStatus.INTERNAL_SERVER_ERROR)
def internal_server_error(error):
log = app.logger
log.error("Internal Error %s - %s" % (request.remote_addr, str(error)))
content = jsonify({
"error": "{error}",
"code": HTTPStatus.INTERNAL_SERVER_ERROR
})
log.error(request.get_data())
log.error(request.form)
log.error(request.headers)
return make_response(content, HTTPStatus.INTERNAL_SERVER_ERROR)
@app.errorhandler(HTTPStatus.BAD_REQUEST)
def bad_request_error(error):
log = app.logger
log.error("Bad Request %s - %s" % (request.remote_addr, str(error)))
content = jsonify({
"error": "Bad Request",
"code": HTTPStatus.BAD_REQUEST
})
log.error(request.get_data())
log.error(request.form)
log.error(request.headers)
return make_response(content, HTTPStatus.BAD_REQUEST)
@app.errorhandler(JoseError)
def forbidden(error):
log.error("Denied access %s - %s" % (request.remote_addr, str(error)))
content = jsonify({"error": "Invalid Token"})
return make_response(content, HTTPStatus.UNAUTHORIZED)
@app.errorhandler(ExpiredTokenError)
def expired_token(error):
content = jsonify({"error": "Token Expired"})
return make_response(content, HTTPStatus.UNAUTHORIZED)
@app.route('/', methods=['GET'], strict_slashes=False)
def index():
"""
Returns a list of valid API version endpoints
:return: JSON of valid API version endpoints
"""
return jsonify([url_for(".v1.get_status", _external=True)])
@app.route('/version', methods=['GET'], strict_slashes=False)
def version():
"""
Get the current version of the api
"""
from os import environ
hash = ""
if environ.get('GITHASH') is not None:
hash = environ.get("GITHASH")
# import pkg_resources # part of setuptools
# print(pkg_resources)
# v = pkg_resources.get_distribution("gwa-kong").version
v = ""
version = v
if hash != "":
version += "-" + hash
responseObj = {"v": v, "hash": hash, "version": version}
return jsonify(responseObj)
return app
def readConfig():
""" Read the configuration from the configuration file in the current
working directory.
"""
global smtpconfig, mailaccounts, port, msgdir, sleeptime, waitafterpop, debuglevel, deleteonerror
if os.path.exists(configFile) == False:
print('Configuration file "' + configFile + '" doesn'
't exist. Exiting.')
return False
smtpconfig = config.Config()
smtpconfig.read([configFile])
# Read basic configuration
port = smtpconfig.getint('config', 'port', port) # port of the smtp proxy
msgdir = smtpconfig.getint(
'config', 'msgdir',
"./msgs") # directory where to store temporary messages
sleeptime = smtpconfig.getint('config', 'sleeptime',
sleeptime) # sleep time for sending thread
waitafterpop = smtpconfig.getint(
'config', 'waitafterpop',
waitafterpop) # time to wait after pop authentication
debuglevel = smtpconfig.getint(
'config', 'debuglevel', debuglevel) # debuglevel for various functions
deleteonerror = smtpconfig.getboolean(
'config', 'deleteonerror', deleteonerror) # delete mail on error
# Read accounts
for s in smtpconfig.sections():
if s not in ['logging', 'config']:
account = MailAccount()
account.useconfig = smtpconfig.get(s, 'use', account.useconfig)
if account.useconfig != None:
mailaccounts[s] = account
continue
account.rsmtphost = smtpconfig.get(s, 'smtphost',
account.rsmtphost)
account.rsmtpport = smtpconfig.getint(s, 'smtpport',
account.rsmtpport)
account.rsmtpsecurity = smtpconfig.get(s, 'smtpsecurity',
account.rsmtpsecurity)
account.rpophost = smtpconfig.get(s, 'pophost', account.rpophost)
account.rpopport = smtpconfig.getint(s, 'popport',
account.rpopport)
account.rpopssl = smtpconfig.getboolean(s, 'popssl',
account.rpopssl)
account.rpopuser = smtpconfig.get(s, 'popusername',
account.rpopuser)
account.rpoppass = smtpconfig.get(s, 'poppassword',
account.rpoppass)
account.rPBS = smtpconfig.getboolean(s, 'popbeforesmtp',
account.rPBS)
account.rpopcheckdelay = smtpconfig.getint(s, 'popcheckdelay',
account.rpopcheckdelay)
account.rsmtpuser = smtpconfig.get(s, 'smtpusername',
account.rsmtpuser)
account.rsmtppass = smtpconfig.get(s, 'smtppassword',
account.rsmtppass)
account.localhostname = smtpconfig.get(s, 'localhostname',
account.localhostname)
account.returnpath = smtpconfig.get(s, 'returnpath',
account.returnpath)
# check config
if account.rsmtphost == None:
mlog.logerr('Wrong configuration: smtphost is missing')
return False
if account.rPBS:
if account.rpophost == None:
mlog.logerr('Wrong configuration: pophost is missing')
return False
if account.rpopuser == None:
mlog.logerr('Wrong configuration: popuser is missing')
return False
if account.rpoppass == None:
mlog.logerr('Wrong configuration: poppass is missing')
return False
if account.rsmtpport == 0: # Different default port depending on security type
if account.rsmtpsecurity == 'none' or account.rsmtpsecurity == 'tls':
account.rsmtpport = 25
else: # ssl
account.rsmtpport = 465
mailaccounts[s] = account
# make temporary directory
try:
if os.path.exists(msgdir) == False:
os.makedirs(msgdir)
except:
print('Can' 't create message directory ' + msgdir)
return False
return True
