def check_data_integrity(bot):
'''Checks and fixes the file integrity of Data.\n
A.K.A Replaces files which are currupt, missing, ETC.\n
Also replaces values that have been set incorrectly.'''
for server in bot.servers:
server_path = "Data/" + server.id
#This is for the main server folder.
if not os.path.exists(server_path):
os.makedirs(server_path)
#And this is for the json files contained within.
check_json(server_path + "/RolesConfig.json", {})
check_json(server_path + "/CommandConfig.json", {})
check_json(server_path + "/EventConfig.json", {})
check_json(server_path + "/FunctionConfig.json", {})
check_json(server_path + "/UserConfig.json", {})
if check_json(server_path + "/ServerConfig.json", server_config):
set_default_config_values(server)
update_config_keys(server)
replace_invalid_values(server)
remove_absent_servers(bot)
for member in server.members:
if member.server.get_channel(configs.get_config(configs.server_config, server.id)["MainChannel"]).permissions_for(member).administrator:
if member.id not in configs.get_config(configs.user_config, server.id):
configs.set_config(server.id, "Users", member.id)
configs.set_config(server.id, "Users", member.id + " / GodMode / true")
def replace_invalid_values(server):
"Replaces values in servers configs that are invalid"
#Replacing main_channel if channel does not exist
main_channel = configs.get_config(configs.server_config, server.id)["MainChannel"]
reset = True
for channel in server.channels:
if channel.id == main_channel:
reset = False
if reset:
configs.set_config(server.id, "Server", "MainChannel / " + get_default_config(server)["MainChannel"])
def set_default_config_values(server):
"Sets server's ServerConfig.json to default values."
default_config = get_default_config(server)
configs.set_config(server.id, "Server", "MainChannel / " + default_config["MainChannel"])
configs.set_config(server.id, "Server", "JoinMessage / " + default_config["JoinMessage"])
configs.set_config(server.id, "Server", "StartMessage / " + default_config["StartMessage"])
configs.set_config(server.id, "Server", "NoPermissonMessage / " + default_config["NoPermissonMessage"])
if __name__ == '__main__':
# Set env
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.enabled = True
# Set seed
seed = 2019
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
# Config
args = set_config()
enable_dump_neuron_per_layer = False
# should be fa
enable_hidden_sum = False
assert not enable_hidden_sum
if args.checkpoint_dir is not None:
if args.enable_train:
args.checkpoint_dir = os.path.join(args.checkpoint_dir, 'sz{}_d{}_s{}'.format(args.spatial_size, args.dim, args.scale))
if args.number_of_fmaps != 4:
args.checkpoint_dir = args.checkpoint_dir + '_depth{}'.format(args.number_of_fmaps)
if args.enable_neuron_prune:
if (args.layer_sparsity_list is not None) and (args.layer_sparsity_list > 0):
async def main_bot_loop():
await bot_client.bot.wait_until_ready()
await asyncio.sleep(1)
while True:
CURRENT_TIME = time.time()
#Checking each server
for server in bot_client.bot.servers:
helpers.check_data_integrity(bot_client.bot)
#Events
events = configs.get_config(configs.event_config, server.id)
events_to_delete = []
for event in events:
if events[event]["Enabled"]:
do_execute = False
last_execution = events[event]["LastExecuted"]
time_since_last_execution = CURRENT_TIME - last_execution
#Execute on TimeOfExecution
if events[event]["Repeat"] == "None":
try:
event_time = datetime.datetime(events[event]["TimeOfExecution"]["Year"],events[event]["TimeOfExecution"]["Month"],events[event]["TimeOfExecution"]["Day"], events[event]["TimeOfExecution"]["Hour"], events[event]["TimeOfExecution"]["Min"], events[event]["TimeOfExecution"]["Second"])
if CURRENT_TIME > event_time.timestamp():
do_execute = True
except:
await bot_client.bot.send_message(server.get_channel(configs.get_config(configs.server_config, server.id)["MainChannel"]), "**Invalid time set in event " + event + ". Disabling.**")
configs.set_config(server.id, "Events", event + " / Enabled / false")
#Execute every minute
if events[event]["Repeat"] == "Min":
if (time_since_last_execution / 60) > 1:
do_execute = True
#Execute every hour
if events[event]["Repeat"] == "Hour":
if ((time_since_last_execution / 60) / 60) > 1:
do_execute = True
#Execute every day
if events[event]["Repeat"] == "Day":
if (((time_since_last_execution / 60) / 60) / 24) > 1:
do_execute = True
#Execute every week
if events[event]["Repeat"] == "Week":
if ((((time_since_last_execution / 60) / 60) / 24) / 7) > 1:
do_execute = True
#Execute every month
if events[event]["Repeat"] == "Month":
if ((((time_since_last_execution / 60) / 60) / 24) / 30) > 1:
do_execute = True
if do_execute:
print("Executing", event, "in", server.id)
await logic.execute_function(bot_client.bot, server.get_channel(configs.get_config(configs.server_config, server.id)["MainChannel"]), events[event], events[event]["Args"])
configs.set_config(server.id, "Events", event + " / LastExecuted / " + str(int(CURRENT_TIME)))
#If event is not repeating
if events[event]["Repeat"] != "Min" and "Hour" and "Day" and "Week" and "Month":
events_to_delete.append(event)
#Writing Changes
configs.set_config(server.id, "Events", events_to_delete)
await asyncio.sleep(1)
print('Using device:', device, ' - ', torch.cuda.get_device_name(0))
story_selector = ['st1', 'st2', 'st3']
task_name = 'ComParE2020_USOMS-e'
executable_models = [
'frozen-bert-gmax', 'frozen-bert-rnnatt', 'frozen-bert-pos-fuse-rnnatt'
]
labels = ['V_cat_no', 'A_cat_no'
] #'V_self_cat_no', 'A_self_cat_no', 'V_exp_cat_no', 'A_exp_cat_no'
partitions = ['train', 'devel', 'test']
for model_name in executable_models:
print('-- ', model_name, ' --')
for label in labels:
# load config
config = configs.set_config(label, story_selector, model_name)
torch.cuda.empty_cache()
# load data
df, temp_numpy_data_splits, labels_df_cat, labels_numpy_hot = data.get_data(
config)
# create and add part-of-speech tagging
if config.pos_embedding:
if config.verbose > 0:
print("Create pos embedding")
part_of_speech = pos.add_pos_embeddings(
task_name=task_name,
temp_numpy_data_splits=temp_numpy_data_splits,
MAX_LEN=config.max_seq_length,
import os
from third_party.PSM.models import *
from third_party.efficient_3DCNN.model import generate_model
from third_party.unet.model import UNet3D
from third_party.thop.thop.profile import profile
from pruning.pytorch_snip.prune import pruning
from configs import set_config
from aux.utils import weight_init
if __name__ == "__main__":
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.enabled = True
min_sparsity, max_sparsity = 0., 1.
opt = set_config()
opt.network_name = opt.model
if opt.dataset == 'ucf101':
if opt.network_name == 'i3d':
opt.sample_duration = 16
opt.sample_size = 224
opt.prune_spatial_size = opt.sample_size
elif opt.network_name == 'mobilenetv2':
opt.sample_duration = 16
opt.sample_size = 112
opt.groups = 3
opt.width_mult = 1.0
opt.prune_spatial_size = opt.sample_size
else:
assert False
def main(Param):
train_df, val_df, test_df = read_text_file()
if args.fine_tuning:
weights_list = class_weights(train_df)
model = ClassificationModel(args.model_type,
args.model_name,
num_labels=3,
weight=weights_list,
use_cuda=CUDA,
args=Param)
model.train_model(train_df,
eval_df=val_df,
f1=f1,
uar=uar,
verbose=False)
model = ClassificationModel(args.model_type,
Param['best_model_dir'],
num_labels=3,
use_cuda=CUDA)
evaluate(model, train_df, val_df, test_df)
extract_dutch_bert_embedding(train_df, 'train',
Param['best_model_dir'])
extract_dutch_bert_embedding(val_df, 'devel', Param['best_model_dir'])
extract_dutch_bert_embedding(test_df, 'test', Param['best_model_dir'])
else:
extract_dutch_bert_embedding(train_df, 'train')
extract_dutch_bert_embedding(val_df, 'devel')
extract_dutch_bert_embedding(test_df, 'test')
if args.fusion_type == 'rnnatt':
config = set_config()
X_train, y_train = load_feature_vectors(train_df, config)
X_devel, y_devel = load_feature_vectors(val_df, config)
X_test, _ = load_feature_vectors(test_df, config)
y_train_df = train_df['label']
model = models.create_bert_rnn_att(config)
model, history = train_model(config, model, X_train, y_train, X_devel,
y_devel, y_train_df)
export_results(model, config, X_train, X_devel, y_train, y_devel)
output_model_features(model,
data={
'train': X_train,
'devel': X_devel,
'test': X_test
},
df={
'train': train_df,
'devel': val_df,
'test': test_df
})
# to be save - free memory
del model
torch.cuda.empty_cache()
async def execute_attributes(bot, dic):
global target_member
global remaining_args
#Executing layer one attributes
if "addroles" in dic:
await helpers.give_roles(bot, target_member, dic["addroles"])
if "say" in dic:
amount = None
try:
amount = dic["say"][0]
except:
if len(remaining_args) > 0:
amount = remaining_args[0]
del remaining_args[0]
try:
send_channel = channel.server.get_channel(dic["say"][1])
except:
send_channel = channel
if amount != None:
await bot.send_message(send_channel, amount)
else:
await missing_args("No message set for say.")
return False
if "removemessages" in dic:
amount = None
try:
amount = int(dic["removemessages"][0])
except:
if len(remaining_args) > 0:
amount = int(remaining_args[0])
del remaining_args[0]
try:
send_channel = channel.server.get_channel(
dic["removemessages"][1])
except:
send_channel = channel
if amount != None:
async for amount in bot.logs_from(channel, amount):
await bot.delete_message(amount)
else:
await missing_args("Amount not specified for removemessages")
return False
if "addevent" in dic:
remaining_args = dic["addevent"][1:] + remaining_args
i = 0
event_name = "Event_0"
while str(event_name) in configs.get_config(
configs.event_config, channel.server.id):
event_name = "Event_" + str(i)
i += 1
configs.set_config(channel.server.id, "Events", event_name)
#Functions
configs.set_config(
channel.server.id, "Events",
event_name + " / Functions / " + dic["addevent"][0])
#Execution time
if remaining_args[0][0] == "+":
seconds = int(remaining_args[1])
if len(remaining_args[0]) > 1:
if remaining_args[0][1] == "m":
seconds = int(remaining_args[1]) * 60
if remaining_args[0][1] == "h":
seconds = int(remaining_args[1]) * 3600
if remaining_args[0][1] == "d":
seconds = int(remaining_args[1]) * 86400
if remaining_args[0][1] == "w":
seconds = int(remaining_args[1]) * 604800
if remaining_args[0][1] == "mo":
seconds = int(remaining_args[1]) * 2592000
if remaining_args[0][1] == "y":
seconds = int(remaining_args[1]) * 31536000
del remaining_args[0]
del remaining_args[0]
time_of_execution = datetime.datetime.fromtimestamp(
time.time() + seconds)
configs.set_config(
channel.server.id, "Events", event_name +
" / TimeOfExecution / " + str(time_of_execution.year) +
" " + str(time_of_execution.month) + " " +
str(time_of_execution.day) + " " +
str(time_of_execution.hour) + " " +
str(time_of_execution.minute) + " " +
str(time_of_execution.second))
else:
if len(remaining_args) < 6:
configs.set_config(
channel.server.id, "Events",
event_name + " / TimeOfExecution / " +
remaining_args[0] + " " + remaining_args[1] + " " +
remaining_args[2] + " " + remaining_args[3] + " " +
remaining_args[4] + " " + remaining_args[5])
remaining_args = remaining_args[6:]
else:
await missing_args("No time set for addevent.")
return False
#Args
#Checks if addevent needs target_member if so adds it to it's args.
attributes_in_event = get_required_attributes(dic["addevent"][0])
if "containsroles" in attributes_in_event or "haspermisson" in attributes_in_event or "addroles" in attributes_in_event:
remaining_args = [target_member.id] + remaining_args
configs.set_config(
channel.server.id, "Events",
event_name + " / Args / " + " ".join(remaining_args))
remaining_args.clear()
configs.set_config(channel.server.id, "Events",
event_name + " / Enabled / true")
