def main(img_dir, img_name, classes):
config = Config()
config.batch_size = 1
config.num_classes = 2
result = {}
for index in classes:
result[index] = predict(img_dir + img_name, index, config)
print(result)
return result
class TestConfig(TestCase):
def setUp(self):
self.config = Config()
def test_append_to_log(self):
self.fail()
def test_get_log_filename_for_date(self):
test_datetime = datetime.datetime(2014, 4, 17)
result_filename = self.config.get_log_filename_for_date(test_datetime, 'c:/')
self.assertEquals('c:/2014-04-17.log', result_filename)
def test_get_last_log_line_for_today(self):
self.fail()
def test_get_last_log_line_for_file(self):
last_line = self.config.get_last_log_line_for_file('2013_10_31.log')
self.assertEquals(u'After timer implemented', last_line)
def test_load(self):
#Mock open to return the confi_data from file
with patch.object(builtins,'open',mock_open(read_data=self.config_data)) as m:
Config.load("test")
self.assertEqual(Config.search_queries, ["test"])
self.assertEqual(Config.follow_keywords,["test"])
self.assertEqual(Config.scan_update_time, 1)
self.assertEqual(Config.retweet_update_time, 1)
self.assertEqual(Config.rate_limit_update_time, 1)
self.assertEqual(Config.min_ratelimit, 1)
self.assertEqual(Config.min_ratelimit_search, 1)
self.assertEqual(Config.clear_queue_time, 1)
self.assertEqual(Config.min_posts_queue, 1)
self.assertEqual(Config.blocked_users_update_time, 1)
self.assertEqual(Config.max_follows, 1)
self.assertEqual(Config.consumer_key, "test")
self.assertEqual(Config.consumer_secret, "test")
self.assertEqual(Config.access_token_key, "test")
self.assertEqual(Config.access_token_secret, "test")
def test_load(self):
#Mock open to return the confi_data from file
with patch.object(builtins, 'open',
mock_open(read_data=self.config_data)) as m:
Config.load("test")
self.assertEqual(Config.search_queries, ["test"])
self.assertEqual(Config.follow_keywords, ["test"])
self.assertEqual(Config.scan_update_time, 1)
self.assertEqual(Config.retweet_update_time, 1)
self.assertEqual(Config.rate_limit_update_time, 1)
self.assertEqual(Config.min_ratelimit, 1)
self.assertEqual(Config.min_ratelimit_search, 1)
self.assertEqual(Config.clear_queue_time, 1)
self.assertEqual(Config.min_posts_queue, 1)
self.assertEqual(Config.blocked_users_update_time, 1)
self.assertEqual(Config.max_follows, 1)
self.assertEqual(Config.consumer_key, "test")
self.assertEqual(Config.consumer_secret, "test")
self.assertEqual(Config.access_token_key, "test")
self.assertEqual(Config.access_token_secret, "test")
class api:
scope = "https://www.googleapis.com/auth/spreadsheets"
store = file.Storage("token.json")
creds = store.get()
if not creds or creds.invalid:
flow = client.flow_from_clientsecrets('credentials.json', scope)
creds = tools.run_flow(flow, store)
service = build('sheets', 'v4', http=creds.authorize(Http()))
conf = Config()
sheets = Sheets(conf.spreadsheet_ID, conf.google_API_key)
sheet_id = conf.sheet_id
sheet_names = sheets.sheet_names
value_request = service.spreadsheets().values()
server_config = {
"port":
5001,
"reader":
WebNLGDataReader,
"planner":
NaivePlanner(
WeightedProductOfExperts([
RelationDirectionExpert, GlobalDirectionExpert,
SplittingTendenciesExpert, RelationTransitionsExpert
]))
}
dataset_name = server_config["reader"].DATASET
main_config = Config(reader=server_config["reader"],
planner=server_config["planner"])
base_path = os.path.dirname(os.path.abspath(__file__))
def server(pipeline_res, host, port, debug=True):
app = Flask(__name__)
CORS(app)
# @app.route('/', methods=['GET'])
# @app.route('/index.html', methods=['GET'])
# def root():
# print("got to root")
# return app.send_static_file('static/index.html')
@app.route('/graphs', methods=['GET'])
import sys
sys.path.insert(0, '../../filling_level/vggish/') # nopep8
from main import Config, run_kfold, get_cmd_args
from time import localtime, strftime
# import argparse
if __name__ == "__main__":
# Reproduce the best experiment
# if True, will use the pre-trained model and make predictions, if False, will train the model
use_pretrained = True
exp_name = 200903163404
cfg = Config()
cfg.load_from(path=f'./predictions/{exp_name}/cfg.txt')
# replacing the time with the old_time + current_time such that there is no collision
if use_pretrained:
cfg.init_time = exp_name
else:
cfg.init_time = f'{cfg.init_time}_{strftime("%y%m%d%H%M%S", localtime())}'
# Expected average of Best Metrics on Each Valid Set: 0.912957 @ 200903163404
run_kfold(cfg, use_pretrained, get_cmd_args().predict_on_private)
# Experiment with other parameters
# cfg = Config()
# cfg.assign_variable('task', 'ftype')
# cfg.assign_variable('output_dim', 4)
# cfg.assign_variable('model_type', 'GRU')
# cfg.assign_variable('bi_dir', False)
# cfg.assign_variable('device', 'cuda:0')
# cfg.assign_variable('data_root', '../../filling_level/vggish/vggish_features')
# cfg.assign_variable('batch_size', 64)
# cfg.assign_variable('input_dim', 128)
def load_config(DOMAIN):
CONFIG_PATH = "config/" + DOMAIN
global config
config = Config()
config.load_from_file(CONFIG_PATH)
return config, DEVICE
for idx in range(len(rev_outputs[1][0])):
print('*' * 20, 'pos sample', '*' * 20, file=fw)
print('[gold]', gold_text[1][idx], file=fw)
print('[raw 1.0]', raw_output[1][idx], file=fw)
for i, r in enumerate(ratios):
print(f'[rev {1-r: .1f}]', rev_outputs[1][i][idx], file=fw)
print('[ref ]', ref_text[1][idx], file=fw)
print('*' * 20, '********', '*' * 20, file=fw)
model_F.train()
if __name__ == '__main__':
config = Config()
config.save_folder = config.save_path + '/' + str(time.strftime('%b%d%H%M%S', time.localtime()))
os.makedirs(config.save_folder)
os.makedirs(config.save_folder + '/ckpts')
print('Save Path:', config.save_folder)
train_iters, dev_iters, test_iters, vocab = load_dataset(config)
# print(len(vocab))
# for batch in test_iters:
# text = tensor2text(vocab, batch[0])
# print('\n'.join(text))
# print(batch.label)
# break
model_F = StyleTransformer(config, vocab).to(config.device)
image_validate=image_all[index_validate]
yield_validate=yield_all[index_validate]
s = 'H-32|C-9|lstm_h-128|B-2|dense-64|lstm_conv_filters-64|model_type-conv_lstm|keep_prob-0.5|L-1|conv_type-valid|dataset-standard'
# s = {
# 'H': 32,
# 'model_type': 'lstm',
# 'C': 9,
# 'B': 2
# }
c = Config(s)
model = LSTM(c, regression=True)
os.environ['CUDA_VISIBLE_DEVICES'] = '0' # Or whichever device you would like to use
gpu_options = tf.GPUOptions(allow_growth=True)
saver = tf.train.Saver()
with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True)) as sess:
sess.run(tf.global_variables_initializer())
batch_size = 2
for epoch in range(10):
i = 0
epoch_loss = 0
while i + batch_size < len(image_all):
lengths = [len(x) for x in image_all[i: i + batch_size]]
from db_adapters import InfluxDBAdapter
from main import Config
adapter = InfluxDBAdapter(Config('conf.ini'))
for service in adapter.get_service_statuses():
print("Service %s was down approximately %d seconds which are %.1f"
"%% of total uptime" %
(service['service'], service['srv_downtime'],
(100.0 * service['srv_downtime']) / service['total_uptime']))
for address in adapter.get_instance_statuses():
print("Address %s was unreachable approximately %.1f second which are "
"%.1f %% of total uptime" %
(address['address'], address['failed'],
(100.0 * address['failed']) / address['total_time']))
with open(model_path, "rb") as f:
# 恢复模型
output_graph_def.ParseFromString(f.read())
tf.import_graph_def(output_graph_def, name="")
with tf.Session() as sess:
tf.global_variables_initializer().run()
# 获得名字为x_input、output的tensor
image_input = sess.graph.get_tensor_by_name("image_input:0")
print("image_input shape:", image_input.get_shape())
keep_prob = sess.graph.get_tensor_by_name("keep_prob:0")
kernel_res = sess.graph.get_tensor_by_name("kernel_res:0")
output = sess.graph.get_tensor_by_name("output:0")
config = Config()
kernel = restore_kernel(config)
# img_value = np.array([img_value])
img_list = []
for i in range(16):
img_path = img_dir + class_index + "/" + str(i + 1) + ".jpg"
img_value = img_prepare(img_path)
img_list.append(img_value)
result = sess.run(output,
feed_dict={
image_input: img_list,
keep_prob: 1.0,
kernel_res: kernel
}) # 利用训练好的模型预测结果
print('模型预测结果为：\n', result)
PlanPipeline = Pipeline()
PlanPipeline.enqueue("train-planner", "Train Planner", TrainPlannerPipeline)
PlanPipeline.enqueue("test-corpus", "Pre-process test data",
TestingPreProcessPipeline)
ExperimentsPipeline = Pipeline()
ExperimentsPipeline.enqueue("pre-process", "Pre-process training data",
TrainingPreProcessPipeline)
# Train all planners
# # Naive Planner
ExperimentsPipeline.enqueue(
"naive-planner", "Train Naive Planner",
PlanPipeline.mutate(
{"config": Config(reader=WebNLGDataReader, planner=naive_planner)}))
# # Neural Planner
ExperimentsPipeline.enqueue(
"neural-planner", "Train Neural Planner",
PlanPipeline.mutate(
{"config": Config(reader=WebNLGDataReader, planner=neural_planner)}))
# REG
# # Bert REG
ExperimentsPipeline.enqueue(
"naive-reg", "Train Naive Referring Expressions Generator",
REGPipeline.mutate({"config": Config(reg=NaiveREG)}))
# # Naive REG
ExperimentsPipeline.enqueue(
"bert-reg", "Train BERT Referring Expressions Generator",
REGPipeline.mutate({"config": Config(reg=BertREG)}))
def setUp(self):
self.config = Config()
from __future__ import annotations import math import datetime as dt import numpy as np from abc import ABC, abstractmethod, abstractproperty from constants import * from interfaces import GeneratorInterface from main import Config CONFIG = Config().setup() class IdGenerator(GeneratorInterface): def __init__(self, m: int, a: int, c: int, seed: int) -> None: self.modulus = m self.multiplier = a self.increment = c self.seed = seed def generate_value(self) -> int: self.seed = (self.multiplier * self.seed + self.increment) % self.modulus return self.seed class SideGenerator(GeneratorInterface): def __init__(self, m: int, a: int, c: int) -> None:
