def tuning_MultinomialNB():
param_grid = {
"alpha": [1, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7, 1e-8, 1e-9]
}
result_list = []
optimized_param = [0, 0, 0, 0, 0]
for alpha in param_grid["alpha"]:
# try:
current_param_and_eval = [alpha]
clf = MultinomialNB(alpha=alpha)
f1_scores_dict = load_train_output_crossvalidation(clf)
f1_scores_dict = round_f1_score(f1_scores_dict)
f1_train_average = f1_scores_dict["f1_train_average"]
f1_dev_average = f1_scores_dict["f1_dev_average"]
f1_train_micro_average = f1_scores_dict["f1_train_micro_average"]
f1_dev_micro_average = f1_scores_dict["f1_dev_micro_average"]
current_param_and_eval.append(f1_train_micro_average)
current_param_and_eval.append(f1_dev_micro_average)
current_param_and_eval.append(f1_train_average)
current_param_and_eval.append(f1_dev_average)
result_list.append(current_param_and_eval)
if current_param_and_eval[2] > optimized_param[2]:
optimized_param = current_param_and_eval
# except:
# print("An exception occurs.")
# Generate data table
geometry_options = {"margin": "2.54cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
with doc.create(LongTable("l l l l l")) as data_table:
data_table.add_hline()
data_table.add_row([
"alpha", "training f1", "valid f1",
"training f1 for each technique", "valid f1 for each technique"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
for i in range(len(result_list)):
data_table.add_row(result_list[i][0:5])
data_table.add_hline()
with doc.create(LongTable("l l l l l")) as data_table:
data_table.add_hline()
data_table.add_row([
"alpha", "training f1", "valid f1",
"training f1 for each technique", "valid f1 for each technique"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.add_row(optimized_param)
data_table.add_hline()
print("This is for MultinomialNB.")
doc.generate_pdf("tuning_MultinomialNB", clean_tex=False)
def create_long_table(
doc,
parameters,
skip_parameters=[],
table_specs=r"|p{0.45\linewidth}|p{0.45\linewidth}|",
header=[bold("Parameter"), bold("Value")],
):
"""
Helper function to create long table for parameters
Arguments:
doc: document to add table
parameters: parameters dict
skip_parameters: list of parameters to skip
table_specs: latex specific table settings
header: list with column names
"""
columns = len(header)
with doc.create(LongTable(table_spec=table_specs)) as data_table:
# Table header
data_table.add_hline()
data_table.add_row(header)
data_table.add_hline()
data_table.end_table_header()
data_table.add_row((MultiColumn(columns,
align="r",
data="Continued on Next Page"), ))
data_table.end_table_footer()
data_table.add_row((MultiColumn(columns,
align="r",
data="End of Table"), ))
data_table.end_table_last_footer()
for item in parameters:
if item not in skip_parameters:
data_table.add_row([item, str(parameters[item])])
data_table.add_hline()
def genenerate_longtabu():
geometry_options = {
"margin": "2.54cm",
"includeheadfoot": True
}
doc = Document(page_numbers=True, geometry_options=geometry_options)
# Generate data table
with doc.create(LongTable("l l l")) as data_table:
data_table.add_hline()
data_table.add_row(["header 1", "header 2", "header 3"])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.add_row((MultiColumn(3, align='r',
data='Containued on Next Page'),))
data_table.add_hline()
data_table.end_table_footer()
data_table.add_hline()
data_table.add_row((MultiColumn(3, align='r',
data='Not Containued on Next Page'),))
data_table.add_hline()
data_table.end_table_last_footer()
row = ["Content1", "9", "Longer String"]
for i in range(150):
data_table.add_row(row)
doc.generate_pdf("longtable", clean_tex=False)
def basic_table():
geometry_options = {"margin": "2.54cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
batch_size_list = [8, 12, 16, 32]
learning_rate_list = [1e-5, 2e-5, 5e-5, 1e-4]
epochs_list = [2, 4, 8, 12]
rows = []
for batch_size in batch_size_list:
for learning_rate in learning_rate_list:
for epochs in epochs_list:
row = []
row.append(batch_size)
row.append(learning_rate)
row.append(epochs)
row.append(0)
rows.append(row)
# Generate data table
with doc.create(LongTable("l l l l")) as data_table:
data_table.add_hline()
data_table.add_row(["batch size", "learning rate", "epochs", "F1"])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
for i in range(len(rows)):
data_table.add_row(rows[i])
doc.generate_pdf("hyper_tune_bert", clean_tex=False)
def genenerate_longtabu(data):
if data == data_PU:
with doc.create(LongTable("l l c c c c c c l")) as data_table:
doc.append(Command('caption', 'Zadání místností pro výpočet'))
doc.append(Command('label', 'rozmery'))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row([
"PU", "Místnost", "Plocha",
NoEscape('h$_s$'),
NoEscape('a$_n$'),
NoEscape('p$_n$'),
NoEscape('p$_s$'), "c", "Tab. A.1"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
doc.append(Command('endfoot'))
doc.append(Command('endlastfoot'))
# data_table.end_table_footer()
data_table.add_hline()
if data == data_POP:
with doc.create(LongTable("l l c c c c", pos=['l'])) as data_table:
doc.append(Command('caption', 'Zadání okenních otvorů'))
doc.append(Command('label', 'okna'))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row([
"PU", "Místnost", "n otvorů", "šířka otvorů",
"výška otvorů", "Plocha"
])
data_table.add_row(
[" ", " ", " ", "[m]", "[m]",
NoEscape('m$^2$')])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.add_hline()
for i in range(0, len(data)):
if i % 2 == 0:
data_table.add_row(data[i])
else:
data_table.add_row(data[i], color="Hex")
data_table.add_hline()
def description_regression(full_data_files, description_folder):
data_list = list()
for d in full_data_files:
name = d.split('/')[2].split('.')[0]
df = pd.read_csv(d,
sep='\s+',
header=None)
lines, columns = df.shape
attribute = columns - 1 # Minus one because of target
data_list.append({'Dataset': name,
'Size': lines,
'Attributes': attribute})
df = pd.DataFrame(data_list)
df = df.sort_values('Size', ascending=False)
cols = ['Dataset',
'Size',
'Attributes']
df = df[cols]
df_copy = deepcopy(df)
df_copy.to_csv(os.path.join(description_folder,
'data_description.csv'),
sep=',',
header=True,
columns=['Dataset',
'Size',
'Attributes'],
index=False)
# # LaTeX
df = df.set_index(['Dataset'])
# Max classes per row
max_classes = np.inf
geometry_options = {
"margin": "1.00cm",
"includeheadfoot": True
}
doc = Document(page_numbers=True, geometry_options=geometry_options)
# Generate data table
with doc.create(LongTable("l l l")) as data_table:
data_table.add_hline()
header = ["Dataset",
"Size",
"#Attr."]
data_table.add_row(header)
data_table.add_hline()
data_table.add_hline()
for index in df.index.values:
row = [index] + df.loc[index].values.tolist()
data_table.add_row(row)
doc.generate_pdf(os.path.join(description_folder,
'data_description'), clean_tex=False)
def k_generator(data_dir, vystup_dir):
os.chdir(data_dir)
data_PU = read_results('results.csv')
data_used = []
for i in range(0, len(data_PU)):
data_used.append(data_PU[i][0])
data_used.append(data_PU[i][1])
data_used.append(data_PU[i][2])
data_used.append(data_PU[i][4])
a = 0.15 * ((float(data_PU[i][1]) * float(data_PU[i][2]) *
float(data_PU[i][4]))**0.5)
# print(float(data_PU[i][1]), float(data_PU[i][2]), float(data_PU[i][4]))
data_used.append(str(round(a, 2)))
data_used.append('{} PG6 21A/183B'.format(math.ceil(a)))
data_used = list(chunks(data_used, 6))
with doc.create(Section('Hasicí přístroje')):
with doc.create(Subsection('Přehled hasicích přístrojů')):
doc.append(
NoEscape(r'Přehled počtu a druhu všech hasicích přístrojů,\
které budou v objektu osazeny, je patrný z\
tabulky \ref{PHP_stanoveni}.'))
for i in range(0, len(data_used)):
data_used[i][1] = data_used[i][1].replace(".", ",")
data_used[i][2] = data_used[i][2].replace(".", ",")
data_used[i][3] = data_used[i][3].replace(".", ",")
data_used[i][4] = data_used[i][4].replace(".", ",")
with doc.create(LongTable("l c c c c l", pos=['htb'])) as data_table:
doc.append(Command('caption', 'Počet a druh hasicích přístrojů'))
doc.append(Command('label', NoEscape('PHP_stanoveni')))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row([
"Požární úsek", "S", "a", "c",
NoEscape('$n_r$'), "Počet PHP - typ"
])
data_table.add_row([" ", NoEscape('[m$^2$]'), "-", "-", "-", " "])
data_table.add_hline()
data_table.end_table_header()
for i in range(0, len(data_used)):
if i % 2 != 0:
data_table.add_row(data_used[i], color="Hex")
else:
data_table.add_row(data_used[i])
data_table.add_hline()
# doc.append(NoEscape('\insertTableNotes'))
os.chdir(vystup_dir)
doc.generate_pdf("K_hasicaky", clean_tex=False)
def _document_aggregate_table(self, tests: List[Dict[str, Any]]) -> None:
"""Document a result table of aggregate tests.
Args:
tests: List of corresponding test dictionary to make a table.
"""
with self.doc.create(LongTable('|c|p{8cm}|p{7.3cm}|',
booktabs=True)) as tabular:
package = Package('seqsplit')
if package not in tabular.packages:
tabular.packages.append(package)
# add table heading
tabular.add_row((MultiColumn(size=1, align='|c|', data="Test ID"),
MultiColumn(size=1,
align='c|',
data="Test Description"),
MultiColumn(size=1,
align='c|',
data="Input Value")))
# add table header and footer
tabular.add_hline()
tabular.end_table_header()
tabular.add_hline()
tabular.add_row((MultiColumn(3,
align='r',
data='Continued on Next Page'), ))
tabular.add_hline()
tabular.end_table_footer()
tabular.end_table_last_footer()
for idx, test in enumerate(tests):
if idx > 0:
tabular.add_hline()
inp_data = [
f"{arg}={self.sanitize_value(value)}"
for arg, value in test["inputs"].items()
]
inp_data = [WrapText(data=x, threshold=27) for x in inp_data]
des_data = [
WrapText(data=x, threshold=27)
for x in test["description"].split(" ")
]
row_cells = [
self.test_id,
IterJoin(data=des_data, token=" "),
IterJoin(data=inp_data, token=escape_latex(", \n")),
]
tabular.add_row(row_cells)
self.test_id += 1
def long_table(num=2, title=("符号", "说明")):
data_table = LongTable("l " * num)
data_table.add_hline()
data_table.add_hline()
data_table.add_row(title)
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.end_table_footer()
data_table.add_hline()
data_table.add_hline()
data_table.end_table_last_footer()
return data_table
def _document_sys_config(self) -> None:
"""Add a system config summary to the traceability document.
"""
with self.doc.create(Section("System Config")):
with self.doc.create(Itemize()) as itemize:
itemize.add_item(
escape_latex(f"FastEstimator {fe.__version__}"))
itemize.add_item(
escape_latex(f"Python {platform.python_version()}"))
itemize.add_item(escape_latex(f"OS: {sys.platform}"))
itemize.add_item(
f"Number of GPUs: {torch.cuda.device_count()}")
if fe.fe_deterministic_seed is not None:
itemize.add_item(
escape_latex(
f"Deterministic Seed: {fe.fe_deterministic_seed}"))
with self.doc.create(LongTable('|lr|', pos=['h!'],
booktabs=True)) as tabular:
tabular.add_row((bold("Module"), bold("Version")))
tabular.add_hline()
tabular.end_table_header()
tabular.add_hline()
tabular.add_row((MultiColumn(2,
align='r',
data='Continued on Next Page'), ))
tabular.add_hline()
tabular.end_table_footer()
tabular.end_table_last_footer()
color = True
for name, module in humansorted(sys.modules.items(),
key=lambda x: x[0]):
if "." in name:
continue # Skip sub-packages
if name.startswith("_"):
continue # Skip private packages
if isinstance(module, Base):
continue # Skip fake packages we mocked
if hasattr(module, '__version__'):
tabular.add_row(
(escape_latex(name),
escape_latex(str(module.__version__))),
color='black!5' if color else 'white')
color = not color
elif hasattr(module, 'VERSION'):
tabular.add_row((escape_latex(name),
escape_latex(str(module.VERSION))),
color='black!5' if color else 'white')
color = not color
def test_table():
# Tabular
t = Tabular(table_spec='|c|c|', data=None, pos=None, width=2)
t.add_hline(start=None, end=None)
t.add_row((1, 2), escape=False, strict=True, mapper=[bold])
t.add_row(1, 2, escape=False, strict=True, mapper=[bold])
# MultiColumn/MultiRow.
t.add_row((MultiColumn(size=2, align='|c|', data='MultiColumn'), ),
strict=True)
# One multiRow-cell in that table would not be proper LaTeX,
# so strict is set to False
t.add_row((MultiRow(size=2, width='*', data='MultiRow'), ), strict=False)
repr(t)
# TabularX
tabularx = Tabularx(table_spec='X X X',
width_argument=NoEscape(r"\textwidth"))
tabularx.add_row(["test1", "test2", "test3"])
# Long Table
longtable = LongTable(table_spec='c c c')
longtable.add_row(["test", "test2", "test3"])
longtable.end_table_header()
# Colored Tabu
coloredtable = Tabu(table_spec='X[c] X[c]')
coloredtable.add_row(["test", "test2"], color="gray", mapper=bold)
# Colored Tabu with 'spread'
coloredtable = Tabu(table_spec='X[c] X[c]', spread="1in")
coloredtable.add_row(["test", "test2"], color="gray", mapper=bold)
# Colored Tabu with 'to'
coloredtable = Tabu(table_spec='X[c] X[c]', to="5in")
coloredtable.add_row(["test", "test2"], color="gray", mapper=bold)
# Colored Tabularx
coloredtable = Tabularx(table_spec='X[c] X[c]')
coloredtable.add_row(["test", "test2"], color="gray", mapper=bold)
# Column
column = ColumnType("R", "X", r"\raggedleft", parameters=2)
repr(column)
def periodAndRecur(doc, classes, recursive, mc):
with doc.create(Subsection('Periodicity and Recurrence')):
with doc.create(LongTable("l l l")) as data_table:
data_table.add_hline()
data_table.add_row(['$s$', '$period(s)$', '$Recurrence$'],
escape=False)
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.end_table_last_footer()
for c in classes:
row = [
'$' + toLatexState(c) + '$', '$' + str(mc.period(c)) + '$',
str(c in recursive)
]
data_table.add_row(row, escape=False)
def edgeList(doc, eL):
doc.append(NewPage())
with doc.create(Subsection('Edges')):
with doc.create(LongTable("l l l l l l l l l l l l l")) as data_table:
data_table.add_hline()
data_table.add_row(['$s$', '$s\'$', '$p$', ' ', ' '] * 2 +
['$s$', '$s\'$', '$p$'],
escape=False)
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.end_table_last_footer()
for i in range(0, len(eL), 3):
row = []
triplet = eL[i]
row += [
'$' + toLatexState(triplet[0]) + '$',
'$' + toLatexState(triplet[1]) + '$',
'$' + toLatexProb(triplet[2]) + '$', ' ', ' '
]
if i + 1 < len(eL):
triplet = eL[i + 1]
row += [
'$' + toLatexState(triplet[0]) + '$',
'$' + toLatexState(triplet[1]) + '$',
'$' + toLatexProb(triplet[2]) + '$', ' ', ' '
]
if i + 2 < len(eL):
triplet = eL[i + 2]
row += [
'$' + toLatexState(triplet[0]) + '$',
'$' + toLatexState(triplet[1]) + '$',
'$' + toLatexProb(triplet[2]) + '$'
]
else:
row += [
' ',
] * 3
else:
row += [
' ',
] * 8
data_table.add_row(row, escape=False)
def POP_generator(df):
data_used = df.values.tolist()
for i in range(0, len(data_used)):
data_used[i][1] = str(("%.2f" % data_used[i][1])).replace(".", ",")
data_used[i][2] = str(("%.2f" % data_used[i][2])).replace(".", ",")
data_used[i][3] = str(("%.2f" % data_used[i][3])).replace(".", ",")
with doc.create(Section('Vymezení požárně nebezpečného prostoru')):
with doc.create(Subsection('Procenta požárně otevřených ploch')):
doc.append(NoEscape(r'Dále je určeno, zda je možné jednotlivé otvory ve fasádě posuzovat samostatně, a to výpočtem procenta požárně otevřených ploch z celkové plochy každé fasády. Způsob odečtení plochy fasády a plochy otevřených ploch je patrný z obrázku \ref{SchemaPOP}.'))
with doc.create(Figure(position='htb!')) as POP:
POP.add_image('images/POP.jpg', width='200px')
POP.add_caption('Odečtení požárně otevřených ploch')
POP.append(Command('label', 'SchemaPOP'))
doc.append(NoEscape(r'Procentuální výsledky jednotlivých fasád s požárně otevřenými plochami jsou patrné z tabulky \ref{POP}.'))
with doc.create(LongTable("lcccc", pos=['htb'])) as data_table:
doc.append(Command('caption', 'Odstupové vzdálenosti od objektu'))
doc.append(Command('label', 'POP'))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row(["Popis", "Celková plocha", "Plocha POP",
"Procento POP", "POP jednotlivě"])
data_table.add_row([" ", NoEscape('[m$^2$]'), NoEscape('[m$^2$]'),
NoEscape('[\%]'), NoEscape(r'\textless 40 \%')])
data_table.add_hline()
data_table.end_table_header()
for i in range(0, len(data_used)):
if i == 0:
# \multicolumn{9}{l}{\textbf{1. nadzemní podlaží - POP společné}}\\
data_table.add_row((MultiColumn(5, align='l', data=utils.bold(df_popis_POP[i])),))
if i > 0 and df_popis_POP[i] != df_popis_POP[i-1]:
data_table.add_hline()
data_table.add_row((MultiColumn(5, align='l', data=utils.bold(df_popis_POP[i])),))
if (i) % 2 == 0:
data_table.add_row(data_used[i], color="Hex")
elif (i) % 2 != 0:
data_table.add_row(data_used[i])
data_table.add_hline()
doc.append(NoEscape(r'Ostatní v tabulce výše nezmíněné otvory na fasádách objektu jsou spočteny jako samostatné 100 \% otevřené požární plochy.'))
def dataframe_to_pdf(df, pdf_path):
geometry_options = {"margin": "2.54cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
num_cols = len(df.columns)
# Generate data table
with doc.create(LongTable("l " * num_cols)) as data_table:
data_table.add_hline()
data_table.add_row(list(df.columns.values))
data_table.add_hline()
for i in range(len(df.index)):
row_list = df.iloc[i].values.tolist()
if "SEP" in row_list[0]:
data_table.add_hline()
else:
data_table.add_row(row_list)
data_table.add_hline()
doc.generate_pdf(pdf_path, clean_tex=False)
def make_table_of_symbols(symbols: List[str], units: List[str],
descriptions: List[str]):
table_symbols_content = LongTable("l l l")
table_symbols_content.add_hline()
table_symbols_content.add_row(["Symbol", "Unit", "Description"])
table_symbols_content.add_hline()
table_symbols_content.end_table_header()
table_symbols_content.add_hline()
table_symbols_content.add_row(
(MultiColumn(3, align='r', data='Continued on Next Page'), ))
table_symbols_content.add_hline()
table_symbols_content.end_table_footer()
table_symbols_content.add_hline()
table_symbols_content.add_row((MultiColumn(3, align='r', data='***End'), ))
table_symbols_content.add_hline()
table_symbols_content.end_table_last_footer()
for i in range(len(symbols)):
try:
symbol = py2tex(symbols[i], print_latex=False,
print_formula=False).replace('$', '')
except:
symbol = symbols[i]
try:
unit = py2tex(units[i],
print_latex=False,
print_formula=False,
simplify_fractions=True).replace('$', '')
except:
unit = units[i]
table_symbols_content.add_row([
NoEscape(f'${symbol}$'),
NoEscape(f'${unit}$'),
NoEscape(descriptions[i])
])
table_symbols_content.add_hline()
return table_symbols_content
def basic_run():
geometry_options = {"margin": "2.54cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
clf_1 = LinearSVC(dual=False)
clf_2 = LogisticRegression(multi_class="multinomial", solver="newton-cg")
clf_3 = MultinomialNB()
clf_4 = RandomForestClassifier()
LinearSVC_f1_scores_dict = load_train_output_crossvalidation(clf_1)
LogisticRegression_f1_scores_dict = load_train_output_crossvalidation(
clf_2)
MultinomialNB_f1_scores_dict = load_train_output_crossvalidation(clf_3)
RandomForest_f1_scores_dict = load_train_output_crossvalidation(clf_4)
row_1 = basic_generate_row("LinearSVC", LinearSVC_f1_scores_dict)
row_2 = basic_generate_row("LogisticRegression",
LogisticRegression_f1_scores_dict)
row_3 = basic_generate_row("MultinomialNB", MultinomialNB_f1_scores_dict)
row_4 = basic_generate_row("RandomForest", RandomForest_f1_scores_dict)
rows = []
rows.append(row_1)
rows.append(row_2)
rows.append(row_3)
rows.append(row_4)
# Generate data table
with doc.create(LongTable("l l l l l")) as data_table:
data_table.add_hline()
data_table.add_row([
"Model Name", "training f1", "valid f1",
"training f1 for each technique", "valid f1 for each technique"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
for i in range(len(rows)):
data_table.add_row(rows[i])
doc.generate_pdf("basic_run", clean_tex=False)
def make_table(headers: List, *args):
table = LongTable('|l| l| l| p{10cm}|')
table.add_hline()
table.add_row([
NoEscape(f'\\textbf{{\\textcolor{{black}}{{{i}}}}}')
for i in headers
])
table.add_hline()
table.end_table_header()
table.add_hline()
table.add_row((MultiColumn(4, align='r',
data='Continued on next page'), ))
# table.add_hline()
table.end_table_footer()
# table.add_hline()
# table.add_row((MultiColumn(n_cols, align='r', data=''),))
# table.add_hline()
table.end_table_last_footer()
for i in range(len(args[0])):
table.add_row([NoEscape(j[i]) for j in args])
table.add_hline()
return table
def tuning_RandomForest():
param_grid = {
"max_features": ["auto", "sqrt", "log2"],
"n_estimators": [50, 100, 200],
"min_sample_leaf": [25, 50, 100],
"max_depth": [None, 10, 20, 40, 80],
}
result_list = []
optimized_param = [0, 0, 0, 0, 0, 0, 0, 0]
for max_features in param_grid["max_features"]:
for n_estimators in param_grid["n_estimators"]:
for min_sample_leaf in param_grid["min_sample_leaf"]:
for max_depth in param_grid["max_depth"]:
# try:
current_param_and_eval = [
max_features, n_estimators, min_sample_leaf, max_depth
]
clf = RandomForestClassifier(
max_features=max_features,
n_estimators=n_estimators,
min_samples_leaf=min_sample_leaf,
max_depth=max_depth)
f1_scores_dict = load_train_output_crossvalidation(clf)
f1_scores_dict = round_f1_score(f1_scores_dict)
f1_train_average = f1_scores_dict["f1_train_average"]
f1_dev_average = f1_scores_dict["f1_dev_average"]
f1_train_micro_average = f1_scores_dict[
"f1_train_micro_average"]
f1_dev_micro_average = f1_scores_dict[
"f1_dev_micro_average"]
current_param_and_eval.append(f1_train_micro_average)
current_param_and_eval.append(f1_dev_micro_average)
current_param_and_eval.append(f1_train_average)
current_param_and_eval.append(f1_dev_average)
result_list.append(current_param_and_eval)
if current_param_and_eval[5] > optimized_param[5]:
optimized_param = current_param_and_eval
# except:
# print("An exception occurs.")
# Generate data table
geometry_options = {"margin": "2.54cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
with doc.create(LongTable("l l l l l l l l")) as data_table:
data_table.add_hline()
data_table.add_row([
"max_features", "n_estimators", "min_sample_leaf", "max_depth",
"training f1", "valid f1", "training f1 for each technique",
"valid f1 for each technique"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
for i in range(len(result_list)):
data_table.add_row(result_list[i][0:8])
data_table.add_hline()
with doc.create(LongTable("l l l l l l l l")) as data_table:
data_table.add_hline()
data_table.add_row([
"max_features", "n_estimators", "min_sample_leaf", "max_depth",
"training f1", "valid f1", "training f1 for each technique",
"valid f1 for each technique"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.add_row(optimized_param)
data_table.add_hline()
print("This is for RandomForest.")
doc.generate_pdf("tuning_RandomForest", clean_tex=False)
def generatePDF(obj):
"""
Function that generates the rendered .pdf
"""
geometry_options = {"margin": "2cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
# Disable Page Numbering
# https://jeltef.github.io/PyLaTeX/latest/examples/basic.html
# https://tex.stackexchange.com/questions/7355/how-to-suppress-page-number#7357
doc.preamble.append(Command('pagenumbering', 'gobble'))
# Include Packages
doc.preamble.append(Command('usepackage', 'url'))
doc.preamble.append(Command('usepackage', 'fancyhdr'))
doc.preamble.append(Command('usepackage', 'graphicx'))
# Set Pagestyle (fancy is used for page header and footer)
doc.preamble.append(Command('pagestyle', 'fancy'))
# Header and Footer
doc.preamble.append(
Command(
'cfoot',
NoEscape(
'Aionda Zeiterfassung - \\url{https://github.com/AiondaDotCom/tools}'
)))
doc.preamble.append(
Command('chead',
(Command('Large', bold('Arbeitnehmer: Check-In-Time')))))
#with doc.create(Section(NoEscape('Arbeitnehmer:\\\\Check-In-Time'), numbering=False)):
# Create Table with informations about the employee
with doc.create(LongTable("|l|l|l|")) as headerTable:
headerTable.add_hline()
headerTable.add_row([
"Name: {}".format(obj["employee"]),
"Monat: {:02d}".format(obj["month"]),
"Jahr: {}".format(obj["year"])
])
headerTable.add_hline()
# Generate table for time tracking informations
with doc.create(LongTable("|c|c|r|r|r|")) as data_table:
data_table.add_hline()
data_table.add_row([
bold("Datum"),
bold("von - bis"),
bold("Pause"),
bold("gesamte AZ"),
bold(NoEscape("davon \\\"Uberstunden"))
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
# Insert rows
for row in obj["zeitAufzeichnungsTable"]:
data_table.add_row(row)
data_table.add_hline()
data_table.add_hline()
# Last row shows the total amount of hours
arbeitszeitStr = "{}".format(obj["arbeitszeitKomplettRounded"])
data_table.add_row(["Summe", '', '', arbeitszeitStr, ''])
data_table.add_hline()
# Generate table with remarks
with doc.create(LongTable("lllll")) as signTable:
signTable.add_row(
['Bemerkungen:', 'Krankheitstage:', 'K', 'Schlechtwetter:', 'WA'])
signTable.add_row(
['', 'Wochenende/Feiertag:', 'WF', 'Urlaubstage:', 'U'])
# Insert vertical space
doc.append(Command('vspace', '1cm'))
# place for signatures
with doc.create(LongTable("ll")) as signTable:
if obj['signatureFile']:
signTable.add_row([
Command('includegraphics', signatureFile, 'width=4cm'),
Command('vspace', NoEscape('-.1cm'))
])
else:
signTable.add_row(["", NoEscape("")])
signTable.add_hline()
signTable.add_row([
NoEscape("Unterschrift Arbeitnehmer"),
NoEscape("\hspace{4cm}Unterschrift Arbeitgeber")
])
# Finally the document is rendered
doc.generate_pdf(obj['outputFilename'], clean_tex=False)
def appendix(data_dir, vystup_dir):
os.chdir(data_dir)
data_PU = read_results('raw_data_PU.csv')
data_POP = read_results('raw_data_POP.csv')
data_mid = read_results('results.csv')
PurePath(vystup_dir)
geometry_options = {"margin": "0.5cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
doc.preamble.append(NoEscape(r'\definecolor{Hex}{RGB}{239,239,239}'))
doc.documentclass.options = Options('10pt')
doc.append(Command('textbf', 'Zadání hodnot pro výpočet: '))
doc.append(
NoEscape(r'Tabulka \ref{rozmery} je souhrnem zadaných hodnot \
potřebných k výpočtu požárně výpočtového zatížení.'))
def genenerate_longtabu(data):
if data == data_PU:
with doc.create(LongTable("l l c c c c c c l")) as data_table:
doc.append(Command('caption', 'Zadání místností pro výpočet'))
doc.append(Command('label', 'rozmery'))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row([
"PU", "Místnost", "Plocha",
NoEscape('h$_s$'),
NoEscape('a$_n$'),
NoEscape('p$_n$'),
NoEscape('p$_s$'), "c", "Tab. A.1"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
doc.append(Command('endfoot'))
doc.append(Command('endlastfoot'))
# data_table.end_table_footer()
data_table.add_hline()
if data == data_POP:
with doc.create(LongTable("l l c c c c", pos=['l'])) as data_table:
doc.append(Command('caption', 'Zadání okenních otvorů'))
doc.append(Command('label', 'okna'))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row([
"PU", "Místnost", "n otvorů", "šířka otvorů",
"výška otvorů", "Plocha"
])
data_table.add_row(
[" ", " ", " ", "[m]", "[m]",
NoEscape('m$^2$')])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.add_hline()
for i in range(0, len(data)):
if i % 2 == 0:
data_table.add_row(data[i])
else:
data_table.add_row(data[i], color="Hex")
data_table.add_hline()
for i in range(0, len(data_PU)):
data_PU[i][2] = data_PU[i][2].replace(".", ",")
data_PU[i][3] = data_PU[i][3].replace(".", ",")
data_PU[i][4] = data_PU[i][4].replace(".", ",")
data_PU[i][5] = data_PU[i][5].replace(".", ",")
data_PU[i][6] = data_PU[i][6].replace(".", ",")
data_PU[i][7] = data_PU[i][7].replace(".", ",")
genenerate_longtabu(data_PU)
doc.append(
NoEscape(r'Okenní otvory nutné pro výpočet součinitele b jsou\
uvedeny v následující tabulce \ref{okna}'))
for i in range(0, len(data_POP)):
data_POP[i][3] = data_POP[i][3].replace(".", ",")
data_POP[i][4] = data_POP[i][4].replace(".", ",")
data_POP[i][5] = data_POP[i][5].replace(".", ",")
genenerate_longtabu(data_POP)
doc.append(Command('textbf', 'Mezivýsledky a výsledky: '))
doc.append(
NoEscape(r'Mezivýsledky nutné pro stanovení parametru b jsou\
patrné z tabulky \ref{mezivysledky}'))
#########################################################################
''' Mezivýsledky parametr B '''
data_mid_ar = []
for i in range(0, len(data_mid)):
data_mid_ar.append(data_mid[i][0])
data_mid_ar.append(data_mid[i][1])
data_mid_ar.append(data_mid[i][8])
data_mid_ar.append(data_mid[i][9])
data_mid_ar.append(data_mid[i][10])
data_mid_ar.append(data_mid[i][14])
data_mid_ar.append(data_mid[i][15])
data_mid_ar = list(chunks(data_mid_ar, 7))
for i in range(0, len(data_mid_ar)):
data_mid_ar[i][1] = data_mid_ar[i][1].replace(".", ",")
data_mid_ar[i][2] = data_mid_ar[i][2].replace(".", ",")
data_mid_ar[i][3] = data_mid_ar[i][3].replace(".", ",")
data_mid_ar[i][4] = data_mid_ar[i][4].replace(".", ",")
data_mid_ar[i][5] = data_mid_ar[i][5].replace(".", ",")
data_mid_ar[i][6] = data_mid_ar[i][6].replace(".", ",")
with doc.create(LongTable("l c c c c c c", pos=['l'])) as data_table:
doc.append(Command('caption', 'Mezivýsledky pro paramter b'))
doc.append(Command('label', 'mezivysledky'))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row(["PÚ", "S", "S0", "hs", "h0", "n", "k"])
data_table.add_row([
" ",
NoEscape('m$^2$'),
NoEscape('m$^2$'), "[m]", "[m]", "[-]", "[-]"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.add_hline()
for i in range(0, len(data_mid_ar)):
if i % 2 == 0:
data_table.add_row(data_mid_ar[i])
else:
data_table.add_row(data_mid_ar[i], color="Hex")
data_table.add_hline()
#########################################################################
''' Vysledky '''
doc.append(
NoEscape(r'Přehled výsledků požárních úseků je patrný z tabulky\
\ref{Vysledky}'))
data_res = []
for i in range(0, len(data_mid)):
data_res.append(data_mid[i][0])
data_res.append(data_mid[i][1])
data_res.append(data_mid[i][2])
data_res.append(data_mid[i][3])
data_res.append(data_mid[i][4])
data_res.append(data_mid[i][13]) # a_n
data_res.append(data_mid[i][12]) # p_n
data_res.append(data_mid[i][11]) # p_s
data_res.append(data_mid[i][7]) # p_only
data_res.append(data_mid[i][5]) # p_v
data_res = list(chunks(data_res, 10))
for i in range(0, len(data_res)):
data_res[i][1] = data_res[i][1].replace(".", ",")
data_res[i][2] = data_res[i][2].replace(".", ",")
data_res[i][3] = data_res[i][3].replace(".", ",")
data_res[i][4] = data_res[i][4].replace(".", ",")
data_res[i][5] = data_res[i][5].replace(".", ",")
data_res[i][6] = data_res[i][6].replace(".", ",")
data_res[i][7] = data_res[i][7].replace(".", ",")
data_res[i][8] = data_res[i][8].replace(".", ",")
data_res[i][9] = data_res[i][9].replace(".", ",")
with doc.create(LongTable("l c c c c c c c c c ",
pos=['l'])) as data_table:
doc.append(
Command(
'caption', 'Přehled požárních úseků a jejich\
výsledky'))
doc.append(Command('label', 'Vysledky'))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row([
"PÚ", "Plocha", "a", "b", "c",
NoEscape('a$_n$'),
NoEscape('p$_n$'),
NoEscape('p$_s$'),
NoEscape('p'),
NoEscape('p$_v$')
])
data_table.add_row([
" ",
NoEscape('m$^2$'), "[-]", "[-]", "[-]", "[-]",
NoEscape('[kg/m$^2$]'),
NoEscape('[kg/m$^2$]'),
NoEscape('[kg/m$^2$]'),
NoEscape('[kg/m$^2$]')
])
data_table.end_table_header()
data_table.add_hline()
for i in range(0, len(data_res)):
if i % 2 == 0:
data_table.add_row(data_res[i])
else:
data_table.add_row(data_res[i], color="Hex")
data_table.add_hline()
os.chdir(vystup_dir)
doc.generate_pdf("Appendix", clean_tex=False)
def pile_report(self, pile, pile2, F, factor=1.25):
"""添加桩基长度计算内容"""
self.soil = pile.soil
llist = pl.get_l(self.soil, pile.d, F, factor, pile.h1, pile.rho,
pile.t, pile.k2, pile2.type, pile2.completion)
ra_1, ra_2 = pl.pile_l(llist, self.soil, pile.d, F, pile.h1, pile.rho,
pile.t, pile.k2, pile2.type, pile2.completion)
if ra_1.max() > ra_2.max():
ptype = '摩擦桩'
ra = ra_1.max()
else:
ptype = '端承桩'
ra = ra_2.max()
t1 = f'''桩基直径：$d={pile.d:.2f}\,m$\n
桩基周长：$u={pile.u:.2f}\,m$\n
桩基截面积：$A_p={pile.pd:.2f}\,m^2$\n
桩基密度：$\gamma={pile.rho:.1f}\,kN/m^3$\n
容许承载力随深度的修正系数：$k_2={pile.k2:.1f}$\n
各土层加权平均重度：$\gamma_2={self.soil.rho:.1f}\,kN/m^3$\n
清底系数：$m_0={pile.m0:.1f}$
'''
t2 = '根据规范5.3.3可得，摩擦桩单桩承载力为'
m1 = ['[R_a]', '=\\frac{1}{2}u\\sum_{i=1}^nq_{ik}l_i+A_pq_r']
t3 = '根据规范5.3.4可得，端承桩单桩承载力为'
m2 = [
'[R_a]=', 'c_1A_pf_{rk}', '+u\\sum_{i=1}^mc_{2i}h_if_{rki}',
'+\\frac{1}{2}\\xi_su\sum_{i=1}^nl_iq_{ik}'
]
t4 = '考虑桩身自重与置换土重，桩基承载力为'
m3 = ['R_a', '=[R_a]-G_p+G_s']
t5 = '代入不同长度桩长，可得摩擦桩与端承桩承载力如下图所示'
t6 = '不同桩长具体承载力如下表所示'
t7 = f'由上述分析可知，当桩长为{max(llist)}m时，{ptype}承载力为{ra:.0f}kN，安全系数为{ra/F:.2f}，桩基承载力可满足规范要求。'
with self.doc.create(Section('地基基本情况')):
with self.doc.create(LongTabu("p{4cm}XXXXX")) as soil_table:
header_row1 = self.soil.prop.columns.to_list()[:-1]
soil_table.add_hline()
soil_table.add_row(header_row1, mapper=[bold])
soil_table.add_hline()
for i in self.soil.prop.index:
soil_table.add_row(self.soil.prop.iloc[i].to_list()[:-1])
soil_table.add_hline()
with self.doc.create(Section('桩基及其他参数取值')):
self.doc.append(NoEscape(t1))
with self.doc.create(Section('桩长计算')):
self.doc.append(t2)
self.doc.append(Math(data=m1, escape=False))
self.doc.append(NoEscape('\n'))
self.doc.append(t3)
self.doc.append(Math(data=m2, escape=False))
self.doc.append(NoEscape('\n'))
self.doc.append(t4)
self.doc.append(Math(data=m3, escape=False))
self.doc.append(NoEscape('\n'))
self.doc.append(t5)
with self.doc.create(Figure(position='htbp')) as plot:
plot.add_plot(width=NoEscape(r'1\textwidth'), dpi=300)
self.doc.append(NoEscape('\n'))
self.doc.append(t6)
with self.doc.create(LongTable('p{1.5cm}|ll|ll')) as pll:
pll.add_hline()
pll.add_row(['桩长', '摩擦桩承载力', '安全系数', '端承桩承载力', '安全系数'])
pll.add_hline()
for i, j in enumerate(llist):
pll.add_row([
j, f'{ra_1[i]:.0f}', f'{ra_1[i]/F:.2f}',
f'{ra_2[i]:.0f}', f'{ra_2[i]/F:.2f}'
])
pll.add_hline()
self.doc.append(t7)
def generate_latex_document(trackers: List[Tracker],
sequences: List[Sequence],
results,
storage: Storage,
build=False,
multipart=True):
order_marks = {1: "first", 2: "second", 3: "third"}
def format_cell(value, order):
cell = format_value(value)
if order in order_marks:
cell = Command(order_marks[order], cell)
return cell
logger = logging.getLogger("vot")
table_header, table_data, table_order = extract_measures_table(
trackers, results)
plots = extract_plots(trackers, results)
doc = Document(page_numbers=True)
doc.preamble.append(Package('pgf'))
doc.preamble.append(Package('xcolor'))
doc.preamble.append(Package('fullpage'))
doc.preamble.append(NoEscape(read_resource("commands.tex")))
doc.preamble.append(
UnsafeCommand('newcommand',
r'\first',
options=1,
extra_arguments=r'{\color{red} #1 }'))
doc.preamble.append(
UnsafeCommand('newcommand',
r'\second',
options=1,
extra_arguments=r'{\color{green} #1 }'))
doc.preamble.append(
UnsafeCommand('newcommand',
r'\third',
options=1,
extra_arguments=r'{\color{blue} #1 }'))
if multipart:
container = Chunk()
generate_symbols(container, trackers)
with storage.write("symbols.tex") as out:
container.dump(out)
doc.preamble.append(Command("input", "symbols.tex"))
else:
generate_symbols(doc.preamble, trackers)
doc.preamble.append(Command('title', 'VOT report'))
doc.preamble.append(
Command('author', 'Toolkit version ' + toolkit_version()))
doc.preamble.append(Command('date', datetime.datetime.now().isoformat()))
doc.append(NoEscape(r'\maketitle'))
if len(table_header[2]) == 0:
logger.debug("No measures found, skipping table")
else:
# Generate data table
with doc.create(LongTable("l " *
(len(table_header[2]) + 1))) as data_table:
data_table.add_hline()
data_table.add_row([" "] + [
MultiColumn(c[1], data=c[0].identifier)
for c in merge_repeats(table_header[0])
])
data_table.add_hline()
data_table.add_row([" "] + [
MultiColumn(c[1], data=c[0].title)
for c in merge_repeats(table_header[1])
])
data_table.add_hline()
data_table.add_row(
["Tracker"] +
[" " + c.abbreviation + " " for c in table_header[2]])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
for tracker, data in table_data.items():
data_table.add_row([
UnsafeCommand("Tracker",
[tracker.reference, TRACKER_GROUP])
] + [
format_cell(x,
order[tracker] if not order is None else None)
for x, order in zip(data, table_order)
])
for experiment, experiment_plots in plots.items():
if len(experiment_plots) == 0:
continue
doc.append(Section("Experiment " + experiment.identifier))
for title, plot in experiment_plots:
with doc.create(Figure(position='htbp')) as container:
if multipart:
plot_name = plot.identifier + ".pdf"
with storage.write(plot_name, binary=True) as out:
plot.save(out, "PDF")
container.add_image(plot_name)
else:
container.append(insert_figure(plot))
container.add_caption(title)
if build:
temp = tempfile.mktemp()
logger.debug("Generating to tempourary output %s", temp)
doc.generate_pdf(temp, clean_tex=True)
storage.copy(temp + ".pdf", "report.pdf")
else:
with storage.write("report.tex") as out:
doc.dump(out)
def d_generator(data_dir, vystup_dir):
os.chdir(data_dir)
data_PU = read_results('results.csv')
info_PU = read_results('raw_data_info.csv')
# Arrange data to desired shape
data_check = []
data_used = []
data_replace_p = []
data_check_p = []
data_replace_a = []
l_names = []
p_stale = []
for i in range(0, len(data_PU)):
data_used.append(data_PU[i][0])
data_used.append(data_PU[i][16])
data_used.append(data_PU[i][1])
data_used.append(data_PU[i][2])
data_used.append(data_PU[i][3])
data_used.append(data_PU[i][4])
data_used.append(data_PU[i][5])
data_used.append(data_PU[i][6])
data_check.append(data_PU[i][19])
data_replace_p.append(data_PU[i][12])
data_replace_a.append(data_PU[i][13])
data_check_p.append(data_PU[i][7])
l_names.append(data_PU[i][19])
p_stale.append(data_PU[i][20])
data_used = list(chunks(data_used, 8))
list_avaiable = [
'B.1 pol.1', 'B.1 pol.2', 'B.1 pol.3', 'B.1 pol.4', 'B.1 pol.5',
'B.1 pol.6', 'B.1 pol.7', 'B.1 pol.8', 'B.1 pol.9', 'B.1 pol.10',
'B.1 pol.11', 'B.1 pol.12', 'B.1 pol.13'
]
list_avaiable2 = [
'AZ1 Ordi.', 'AZ1 Lék.', 'AZ2 Ordi', 'AZ2 vyšet.', 'AZ2 Lék.', 'LZ1',
'LZ2 lůž', 'LZ2 int.péče', 'LZ2 Lék', 'LZ2 biochem', 'peč. Služ',
'soc.péče.ošetř.', 'soc.péče.lůž.', 'soc.péče.byt', 'Jesle'
]
check = []
for i in range(0, len(data_check)):
if data_check[i] in list_avaiable or\
data_check[i] == 'OB2 byt' or\
data_check[i] == 'OB3' or data_check[i] == 'OB4 ubyt.' or data_check[i] == 'OB4 sklad' or\
data_check[i] == 'CHÚC-A' or data_check[i] == 'CHÚC-B' or\
data_check[i] == 'CHÚC-C' or data_check[i] in list_avaiable2:
check.append(i)
sys.path.insert(0,
"c:/Users/Honza/Google Drive/Work/Generator_zprav/minor/")
from stupen import spb_def
type_sys = info_PU[0]
h_p = float(info_PU[1][0])
podlazi = float(info_PU[2][0])
if len(check) > 0:
for item in check:
data_used[item][4] = '-'
'''data_used[item][4] = '-'
if data_check[item] == 'OB2 byt':
if (float(data_check_p[item]) - float(data_replace_p[item])) >= 0:
data_used[item][6] = '%.2f' % 40
spb_fix = spb_def(h_p, type_sys[0], [40], [1.00], podlazi, str(data_PU[item][0]))
data_used[item][7] = spb_fix[0]
if (float(data_check_p[item]) - float(data_replace_p[item])) > 5:
data_used[item][6] = '%.2f' % 45.00
spb_fix = spb_def(h_p, type_sys[0], [45], [1.00], podlazi, data_PU[item][0])
data_used[item][7] = spb_fix[0]
if (float(data_check_p[item]) - float(data_replace_p[item])) >= 15:
data_used[item][6] = '%.2f' % 50.00
spb_fix = spb_def(h_p, type_sys[0], [50], [1.00], podlazi, data_PU[item][0])
data_used[item][7] = spb_fix[0]
data_used[item][3] = str('%.2f' % 1.00)
# pozn = ' $^{1)}$'
# data_used[item][0] = NoEscape(data_used[item][0] + pozn)
if data_check[item] in list_avaiable:
if 0 <= float(p_stale[item]) <= 5:
data_used[item][6] = '%.2f' % float(data_replace_p[item])
if float(p_stale[item]) > 5:
data_replace_p[item] = ((float(p_stale[item]) - 5) * 1.15)\
+ float(data_replace_p[item])
data_used[item][6] = '%.2f' % data_replace_p[item]
spb_fix = spb_def(h_p, type_sys[0],
[float(data_replace_p[item])],
[1.00], podlazi,
data_PU[item][0])
data_used[item][7] = spb_fix[0]
data_used[item][3] = str('%.2f' % 1.00)
if data_check[item] in list_avaiable2:
data_used[item][6] = '%.2f' % float(data_replace_p[item])
data_used[item][3] = data_replace_a[item]
spb_fix = spb_def(h_p, type_sys[0], [float(data_used[item][6])], [float(data_used[item][3])], podlazi, data_PU[item][0])
data_used[item][7] = spb_fix[0]
if data_check[item] == 'OB3' or data_check[i] == 'OB4 ubyt.':
data_used[item][6] = '%.2f' % float(data_replace_p[item])
spb_fix = spb_def(h_p, type_sys[0],
[30],
[1.00], podlazi,
data_PU[item][0])
data_used[item][7] = spb_fix[0]
data_used[item][3] = str('%.2f' % 1.00)
if data_check[item] == 'OB4 sklad':
data_used[item][6] = '%.2f' % float(data_replace_p[item])
spb_fix = spb_def(h_p, type_sys[0],
[60],
[1.00], podlazi,
data_PU[item][0])
data_used[item][7] = spb_fix[0]
data_used[item][3] = str('%.2f' % 1.00)'''
if data_check[item] == 'CHÚC-A' or data_check[item] == 'CHÚC-B' or\
data_check[item] == 'CHÚC-C':
data_used[item][3] = '-'
data_used[item][4] = '-'
data_used[item][5] = '-'
data_used[item][6] = '-'
if h_p < 30:
data_used[item][7] = 'II.'
if h_p >= 30:
data_used[item][7] = 'III.'
if h_p >= 45:
data_used[item][7] = 'IV.'
with doc.create(Section('Posouzení požárních úseků')):
with doc.create(Subsection('Vyhodnocení požárních úseků')):
doc.append(
NoEscape(r'Z tabulky \ref{PU} je patrné požární riziko\
a stupeň požární bezpečnosti všech řešených\
požárních úseků. Není-li v poznámce pod\
tabulkou uvedeno jinak, je požární riziko PÚ\
stanoveno výpočtem (viz příloha \ref{A-1}:\
Výpočet požárního rizika).'))
save_var = []
save_id = []
save_name = []
save_id_check = []
for i in range(0, len(data_check)):
if data_check[i] == 'B.1 pol.1' or data_check[i] == 'B.1 pol.2' or\
data_check[i] == 'B.1 pol.3' or data_check[i] == 'B.1 pol.4' or\
data_check[i] == 'B.1 pol.5' or data_check[i] == 'B.1 pol.6' or\
data_check[i] == 'B.1 pol.7' or data_check[i] == 'B.1 pol.8' or\
data_check[i] == 'B.1 pol.9' or data_check[i] == 'B.1 pol.10' or\
data_check[i] == 'B.1 pol.11' or data_check[i] == 'B.1 pol.12' or\
data_check[i] == 'B.1 pol.13' or data_check[i] == 'OB2 byt' or\
data_check[i] == 'CHÚC-A' or data_check[i] == 'CHÚC-B' or\
data_check[i] == 'CHÚC-C' or data_check[i] == 'OB3' or\
data_check[i] == 'OB4 ubyt.' or\
data_check[i] == 'OB4 sklad' or\
data_check[i] in list_avaiable2:
save_var.append(data_check[i])
save_id_check.append(i)
count = list(range(1, len(save_var) + 1))
pre = ' $^{'
suf = ')}$'
for i in range(0, len(save_var)):
count[i] = pre + str(count[i])
count[i] = str(count[i]) + suf
for n in range(0, len(save_var)):
if n == 0:
new_dict = dict(zip([save_var[n]], [count[n]]))
save_id.append(save_id_check[n])
save_name.append(save_var[n])
# new_dict = dict(zip([save_var[n]], str(count[n])))
if n > 0:
if save_var[n] in new_dict:
save_id.append(save_id_check[n])
save_name.append(save_var[n])
else:
len_dict = len(new_dict) + 1
len_dict = pre + str(len_dict)
len_dict = str(len_dict) + suf
save_id.append(save_id_check[n])
save_name.append(save_var[n])
new_dict[save_var[n]] = len_dict
for i in range(0, len(save_id)):
data_used[save_id[i]][1] = NoEscape(data_used[save_id[i]][1] +
new_dict[save_name[i]])
doc.append(Command('begin', 'ThreePartTable'))
if len(check) > 0:
doc.append(Command('begin', 'TableNotes'))
doc.append(NoEscape('\small'))
for key in new_dict.keys():
pre_str = '\item'
if key == 'OB2 byt':
idx = l_names.index(key)
suf_str = ' Uvažováno s požárně výpočetním zatížením (p$_v$)\
podle normy ČSN 73 0833 čl. 5.1.2.'
string = new_dict[key]
if 0 <= (float(data_check_p[idx]) -
float(data_replace_p[idx])) < 5:
loc_str = pre_str + string + suf_str
doc.append(NoEscape(loc_str))
if (float(data_check_p[idx]) -
float(data_replace_p[idx])) > 5:
suf_str = suf_str + ' Stálé požární\
zatížení v požárním úseku je p$_s$ = 10 kg/m$^2$.\
Je tak přihlédnuto k poznámce stejného článku,\
která stanovuje požární zatížení na hodnotu\
p$_v$ = 45 kg/m$^2$.'
loc_str = pre_str + string + suf_str
doc.append(NoEscape(loc_str))
if key in list_avaiable:
string = new_dict[key]
idx = l_names.index(key)
polozka = str(list_avaiable.index(key) + 1)
suf_str_f = ' Hodnota požárně výpočtového zatížení je\
stanovena paušálně z položky '
suf_str_ff = ' tabulky B.1 normy ČSN 73 0802.'
suf_str_b = ' Stálé požární zatížení je p$_s$ = '
suf_str_bb = ' kg/m$^2$. Při stanovení požárně výpočtového\
zaížení je tak přihlédnuto k čl. B.1.2.'
if 0 <= (float(data_check_p[idx]) -
float(data_replace_p[idx])) <= 5:
suf_str_f = suf_str_f + polozka + suf_str_ff
loc_str = pre_str + string + suf_str_f
doc.append(NoEscape(loc_str))
if 5 < (float(data_check_p[idx]) -
float(data_replace_p[idx])):
suf_str_num = str(p_stale[idx])
suf_str_f = suf_str_f + polozka + suf_str_ff
suf_str_b = suf_str_b + suf_str_num + suf_str_bb
loc_str = pre_str + string + suf_str_f + suf_str_b
doc.append(NoEscape(loc_str))
if key in list_avaiable2:
string = new_dict[key]
idx = l_names.index(key)
suf_str_f = ' Hodnota požárně výpočtového zatížení je\
stanovena paušálně z '
suf_str_ff = ' z normy ČSN 73 0835.'
if key == 'AZ1 Ordi.':
odkaz = 'čl. 5.3.1'
suf_str_b = ' Jedná se o zařízení lékařské péče\
zařazené do skupiny AZ1'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'AZ1 Lék.':
odkaz = 'čl. 5.3.1'
suf_str_b = ' Jedná se o lékárenské zařízení\
zařazené do skupiny AZ1'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'AZ2 Ordi':
odkaz = 'čl. 6.2.1'
suf_str_b = ' Jedná se o lékárenské pracoviště\
zařazené do skupiny AZ2'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'AZ2 vyšet.':
odkaz = 'čl. 6.2.1'
suf_str_b = ' Jedná se o vyšetřovací nebo léčebnou\
část budovy zařazené do skupiny AZ2'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'AZ2 Lék.':
odkaz = 'čl. 6.2.1'
suf_str_b = ' Jedná se o lékárenské zařízení\
zařazené do skupiny AZ2'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'LZ1':
odkaz = 'čl. 7.2.1'
suf_str_b = ' Jedná se o požární úsek, který je\
součástí budovy skupiny LZ1'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(No.Escape(loc_str))
if key == 'LZ2 lůž':
odkaz = 'čl. 8.2.1'
suf_str_b = ' Jedná se o lůžkové jednotky v\
budově skupiny LZ2'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'LZ2 int.péče':
odkaz = 'čl. 8.2.1'
suf_str_b = ' Jedná se o jednotky intenzivní péče,\
ansteziologicko resustitační oddělení,\
nebo o operační oddělení v budově\
zařazené do skupiny LZ2'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'LZ2 Lék':
odkaz = 'čl. 8.2.1'
suf_str_b = ' Jedná se o lékárenské zařízení v\
budově skupiny LZ2'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'LZ2 biochem':
odkaz = 'čl. 8.2.1'
suf_str_b = ' Jedná se o oddělení klinické biochemie\
v budově skupiny LZ2'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'peč. Služ':
odkaz = 'čl. 9.3.1'
suf_str_b = ' Jedná se o bytovou jednotku v domě\
s pečovatelskou službou'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'soc.péče.oštř.':
odkaz = 'čl. 10.3.1'
suf_str_b = ' Jedná se o ošetřovatelské oddělení v\
budově sociální péče'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'soc.péče.lůž.':
odkaz = 'čl. 10.3.1'
suf_str_b = ' Jedná se o lůžkovou část ústavu\
sociální péče'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'soc.péče.byt.':
odkaz = 'čl. 10.3.1'
suf_str_b = ' Jedná se o bytové jednotky v budově\
sociální péče.'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'Jesle.':
odkaz = 'čl. 10.3.1'
suf_str_b = ' Jedná se o zrdavotnické zařízení\
pro děti - jesle'
loc_str = pre_str + string + suf_str_f + odkaz +\
suf_str_ff + suf_str_b
doc.append(NoEscape(loc_str))
if key == 'OB3':
string = new_dict[key]
pre_str = '\item'
suf_str = ' Požární riziko pro ubytovací jednotku bylo\
stanoveno paušálně pomocí čl. 6.1.1 normy\
ČSN 73 0833.'
loc_str = pre_str + string + suf_str
doc.append(NoEscape(loc_str))
if key == 'OB4 ubyt.':
string = new_dict[key]
pre_str = '\item'
suf_str = ' Požární riziko pro ubytovací jednotku v budově OB4 bylo\
stanoveno paušálně pomocí čl. 7.1.1 normy\
ČSN 73 0833.'
loc_str = pre_str + string + suf_str
doc.append(NoEscape(loc_str))
if key == 'OB4 sklad':
string = new_dict[key]
pre_str = '\item'
suf_str = ' Požární riziko pro ubytovací jednotku v budově OB4 bylo\
stanoveno paušálně pomocí čl. 7.1.3 normy\
ČSN 73 0833.'
loc_str = pre_str + string + suf_str
doc.append(NoEscape(loc_str))
if key == 'CHÚC-A' or key == 'CHÚC-B' or key == 'CHÚC-C':
string = new_dict[key]
pre_str = '\item'
suf_str = ' CHÚC je zatříděna v souladu s čl. 9.3.2 normy\
ČSN 73 0802.'
loc_str = pre_str + string + suf_str
doc.append(NoEscape(loc_str))
if info_PU[3] == ['ANO']:
try:
new_dict
except NameError:
var_exist = False
else:
var_exist = True
if var_exist is False:
new_dict = []
pre_str = '\item'
doc.append(Command('begin', 'TableNotes'))
doc.append(NoEscape('\small'))
if info_PU[5] == ['osobní výtahy, malé nákladní výtahy']:
if h_p <= 22.5:
s_vytah = [
'Šv', 'Výtahové šachty', '-', '-', '-', '-', '-',
'II.'
]
if 22.5 < h_p <= 45.0:
s_vytah = [
'Šv', 'Výtahové šachty', '-', '-', '-', '-', '-',
'III.'
]
if h_p > 45.0:
s_vytah = [
'Šv', 'Výtahové šachty', '-', '-', '-', '-', '-',
'IV.'
]
len_vytah = len(new_dict) + 1
app_vytah = pre + str(len_vytah) + suf
suf_str_v = ' Výtahová šachta odpovídá čl. 8.10.2 a) normy\
ČSN 73 0802. Šachta slouží pro přepravu\
osob, nebo jako malý nákladní výtah.'
loc_str_v = pre_str + app_vytah + suf_str_v
doc.append(NoEscape(loc_str_v))
if info_PU[5] == ['osobně-nákladní, nákladní výtahy']:
if h_p <= 30:
s_vytah = [
'Šv', 'Výtahové šachty', '-', '-', '-', '-', '-',
'III.'
]
if h_p > 30:
s_vytah = [
'Šv', 'Výtahové šachty', '-', '-', '-', '-', '-',
'IV.'
]
len_vytah = len(new_dict) + 1
app_vytah = pre + str(len_vytah) + suf
suf_str_v = ' Výtahová šachta odpovídá čl. 8.10.2 normy\
ČSN 73 0802 bodu b). Šachta slouží jako\
osobo nákladní nebo nákladní výtah.'
loc_str_v = pre_str + app_vytah + suf_str_v
doc.append(NoEscape(loc_str_v))
app_this = pre + str(len_vytah) + suf
s_vytah[1] = NoEscape(s_vytah[1] + app_this)
if info_PU[4] == ['ANO']:
try:
new_dict
except NameError:
var_exist = False
else:
var_exist = True
if var_exist is False:
new_dict = []
pre_str = '\item'
doc.append(Command('begin', 'TableNotes'))
doc.append(NoEscape('\small'))
if info_PU[6] == ['rozvody hořlavých látek – max 1000 mm2']:
if h_p <= 22.5:
s_inst = [
'Ši', 'Instalační šachty', '-', '-', '-', '-', '-',
'II.'
]
if 22.5 < h_p <= 45.0:
s_inst = [
'Ši', 'Instalační šachty', '-', '-', '-', '-', '-',
'III.'
]
if h_p > 45.0:
s_inst = [
'Ši', 'Instalační šachty', '-', '-', '-', '-', '-',
'IV.'
]
if info_PU[3] == ['ANO']:
len_inst = len_vytah + 1
app_vytah = pre + str(len_inst) + suf
suf_str_i = ' Instalační šachty jsou zatříděny v souladu s\
čl. 8.12.2 c). Šachty jsou dimenzovány\
pro rozvody hořlavých látek o celkovém\
průřezu 1000 m$^2$'
loc_str_i = pre_str + app_vytah + suf_str_i
doc.append(NoEscape(loc_str_i))
if info_PU[6] == [
'rozvody nehořlavých látek – potrubí A1,\
A2'
]:
s_inst = [
'Ši', 'Instalační šachty', '-', '-', '-', '-', '-',
'I.'
]
if info_PU[6] == ['rozvody nehořlavých látek – potrubí B-F']:
s_inst = [
'Ši', 'Instalační šachty', '-', '-', '-', '-', '-',
'II.'
]
if info_PU[6] == ['rozvody hořlavých látek – 1000-8000 mm2']:
if h_p <= 45.0:
s_inst = [
'Ši', 'Instalační šachty', '-', '-', '-', '-', '-',
'IV.'
]
if h_p > 45.0:
s_inst = [
'Ši', 'Instalační šachty', '-', '-', '-', '-', '-',
'V.'
]
if info_PU[6] == [
'rozvody hořlavých látek – více než 8000 mm2'
]:
s_inst = [
'Ši', 'Instalační šachty', '-', '-', '-', '-', '-',
'VI.'
]
if info_PU[3] == ['ANO']:
len_inst = len_vytah + 1
else:
len_inst = len(new_dict) + 1
app_this = pre + str(len_inst) + suf
s_inst[1] = NoEscape(s_inst[1] + app_this)
data_used.append(s_vytah)
data_used.append(s_inst)
if len(check) > 0 or info_PU[4] == ['ANO'
] or info_PU[3] == ['ANO']:
doc.append(Command('end', 'TableNotes'))
for i in range(0, len(data_used)):
data_used[i][2] = data_used[i][2].replace(".", ",")
data_used[i][3] = data_used[i][3].replace(".", ",")
data_used[i][4] = data_used[i][4].replace(".", ",")
data_used[i][5] = data_used[i][5].replace(".", ",")
data_used[i][6] = data_used[i][6].replace(".", ",")
with doc.create(LongTable("l l c c c c c c",
pos=['htb'])) as data_table:
doc.append(
Command('caption',
'Přehled požárních úselků a jejich SPB'))
doc.append(Command('label', 'PU'))
doc.append(Command('\ '))
data_table.append
data_table.add_hline()
data_table.add_row([
"Číslo", "Popis", "Plocha",
MultiColumn(3, data='Součinitelé'),
NoEscape('p$_v$'), "SPB"
])
data_table.add_row([
" ", " ",
NoEscape('[m$^2$]'), "a", "b", "c",
NoEscape('[kg/m$^2$]'), '[-]'
])
data_table.add_hline()
data_table.end_table_header()
for i in range(0, len(data_used)):
if i % 2 != 0:
data_table.add_row(data_used[i], color="Hex")
else:
data_table.add_row(data_used[i])
data_table.add_hline()
if len(check) > 0 or info_PU[4] == ['ANO'
] or info_PU[3] == ['ANO']:
doc.append(NoEscape('\insertTableNotes'))
os.chdir(vystup_dir)
doc.append(Command('end', 'ThreePartTable'))
doc.generate_pdf("D_PU", clean_tex=False)
def _document_instance_table(self, tests: List[Dict[str, Any]],
with_id: bool):
"""Document a result table of per-instance tests.
Args:
tests: List of corresponding test dictionary to make a table.
with_id: Whether the test information includes data ID.
"""
if with_id:
table_spec = '|c|p{5cm}|c|c|p{5cm}|'
column_num = 5
else:
table_spec = '|c|p{10cm}|c|c|'
column_num = 4
with self.doc.create(LongTable(table_spec, pos=['h!'],
booktabs=True)) as tabular:
package = Package('seqsplit')
if package not in tabular.packages:
tabular.packages.append(package)
# add table heading
row_cells = [
MultiColumn(size=1, align='|c|', data="Test ID"),
MultiColumn(size=1, align='c|', data="Test Description"),
MultiColumn(size=1, align='c|', data="Pass Threshold"),
MultiColumn(size=1, align='c|', data="Failure Count")
]
if with_id:
row_cells.append(
MultiColumn(size=1,
align='c|',
data="Failure Data Instance ID"))
tabular.add_row(row_cells)
# add table header and footer
tabular.add_hline()
tabular.end_table_header()
tabular.add_hline()
tabular.add_row((MultiColumn(column_num,
align='r',
data='Continued on Next Page'), ))
tabular.add_hline()
tabular.end_table_footer()
tabular.end_table_last_footer()
for idx, test in enumerate(tests):
if idx > 0:
tabular.add_hline()
des_data = [
WrapText(data=x, threshold=27)
for x in test["description"].split(" ")
]
row_cells = [
self.test_id,
IterJoin(data=des_data, token=" "),
NoEscape(r'$\le $' + str(test["fail_threshold"])),
test["fail_number"]
]
if with_id:
id_data = [
WrapText(data=x, threshold=27) for x in test["fail_id"]
]
row_cells.append(IterJoin(data=id_data, token=", "))
tabular.add_row(row_cells)
self.test_id += 1
def description_classification(full_data_files, description_folder):
data_list = list()
for d in full_data_files:
name = d.split('/')[2].split('.')[0]
df = pd.read_csv(d,
sep='\s+',
header=None)
lines, columns = df.shape
attribute = columns - 1 # Minus one because of target
last_pos = attribute
classes = np.unique(df[last_pos])
n_classes = len(classes)
distribution_list = [len(df[df[last_pos] == c]) for c in classes]
distribution_list.sort(reverse=True)
distribution = tuple(distribution_list)
data_list.append({'Dataset': name,
'Size': lines,
'Attributes': attribute,
'Classes': n_classes,
'Class distribution': distribution})
df = pd.DataFrame(data_list)
df = df.sort_values('Size', ascending=False)
cols = ['Dataset',
'Size',
'Attributes',
'Classes',
'Class distribution']
df = df[cols]
df_copy = deepcopy(df)
df_copy['Class distribution'] = [str(value).replace(', ', ';').replace(')', '').replace('(', '')
for value in df_copy['Class distribution']]
df_copy.to_csv(os.path.join(description_folder,
'data_description.csv'),
sep=',',
header=True,
columns=['Dataset',
'Size',
'Attributes',
'Classes',
'Class distribution'],
index=False)
# # LaTeX
df = df.set_index(['Dataset'])
# Max classes per row
max_classes = np.inf
geometry_options = {
"margin": "1.00cm",
"includeheadfoot": True
}
doc = Document(page_numbers=True, geometry_options=geometry_options)
# Generate data table
with doc.create(LongTable("l l l l l")) as data_table:
data_table.add_hline()
header = ["Dataset",
"Size",
"#Attr.",
"#Classes",
"Class distribution"]
data_table.add_row(header)
data_table.add_hline()
data_table.add_hline()
for index in df.index.values:
row = [index] + df.loc[index].values.tolist()
if len(row[-1]) > max_classes:
max = max_classes
finished = False
subrow = row.copy()
# Select subtuple and removing last parenthesis
subrow[-1] = str(subrow[-1][:max]).replace(')', ',')
data_table.add_row(subrow)
while finished is False:
last_element = row[-1][max:max + max_classes]
if len(last_element) == 1:
# To string
last_element = str(last_element)
# Remove first and last parenthesis and comma
last_element = last_element[1:-2]
else:
# To string
last_element = str(last_element)
# Remove first and last parenthesis
last_element = last_element[1:-1]
max = max + max_classes
if max >= len(row[-1]):
finished = True
last_element += ')'
else:
# Remove last parenthesis or comma if len is 1
last_element = last_element[:-1]
subrow = ['', '', '', '', last_element]
data_table.add_row(subrow)
else:
data_table.add_row(row)
doc.generate_pdf(os.path.join(description_folder,
'data_description'), clean_tex=False)
def tuning_LogisticRegression():
param_grid = {
"tol": [1e-3, 1e-4, 1e-5],
"C": [1e-5, 3e-5, 1e-4, 3e-4, 1e-3],
"max_iter": [100, 200, 300]
}
result_list = []
optimized_param = [0, 0, 0, 0, 0, 0, 0]
for tol in param_grid["tol"]:
for C in param_grid["C"]:
for max_iter in param_grid["max_iter"]:
# try:
current_param_and_eval = [tol, C, max_iter]
clf = LogisticRegression(tol=tol,
C=C,
max_iter=max_iter,
multi_class="multinomial",
solver="newton-cg")
f1_scores_dict = load_train_output_crossvalidation(clf)
f1_scores_dict = round_f1_score(f1_scores_dict)
f1_train_average = f1_scores_dict["f1_train_average"]
f1_dev_average = f1_scores_dict["f1_dev_average"]
f1_train_micro_average = f1_scores_dict[
"f1_train_micro_average"]
f1_dev_micro_average = f1_scores_dict["f1_dev_micro_average"]
current_param_and_eval.append(f1_train_micro_average)
current_param_and_eval.append(f1_dev_micro_average)
current_param_and_eval.append(f1_train_average)
current_param_and_eval.append(f1_dev_average)
result_list.append(current_param_and_eval)
if current_param_and_eval[4] > optimized_param[4]:
optimized_param = current_param_and_eval
# except:
# print("An exception occurs.")
# Generate data table
geometry_options = {"margin": "2.54cm", "includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
with doc.create(LongTable("l l l l l l l")) as data_table:
data_table.add_hline()
data_table.add_row([
"tol", "C", "max_iter", "training f1", "valid f1",
"training f1 for each technique", "valid f1 for each technique"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
for i in range(len(result_list)):
data_table.add_row(result_list[i][0:7])
data_table.add_hline()
with doc.create(LongTable("l l l l l l l")) as data_table:
data_table.add_hline()
data_table.add_row([
"tol", "C", "max_iter", "training f1", "valid f1",
"training f1 for each technique", "valid f1 for each technique"
])
data_table.add_hline()
data_table.end_table_header()
data_table.add_hline()
data_table.add_row(optimized_param)
data_table.add_hline()
print("This is for LogisticRegression.")
doc.generate_pdf("tuning_LogisticRegression", clean_tex=False)
def latex_report(system, curves, grid, filename):
lines = system.lines
trafos = system.trafos
buses = system.buses
geometry_options = {"tmargin": "1cm",
"lmargin": "1cm",
"rmargin": "1cm",
"bmargin": "1cm",
"includeheadfoot": True}
doc = Document(page_numbers=True, geometry_options=geometry_options)
doc.preamble.append(Command('usepackage', 'cmbright'))
doc.preamble.append(Command('usepackage', 'tikz'))
doc.preamble.append(Command('usepackage', 'amsmath'))
doc.preamble.append(Command('usepackage', 'graphicx'))
now = datetime.datetime.now()
doc.append(f'Report auto-generated by Elegant at '
f'{now.day:02d}/{now.month:02d}/{now.year:02d} '
f'{now.hour:02d}:{now.minute:02d}:{now.second:02d}')
wye_comm = UnsafeCommand(
'newcommand', '\\wye',
extra_arguments=r'\mathbin{\text{\begin{tikzpicture}'
r'[x=1pt, y=1pt, scale=2]'
r'\draw '
r'(-0.9, 0) -- (0.9, 0) '
r'(-0.6, -0.5) -- (0.6, -0.5) '
r'(-0.3, -1) -- (0.3, -1) '
r'(0, 0) -- ++(0, 1.5) -- ++(1.2, 0) coordinate (tmp)'
r'-- +(0, -2) '
r'(tmp) +(45:2) -- (tmp) -- +(135:2) ;'
r'\end{tikzpicture}}}'
)
why_comm = UnsafeCommand(
'newcommand', '\\why',
extra_arguments=r'\mathbin{\text{\begin{tikzpicture}'
r'[x=1pt, y=1pt, scale=2]'
r'\draw '
r'(1.2, 1.5) coordinate (tmp)'
r'-- +(0, -2) '
r'(tmp) +(45:2) -- (tmp) -- +(135:2) ;'
r'\end{tikzpicture}}}'
)
doc.append(wye_comm)
doc.append(why_comm)
doc.add_color(name="lightgray", model="gray", description="0.80")
with doc.create(Section('Buses')):
with doc.create(Subsection('Load-Flow Solution')):
with doc.create(LongTable('c|ccccccc')) as tbl:
tbl.add_hline()
tbl.add_row(('Bus', NoEscape('$|V|$ (pu)'), NoEscape('$\\delta$ (deg)'),
NoEscape('$P_G$ (MW)'), NoEscape('$Q_G$ (Mvar)'),
NoEscape('$P_L$ (MW)'), NoEscape('$Q_L$ (Mvar)'),
NoEscape('$Z_L$ (pu)')))
tbl.add_hline()
tbl.end_table_header()
tbl.add_hline()
tbl.add_row((MultiColumn(8, align='r', data='Continued on Next Page'),))
tbl.add_hline()
tbl.end_table_footer()
tbl.add_hline()
tbl.end_table_last_footer()
for i, b in enumerate(buses):
if i % 2 == 0:
color = 'lightgray'
else:
color = None
tbl.add_row((b.bus_id + 1,
NoEscape('{:.04f}'.format(b.v)),
NoEscape('${:.02f}$'.format(b.delta * 180 / np.pi)),
NoEscape('{:.02f}'.format(b.pg * 100)),
NoEscape('{:.02f}'.format(b.qg * 100)),
NoEscape('{:.02f}'.format(b.pl * 100)),
NoEscape('{:.02f}'.format(b.ql * 100)),
safe_repr(b.Z)),
color=color)
with doc.create(Subsection('Fault Calculations')):
with doc.create(LongTable('c|cccccccccc')) as tbl:
tbl.add_hline()
tbl.add_row((MultiRow(2, data='Bus'),
MultiColumn(2, align='c', data=NoEscape('TPG')),
MultiColumn(2, align='c', data=NoEscape('SLG')),
MultiColumn(4, align='c', data=NoEscape('DLG')),
MultiColumn(2, align='c', data=NoEscape('LL'))))
tbl.add_hline(2, 11)
tbl.add_row(('', NoEscape('$I_A$ (pu)'), NoEscape('$\\delta_A$ (deg)'),
NoEscape('$I_A$ (pu)'), NoEscape('$\\delta_A$ (deg)'),
NoEscape('$I_B$ (pu)'), NoEscape('$\\delta_B$ (deg)'),
NoEscape('$I_C$ (pu)'), NoEscape('$\\delta_C$ (deg)'),
NoEscape('$I_B$ (pu)'), NoEscape('$\\delta_B$ (deg)')))
tbl.add_hline()
tbl.end_table_header()
tbl.add_hline()
tbl.add_row((MultiColumn(11, align='r', data='Continued on Next Page'),))
tbl.add_hline()
tbl.end_table_footer()
tbl.add_hline()
tbl.end_table_last_footer()
for i, b in enumerate(buses):
if i % 2 == 0:
color = 'lightgray'
else:
color = None
tbl.add_row((b.bus_id + 1,
safe_repr(np.abs(b.iTPG)),
NoEscape('${:.02f}$'.format(np.angle(b.iTPG) * 180 / np.pi)),
safe_repr(np.abs(b.iSLG)),
NoEscape('${:.02f}$'.format(np.angle(b.iSLG) * 180 / np.pi)),
safe_repr(np.abs(b.iDLGb)),
NoEscape('${:.02f}$'.format(np.angle(b.iDLGb) * 180 / np.pi)),
safe_repr(np.abs(b.iDLGc)),
NoEscape('${:.02f}$'.format(np.angle(b.iDLGc) * 180 / np.pi)),
safe_repr(np.abs(b.iLL)),
NoEscape('${:.02f}$'.format(np.angle(b.iLL) * 180 / np.pi))),
color=color)
with doc.create(Section('Lines')):
with doc.create(LongTable('c|cccccccc')) as tbl:
tbl.add_hline()
tbl.add_row((MultiRow(2, data='Line'),
MultiColumn(3, align='c', data='Parametrization'),
MultiColumn(2, align='c', data='Loss'),
MultiColumn(3, align='c', data='Flow')))
tbl.add_hline(2, 9)
tbl.add_row(('', NoEscape('$R$ (\\%pu)'), NoEscape('$X_L$ (\\%pu)'),
NoEscape('$B_C$ (\\%pu)'), NoEscape('$P_{loss}$ (MW)'),
NoEscape('$Q_{loss}$ (Mvar)'), NoEscape('$P$ (MW)'),
NoEscape('$Q$ (Mvar)'), NoEscape('$I/I_{max}$ (\\%)')))
tbl.add_hline()
tbl.end_table_header()
tbl.add_hline()
tbl.add_row((MultiColumn(9, align='r', data='Continued on Next Page'),))
tbl.add_hline()
tbl.end_table_footer()
tbl.add_hline()
tbl.end_table_last_footer()
for i, lt in enumerate(lines):
if i % 2 == 0:
color = 'lightgray'
else:
color = None
tbl.add_row((NoEscape('{} -- {}'.format(lt.orig.bus_id + 1, lt.dest.bus_id + 1)),
NoEscape('{:.04f}'.format(lt.Zpu.real * 100)),
NoEscape('{:.04f}'.format(lt.Zpu.imag * 100)),
NoEscape('{:.04f}'.format(lt.Ypu.imag * 100)),
NoEscape('{:.02f}'.format(lt.Sper.real * 100)),
NoEscape('{:.02f}'.format(lt.Sper.imag * 100)),
NoEscape('{:.02f}'.format(lt.S2.real * 100)),
NoEscape('{:.02f}'.format(lt.S2.imag * 100)),
NoEscape('{:.02f}'.format(np.abs(lt.Ia) / lt.imax * 100))),
color=color)
with doc.create(Section('Trafos')):
with doc.create(LongTable('c|ccccccc')) as tbl:
tbl.add_hline()
tbl.add_row((MultiRow(2, data='Trafo'),
MultiColumn(3, align='c', data='Parametrization'),
MultiColumn(1, align='c', data='Loss'),
MultiColumn(3, align='c', data='Flow')))
tbl.add_hline(2, 8)
tbl.add_row(('', NoEscape('$x^+$ (\\%pu)'), NoEscape('$x^0$ (\\%pu)'),
'Configuration', NoEscape('$Q_{loss}$ (Mvar)'),
NoEscape('$P$ (MW)'), NoEscape('$Q$ (Mvar)'), NoEscape('$S/S_N$ (\\%)')))
tbl.add_hline()
tbl.end_table_header()
tbl.add_hline()
tbl.add_row((MultiColumn(8, align='r', data='Continued on Next Page'),))
tbl.add_hline()
tbl.end_table_footer()
tbl.add_hline()
tbl.end_table_last_footer()
for i, tr in enumerate(trafos):
if i % 2 == 0:
color = 'lightgray'
else:
color = None
tbl.add_row((NoEscape('{} -- {}'.format(tr.orig.bus_id + 1, tr.dest.bus_id + 1)),
NoEscape('{:.02f}'.format(tr.Z1.imag * 100)),
NoEscape('{:.02f}'.format(tr.Z0.imag * 100)),
get_scheme(tr),
NoEscape('{:.02f}'.format(tr.Sper.imag * 100)),
NoEscape('{:.02f}'.format(tr.S2.real * 100)),
NoEscape('{:.02f}'.format(tr.S2.imag * 100)),
NoEscape('{:.02f}'.format(np.abs(tr.S2) * 1e8 / tr.snom * 100))),
color=color)
filepath = filename.strip('.pdf')
make_system_schematic(curves, grid, initial_fontsize=9)
doc.append(NewPage())
with doc.create(Section('System')):
with doc.create(Figure(position='h')) as system_pic:
system_pic.add_plot(bbox_inches='tight', width=NoEscape('\\textwidth'))
doc.generate_pdf(filepath, clean_tex=True, compiler='latexmk', compiler_args=['-pdf'])
def save_report(model, file_name, detailed_traces=2):
print('Saving analytics report to {}.tex and {}.pdf'.format(
file_name, file_name))
inference_network = model._inference_network
iter_per_sec = inference_network._total_train_iterations / inference_network._total_train_seconds
traces_per_sec = inference_network._total_train_traces / inference_network._total_train_seconds
traces_per_iter = inference_network._total_train_traces / inference_network._total_train_iterations
train_loss_initial = inference_network._history_train_loss[0]
train_loss_final = inference_network._history_train_loss[-1]
train_loss_change = train_loss_final - train_loss_initial
train_loss_change_per_sec = train_loss_change / inference_network._total_train_seconds
train_loss_change_per_iter = train_loss_change / inference_network._total_train_iterations
train_loss_change_per_trace = train_loss_change / inference_network._total_train_traces
valid_loss_initial = inference_network._history_valid_loss[0]
valid_loss_final = inference_network._history_valid_loss[-1]
valid_loss_change = valid_loss_final - valid_loss_initial
valid_loss_change_per_sec = valid_loss_change / inference_network._total_train_seconds
valid_loss_change_per_iter = valid_loss_change / inference_network._total_train_iterations
valid_loss_change_per_trace = valid_loss_change / inference_network._total_train_traces
sys.stdout.write(
'Generating report... \r')
sys.stdout.flush()
geometry_options = {
'tmargin': '1.5cm',
'lmargin': '1cm',
'rmargin': '1cm',
'bmargin': '1.5cm'
}
doc = Document('basic', geometry_options=geometry_options)
doc.preamble.append(NoEscape(r'\usepackage[none]{hyphenat}'))
doc.preamble.append(NoEscape(r'\usepackage{float}'))
# doc.preamble.append(NoEscape(r'\renewcommand{\familydefault}{\ttdefault}'))
doc.preamble.append(Command('title', 'pyprob analytics: ' + model.name))
doc.preamble.append(
Command(
'date',
NoEscape(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))))
doc.append(NoEscape(r'\maketitle'))
# doc.append(NoEscape(r'\small'))
print('Analytics: Current system')
with doc.create(Section('Current system', numbering=False)):
with doc.create(Tabularx('ll')) as table:
table.add_row(('pyprob version', __version__))
table.add_row(('PyTorch version', torch.__version__))
# doc.append(NoEscape(r'\newpage'))
print('Analytics: Inference network')
with doc.create(Section('Inference network', numbering=False)):
print('Analytics: Inference network.File')
with doc.create(Section('File')):
with doc.create(Tabularx('ll')) as table:
# table.add_row(('File name', file_name))
# file_size = '{:,}'.format(os.path.getsize(file_name))
# table.add_row(('File size', file_size + ' Bytes'))
table.add_row(('Created', inference_network._created))
table.add_row(('Modified', inference_network._modified))
table.add_row(('Updates to file', inference_network._updates))
print('Analytics: Inference network.Training')
with doc.create(Section('Training')):
with doc.create(Tabularx('ll')) as table:
table.add_row(
('pyprob version', inference_network._pyprob_version))
table.add_row(
('PyTorch version', inference_network._torch_version))
table.add_row(('Trained on', inference_network._trained_on))
table.add_row(('Total training time', '{0}'.format(
util.days_hours_mins_secs_str(
inference_network._total_train_seconds))))
table.add_row(
('Total training traces',
'{:,}'.format(inference_network._total_train_traces)))
table.add_row(('Traces / s', '{:,.2f}'.format(traces_per_sec)))
table.add_row(
('Traces / iteration', '{:,.2f}'.format(traces_per_iter)))
table.add_row(
('Iterations',
'{:,}'.format(inference_network._total_train_iterations)))
table.add_row(
('Iterations / s', '{:,.2f}'.format(iter_per_sec)))
table.add_row(('Optimizer', inference_network._optimizer_type))
table.add_row(('Validation set size',
inference_network._valid_batch.length))
print('Analytics: Inference network.Training loss')
with doc.create(Subsection('Training loss')):
with doc.create(Tabularx('ll')) as table:
table.add_row(
('Initial loss', '{:+.6e}'.format(train_loss_initial)))
table.add_row(
('Final loss', '{:+.6e}'.format(train_loss_final)))
table.add_row(('Loss change / s',
'{:+.6e}'.format(train_loss_change_per_sec)))
table.add_row(('Loss change / iteration',
'{:+.6e}'.format(train_loss_change_per_iter)))
table.add_row(('Loss change / trace',
'{:+.6e}'.format(train_loss_change_per_trace)))
print('Analytics: Inference network.Validation loss')
with doc.create(Subsection('Validation loss')):
with doc.create(Tabularx('ll')) as table:
table.add_row(
('Initial loss', '{:+.6e}'.format(valid_loss_initial)))
table.add_row(
('Final loss', '{:+.6e}'.format(valid_loss_final)))
table.add_row(('Loss change / s',
'{:+.6e}'.format(valid_loss_change_per_sec)))
table.add_row(('Loss change / iteration',
'{:+.6e}'.format(valid_loss_change_per_iter)))
table.add_row(('Loss change / trace',
'{:+.6e}'.format(valid_loss_change_per_trace)))
with doc.create(Figure(position='H')) as plot:
fig = plt.figure(figsize=(10, 6))
ax = plt.subplot(111)
ax.plot(inference_network._history_train_loss_trace,
inference_network._history_train_loss,
label='Training')
ax.plot(inference_network._history_valid_loss_trace,
inference_network._history_valid_loss,
label='Validation')
ax.legend()
plt.xlabel('Training traces')
plt.ylabel('Loss')
plt.grid()
fig.tight_layout()
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption('Loss plot.')
print('Analytics: Inference network.Neural network modules')
with doc.create(Section('Neural network modules')):
with doc.create(Tabularx('ll')) as table:
table.add_row(
('Total trainable parameters',
'{:,}'.format(inference_network._history_num_params[-1])))
# table.add_row(('Softmax boost', inference_network.softmax_boost))
# table.add_row(('Dropout', inference_network.dropout))
# table.add_row(('Standardize inputs', inference_network.standardize_observes))
with doc.create(Figure(position='H')) as plot:
fig = plt.figure(figsize=(10, 4))
ax = plt.subplot(111)
ax.plot(inference_network._history_num_params_trace,
inference_network._history_num_params)
plt.xlabel('Training traces')
plt.ylabel('Number of parameters')
plt.grid()
fig.tight_layout()
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption('Number of parameters.')
doc.append(NoEscape(r'\newpage'))
print(
'Analytics: Inference network.Neural network modules.All modules'
)
with doc.create(Subsection('All modules')):
doc.append(str(inference_network))
for m_name, m in inference_network.named_modules():
if (m_name != ''):
regex = r'(sample_embedding_layer\(\S*\)._)|(proposal_layer\(\S*\)._)|(_observe_embedding_layer.)|(_lstm)'
if len(list(re.finditer(regex, m_name))) > 0:
# if ('_observe_embedding_layer.' in m_name) or ('sample_embedding_layer.' in m_name) or ('proposal_layer.' in m_name):
doc.append(NoEscape(r'\newpage'))
with doc.create(Subsubsection(m_name)):
doc.append(str(m))
for p_name, p in m.named_parameters():
if not 'bias' in p_name:
with doc.create(
Figure(position='H')) as plot:
fig = plt.figure(figsize=(10, 10))
ax = plt.subplot(111)
plt.imshow(np.transpose(
util.weights_to_image(p),
(1, 2, 0)),
interpolation='none')
plt.axis('off')
plot.add_plot(
width=NoEscape(r'\textwidth'))
plot.add_caption(m_name + '_' + p_name)
# doc.append(NoEscape(r'\newpage'))
# print('Analytics: Inference network.Neural network modules.Address embeddings')
# with doc.create(Subsection('Address embeddings')):
# for p_name, p in inference_network.named_parameters():
# if ('address_embedding' in p_name):
# with doc.create(Figure(position='H')) as plot:
# fig = plt.figure(figsize=(10,10))
# ax = plt.subplot(111)
# plt.imshow(np.transpose(util.weights_to_image(p),(1,2,0)), interpolation='none')
# plt.axis('off')
# plot.add_plot(width=NoEscape(r'\textwidth'))
# plot.add_caption(FootnoteText(p_name.replace('::', ':: ')))
gc.collect()
doc.append(NoEscape(r'\newpage'))
print('Analytics: Inference network.Traces')
with doc.create(Section('Traces')):
with doc.create(Tabularx('ll')) as table:
table.add_row(
('Total training traces',
'{:,}'.format(inference_network._total_train_traces)))
print(
'Analytics: Inference network.Traces.Distributions encountered'
)
with doc.create(Subsection('Distributions encountered')):
with doc.create(Tabularx('ll')) as table:
# print([v[2] for v in inference_network._address_stats.values()])
distributions = set([
v[2]
for v in inference_network._address_stats.values()
])
num_distributions = len(distributions)
table.add_row(
('Number of distributions', num_distributions))
table.add_empty_row()
for distribution in distributions:
table.add_row((distribution, ''))
print('Analytics: Inference network.Traces.Addresses encountered')
with doc.create(Subsection('Addresses encountered')):
with doc.create(Tabularx('lX')) as table:
num_addresses_all = len(
inference_network._address_stats.keys())
table.add_row(('Number of addresses', num_addresses_all))
num_addresses_controlled = len([
k for k, v in inference_network._address_stats.items()
if v[3]
])
num_addresses_replaced = len([
k for k, v in inference_network._address_stats.items()
if v[3] and v[4]
])
num_addresses_observed = len([
k for k, v in inference_network._address_stats.items()
if v[5]
])
table.add_row(
(TextColor('red', 'Number of addresses (controlled)'),
TextColor('red', num_addresses_controlled)))
table.add_row((TextColor('green',
'Number of addresses (replaced)'),
TextColor('green', num_addresses_replaced)))
table.add_row((TextColor('blue',
'Number of addresses (observed)'),
TextColor('blue', num_addresses_observed)))
table.add_row(
('Number of addresses (uncontrolled)',
num_addresses_all - num_addresses_controlled -
num_addresses_observed))
table.add_empty_row()
doc.append('\n')
with doc.create(LongTable('llllllp{12cm}')) as table:
# table.add_empty_row()
table.add_row(FootnoteText('Count'), FootnoteText('ID'),
FootnoteText('Distrib.'),
FootnoteText('Ctrl.'),
FootnoteText('Replace'),
FootnoteText('Obs.'),
FootnoteText('Address'))
table.add_hline()
# address_to_abbrev = {}
# abbrev_to_address =
# abbrev_i = 0
# sorted_addresses = sorted(inference_network.address_histogram.items(), key=lambda x:x[1], reverse=True)
plt_all_addresses = []
plt_all_counts = []
plt_all_colors = []
plt_controlled_addresses = []
plt_controlled_counts = []
plt_controlled_colors = []
address_id_to_count = {}
address_id_to_color = {}
address_id_count_total = 0
for address, vals in inference_network._address_stats.items(
):
address = address.replace('::', ':: ')
count = vals[0]
address_id = vals[1]
distribution = vals[2]
control = vals[3]
replace = vals[4]
observed = vals[5]
plt_all_addresses.append(address_id)
plt_all_counts.append(1 if replace else count)
address_id_to_count[address_id] = count
address_id_count_total += count
if control:
if replace:
color = 'green'
plt_controlled_counts.append(1)
else:
color = 'red'
plt_controlled_counts.append(count)
plt_controlled_addresses.append(address_id)
plt_controlled_colors.append(color)
elif observed:
color = 'blue'
plt_controlled_addresses.append(address_id)
plt_controlled_colors.append(color)
plt_controlled_counts.append(count)
else:
color = 'black'
table.add_row(
(TextColor(color,
FootnoteText('{:,}'.format(count))),
TextColor(color, FootnoteText(address_id)),
TextColor(color, FootnoteText(distribution)),
TextColor(color, FootnoteText(control)),
TextColor(color, FootnoteText(replace)),
TextColor(color, FootnoteText(observed)),
TextColor(color, FootnoteText(address))))
plt_all_colors.append(color)
address_id_to_color[address_id] = color
gc.collect()
with doc.create(Figure(position='H')) as plot:
fig = plt.figure(figsize=(10, 5))
ax = plt.subplot(111)
plt_x = range(len(plt_all_addresses))
ax.bar(plt_x, plt_all_counts, color=plt_all_colors)
plt.xticks(plt_x, plt_all_addresses)
plt.xlabel('Address ID')
plt.ylabel('Count')
# plt.grid()
fig.tight_layout()
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption(
'Histogram of all addresses. Red: controlled, green: replaced, black: uncontrolled, blue: observed.'
)
with doc.create(Figure(position='H')) as plot:
fig = plt.figure(figsize=(10, 5))
ax = plt.subplot(111)
plt_x = range(len(plt_controlled_addresses))
ax.bar(plt_x,
plt_controlled_counts,
color=plt_controlled_colors)
plt.xticks(plt_x, plt_controlled_addresses)
plt.xlabel('Address ID')
plt.ylabel('Count')
# plt.grid()
fig.tight_layout()
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption(
'Histogram of controlled and observed addresses. Red: controlled, green: replaced, blue: observed.'
)
gc.collect()
print('Analytics: Inference network.Traces.Trace lengths')
with doc.create(Subsection('Trace lengths')):
with doc.create(Tabularx('ll')) as table:
trace_lengths_controlled = [
v[3] for v in inference_network._trace_stats.values()
]
trace_lengths_controlled_min = min(
trace_lengths_controlled)
trace_lengths_controlled_max = max(
trace_lengths_controlled)
trace_lengths_all = [
v[2] for v in inference_network._trace_stats.values()
]
trace_lengths_all_min = min(trace_lengths_all)
trace_lengths_all_max = max(trace_lengths_all)
s_controlled = 0
s_all = 0
total_count = 0
for _, v in inference_network._trace_stats.items():
trace_length_controlled = v[3]
trace_length_all = v[2]
count = v[0]
s_controlled += trace_length_controlled * count
total_count += count
s_all += trace_length_all * count
trace_length_controlled_mean = s_controlled / total_count
trace_length_all_mean = s_all / total_count
table.add_row(('Trace length min',
'{:,}'.format(trace_lengths_all_min)))
table.add_row(('Trace length max',
'{:,}'.format(trace_lengths_all_max)))
table.add_row(('Trace length mean',
'{:.2f}'.format(trace_length_all_mean)))
table.add_row(
('Controlled trace length min',
'{:,}'.format(trace_lengths_controlled_min)))
table.add_row(
('Controlled trace length max',
'{:,}'.format(trace_lengths_controlled_max)))
table.add_row(
('Controlled trace length mean',
'{:.2f}'.format(trace_length_controlled_mean)))
with doc.create(Figure(position='H')) as plot:
plt_counter = dict(Counter(trace_lengths_all))
plt_lengths = [
i for i in range(0, trace_lengths_all_max + 1)
]
plt_counts = [
plt_counter[i] if i in plt_counter else 0
for i in range(0, trace_lengths_all_max + 1)
]
fig = plt.figure(figsize=(10, 5))
ax = plt.subplot(111)
ax.bar(plt_lengths,
plt_counts,
width=trace_lengths_all_max / 500.)
plt.xlabel('Length')
plt.ylabel('Count')
# plt.yscale('log')
# plt.grid()
fig.tight_layout()
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption('Histogram of trace lengths.')
with doc.create(Figure(position='H')) as plot:
plt_counter = dict(Counter(trace_lengths_controlled))
plt_lengths = [
i for i in range(0, trace_lengths_controlled_max + 1)
]
plt_counts = [
plt_counter[i] if i in plt_counter else 0
for i in range(0, trace_lengths_controlled_max + 1)
]
fig = plt.figure(figsize=(10, 5))
ax = plt.subplot(111)
ax.bar(plt_lengths, plt_counts)
plt.xlabel('Length')
plt.ylabel('Count')
# plt.yscale('log')
# plt.grid()
fig.tight_layout()
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption('Histogram of controlled trace lengths.')
gc.collect()
print(
'Analytics: Inference network.Traces.Unique traces encountered'
)
with doc.create(Subsection('Unique traces encountered')):
detailed_traces = min(len(inference_network._trace_stats),
detailed_traces)
with doc.create(Tabularx('ll')) as table:
table.add_row(
('Unique traces encountered',
'{:,}'.format(len(inference_network._trace_stats))))
table.add_row(('Unique traces rendered in detail',
'{:,}'.format(detailed_traces)))
doc.append('\n')
with doc.create(LongTable('llllp{15cm}')) as table:
# table.add_empty_row()
table.add_row(FootnoteText('Count'), FootnoteText('ID'),
FootnoteText('Len.'),
FootnoteText('Ctrl. len.'),
FootnoteText('Unique trace'))
table.add_hline()
plt_traces = []
plt_counts = []
for trace_str, vals in inference_network._trace_stats.items(
):
count = vals[0]
trace_id = vals[1]
length_all = vals[2]
length_controlled = vals[3]
addresses_controlled = vals[4]
addresses_controlled_str = ' '.join(
addresses_controlled)
plt_traces.append(trace_id)
plt_counts.append(count)
table.add_row(
(FootnoteText('{:,}'.format(count)),
FootnoteText(trace_id),
FootnoteText('{:,}'.format(length_all)),
FootnoteText('{:,}'.format(length_controlled)),
FootnoteText(addresses_controlled_str)))
with doc.create(Figure(position='H')) as plot:
fig = plt.figure(figsize=(10, 5))
ax = plt.subplot(111)
plt_x = range(len(plt_traces))
ax.bar(plt_x, plt_counts)
plt.xticks(plt_x, plt_traces)
plt.xlabel('Trace ID')
plt.ylabel('Count')
# plt.grid()
fig.tight_layout()
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption('Histogram of unique traces.')
with doc.create(Figure(position='H')) as plot:
sorted_trace_stats = OrderedDict(
sorted(dict(inference_network._trace_stats).items(),
key=lambda x: x[1],
reverse=True))
master_trace_pairs = {}
transition_count_total = 0
for trace_str, vals in sorted_trace_stats.items():
count = vals[0]
ta = vals[4]
for left, right in zip(ta, ta[1:]):
if (left, right) in master_trace_pairs:
master_trace_pairs[(left, right)] += count
else:
master_trace_pairs[(left, right)] = count
transition_count_total += count
fig = plt.figure(figsize=(10, 5))
ax = plt.subplot(111)
master_graph = pydotplus.graphviz.Dot(graph_type='digraph',
rankdir='LR')
transition_count_max = 0
for p, count in master_trace_pairs.items():
if count > transition_count_max:
transition_count_max = count
nodes = master_graph.get_node(p[0])
if len(nodes) > 0:
n0 = nodes[0]
else:
n0 = pydotplus.Node(p[0])
master_graph.add_node(n0)
nodes = master_graph.get_node(p[1])
if len(nodes) > 0:
n1 = nodes[0]
else:
n1 = pydotplus.Node(p[1])
master_graph.add_node(n1)
master_graph.add_edge(
pydotplus.Edge(n0, n1, weight=count))
for node in master_graph.get_nodes():
node.set_color('gray')
node.set_fontcolor('gray')
for edge in master_graph.get_edges():
edge.set_color('gray')
master_graph_annotated = pydotplus.graphviz.graph_from_dot_data(
master_graph.to_string())
for node in master_graph_annotated.get_nodes():
# color = util.rgb_to_hex(util.rgb_blend((1, 1, 1), (1, 0, 0), address_id_to_count[node.obj_dict['name']] / address_id_count_total))
address_id = node.obj_dict['name']
node.set_style('filled')
node.set_fillcolor(address_id_to_color[address_id])
node.set_color('black')
node.set_fontcolor('black')
for edge in master_graph_annotated.get_edges():
(left, right) = edge.obj_dict['points']
count = master_trace_pairs[(left, right)]
edge.set_label(count)
# color = util.rgb_to_hex((1.5*(count/transition_count_total), 0, 0))
edge.set_color('black')
edge.set_penwidth(2.5 * count / transition_count_max)
png_str = master_graph_annotated.create_png(
prog=['dot', '-Gsize=90', '-Gdpi=600'])
bio = BytesIO()
bio.write(png_str)
bio.seek(0)
img = np.asarray(mpimg.imread(bio))
plt.imshow(util.crop_image(img), interpolation='bilinear')
plt.axis('off')
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption(
'Succession of controlled addresses (accumulated over all traces). Red: controlled, green: replaced, blue: observed.'
)
for trace_str, vals in OrderedDict(
islice(sorted_trace_stats.items(), 0,
detailed_traces)).items():
count = vals[0]
trace_id = vals[1]
doc.append(NoEscape(r'\newpage'))
with doc.create(Subsubsection('Unique trace ' + trace_id)):
sys.stdout.write(
'Rendering unique trace {0}... \r'
.format(trace_id))
sys.stdout.flush()
addresses = len(plt_controlled_addresses)
trace_addresses = vals[4]
with doc.create(Tabularx('ll')) as table:
table.add_row(FootnoteText('Count'),
FootnoteText('{:,}'.format(count)))
table.add_row(
FootnoteText('Controlled length'),
FootnoteText('{:,}'.format(
len(trace_addresses))))
doc.append('\n')
im = np.zeros((addresses, len(trace_addresses)))
for i in range(len(trace_addresses)):
address = trace_addresses[i]
address_i = plt_controlled_addresses.index(address)
im[address_i, i] = 1
truncate = 100
for col_start in range(0, len(trace_addresses),
truncate):
col_end = min(col_start + truncate,
len(trace_addresses))
with doc.create(Figure(position='H')) as plot:
fig = plt.figure(figsize=(20 * (
(col_end + 4 - col_start) / truncate), 4))
ax = plt.subplot(111)
# ax.imshow(im,cmap=plt.get_cmap('Greys'))
sns.heatmap(
im[:, col_start:col_end],
cbar=False,
linecolor='lightgray',
linewidths=.5,
cmap='Greys',
yticklabels=plt_controlled_addresses,
xticklabels=np.arange(col_start, col_end))
plt.yticks(rotation=0)
fig.tight_layout()
plot.add_plot(
width=NoEscape(r'{0}\textwidth'.format(
(col_end + 4 - col_start) / truncate)),
placement=NoEscape(r'\raggedright'))
with doc.create(Figure(position='H')) as plot:
pairs = {}
for left, right in zip(trace_addresses,
trace_addresses[1:]):
if (left, right) in pairs:
pairs[(left, right)] += 1
else:
pairs[(left, right)] = 1
fig = plt.figure(figsize=(10, 5))
ax = plt.subplot(111)
graph = pydotplus.graphviz.graph_from_dot_data(
master_graph.to_string())
trace_address_to_count = {}
for address in trace_addresses:
if address in trace_address_to_count:
trace_address_to_count[address] += 1
else:
trace_address_to_count[address] = 1
transition_count_max = 0
for p, count in pairs.items():
if count > transition_count_max:
transition_count_max = count
left_node = graph.get_node(p[0])[0]
right_node = graph.get_node(p[1])[0]
edge = graph.get_edge(p[0], p[1])[0]
# color = util.rgb_to_hex(util.rgb_blend((1,1,1), (1,0,0), trace_address_to_count[p[0]] / len(trace_addresses)))
left_node.set_style('filled')
left_node.set_fillcolor(
address_id_to_color[p[0]])
left_node.set_color('black')
left_node.set_fontcolor('black')
# color = util.rgb_to_hex(util.rgb_blend((1,1,1), (1,0,0), trace_address_to_count[p[0]] / len(trace_addresses)))
right_node.set_style('filled')
right_node.set_fillcolor(
address_id_to_color[p[1]])
right_node.set_color('black')
right_node.set_fontcolor('black')
# (left, right) = edge.obj_dict['points']
edge.set_label(count)
# color = util.rgb_to_hex((1.5*(count/len(trace_addresses)),0,0))
edge.set_color('black')
edge.set_penwidth(2.5 * count /
transition_count_max)
png_str = graph.create_png(
prog=['dot', '-Gsize=90', '-Gdpi=600'])
bio = BytesIO()
bio.write(png_str)
bio.seek(0)
img = np.asarray(mpimg.imread(bio))
plt.imshow(util.crop_image(img),
interpolation='bilinear')
plt.axis('off')
plot.add_plot(width=NoEscape(r'\textwidth'))
plot.add_caption(
'Succession of controlled addresses (for one trace of type '
+ trace_id +
'). Red: controlled, green: replaced, blue: observed.'
)
with doc.create(Tabularx('lp{16cm}')) as table:
table.add_row(
FootnoteText('Trace'),
FootnoteText(' '.join(trace_addresses)))
doc.generate_pdf(file_name, clean_tex=False)
sys.stdout.write(
' \r')
sys.stdout.flush()
def save_latex(self,
uiObj,
Design_Check,
reportsummary,
filename,
rel_path,
Disp_2d_image,
Disp_3d_image,
module=''):
companyname = str(reportsummary["ProfileSummary"]['CompanyName'])
companylogo = str(reportsummary["ProfileSummary"]['CompanyLogo'])
groupteamname = str(reportsummary["ProfileSummary"]['Group/TeamName'])
designer = str(reportsummary["ProfileSummary"]['Designer'])
projecttitle = str(reportsummary['ProjectTitle'])
subtitle = str(reportsummary['Subtitle'])
jobnumber = str(reportsummary['JobNumber'])
client = str(reportsummary['Client'])
does_design_exist = reportsummary['does_design_exist']
osdagheader = '/ResourceFiles/images/Osdag_header_report.png'
# Add document header
geometry_options = {
"top": "5cm",
"hmargin": "2cm",
"headheight": "100pt",
"footskip": "100pt",
"bottom": "5cm"
}
doc = Document(geometry_options=geometry_options, indent=False)
doc.packages.append(Package('amsmath'))
doc.packages.append(Package('graphicx'))
doc.packages.append(Package('needspace'))
doc.append(pyl.Command('fontsize', arguments=[8, 12]))
doc.append(pyl.Command('selectfont'))
doc.add_color('OsdagGreen', 'RGB', '153,169,36')
doc.add_color('PassColor', 'RGB', '153,169,36')
doc.add_color('Red', 'RGB', '255,0,0')
doc.add_color('Green', 'RGB', '0,200,0')
doc.add_color('FailColor', 'HTML', '933A16')
header = PageStyle("header")
# Create center header
with header.create(Head("C")):
with header.create(Tabularx('|l|p{4cm}|l|X|')) as table:
table.add_hline()
# MultiColumn(4)
table.add_row((
MultiColumn(
2,
align='|c|',
data=('' if companylogo is '' else StandAloneGraphic(
image_options="height=0.95cm",
filename=companylogo))),
MultiColumn(2,
align='|c|',
data=[
'Created with',
StandAloneGraphic(
image_options="width=4.0cm,height=1cm",
filename=rel_path + osdagheader)
]),
))
table.add_hline()
table.add_row(('Company Name', companyname, 'Project Title',
projecttitle),
color='OsdagGreen')
table.add_hline()
table.add_row(
('Group/Team Name', groupteamname, 'Subtitle', subtitle),
color='OsdagGreen')
table.add_hline()
table.add_row(('Designer', designer, 'Job Number', jobnumber),
color='OsdagGreen')
table.add_hline()
table.add_row(
('Date', time.strftime("%d /%m /%Y"), 'Client', client),
color='OsdagGreen')
table.add_hline()
# Create right footer
with header.create(Foot("R")):
header.append(NoEscape(r'Page \thepage'))
#
# doc.preamble.append(header)
# doc.change_document_style("header")
# Add Heading
# with doc.create(MiniPage(align='c')):
doc.preamble.append(header)
doc.change_document_style("header")
with doc.create(Section('Input Parameters')):
with doc.create(
LongTable('|p{5cm}|p{2.5cm}|p{1.5cm}|p{3cm}|p{3.5cm}|',
row_height=1.2)) as table:
table.add_hline()
for i in uiObj:
# row_cells = ('9', MultiColumn(3, align='|c|', data='Multicolumn not on left'))
if i == "Selected Section Details" or i == KEY_DISP_ANGLE_LIST or i == KEY_DISP_TOPANGLE_LIST or i == KEY_DISP_CLEAT_ANGLE_LIST:
# if type(uiObj[i]) == list:
continue
if type(uiObj[i]) == dict:
table.add_hline()
sectiondetails = uiObj[i]
image_name = sectiondetails[KEY_DISP_SEC_PROFILE]
Img_path = '/ResourceFiles/images/' + image_name + '.png'
if (len(sectiondetails)) % 2 == 0:
# merge_rows = int(round_up(len(sectiondetails),2)/2 + 2)
merge_rows = int((len(sectiondetails) / 2)) + 2
else:
merge_rows = round_up((len(sectiondetails) / 2), 2)
if (len(sectiondetails)) % 2 == 0:
sectiondetails[''] = ''
a = list(sectiondetails.keys())
# index=0
for x in range(1, (merge_rows + 1)):
# table.add_row("Col.Det.",i,columndetails[i])
if x == 1:
table.add_row((
MultiRow(
merge_rows,
data=StandAloneGraphic(
image_options=
"width=5cm,height=5cm",
filename=rel_path + Img_path)),
MultiColumn(2, align='|c|', data=a[x]),
MultiColumn(2,
align='|c|',
data=sectiondetails[a[x]]),
))
elif x <= 4:
table.add_row((
'',
MultiColumn(2,
align='|c|',
data=NoEscape(a[x])),
MultiColumn(2,
align='|c|',
data=NoEscape(
sectiondetails[a[x]])),
))
else:
table.add_row((
'',
NoEscape(a[x]),
sectiondetails[a[x]],
NoEscape(a[merge_rows + x - 4]),
sectiondetails[a[merge_rows + x - 4]],
))
table.add_hline(2, 5)
elif uiObj[i] == "TITLE":
table.add_hline()
table.add_row((MultiColumn(
5,
align='|c|',
data=bold(i),
), ))
table.add_hline()
elif i == 'Section Size*':
table.add_hline()
table.add_row((
MultiColumn(
3,
align='|c|',
data=i,
),
MultiColumn(2,
align='|c|',
data="Ref List of Input Section"),
))
table.add_hline()
elif len(str(uiObj[i])) > 55 and type(
uiObj[i]) != pyl.math.Math:
str_len = len(str(uiObj[i]))
loop_len = round_up((str_len / 55), 1, 1)
for j in range(1, loop_len + 1):
b = 55 * j + 1
if j == 1:
table.add_row((
MultiColumn(3,
align='|c|',
data=MultiRow(loop_len,
data=i)),
MultiColumn(2,
align='|c|',
data=uiObj[i][0:b]),
))
else:
table.add_row((
MultiColumn(3,
align='|c|',
data=MultiRow(loop_len,
data="")),
MultiColumn(2,
align='|c|',
data=uiObj[i][b - 55:b]),
))
table.add_hline()
else:
table.add_hline()
table.add_row((
MultiColumn(3, align='|c|', data=NoEscape(i)),
MultiColumn(2, align='|c|', data=uiObj[i]),
))
table.add_hline()
for i in uiObj:
if i == 'Section Size*' or i == KEY_DISP_ANGLE_LIST or i == KEY_DISP_TOPANGLE_LIST or i == KEY_DISP_CLEAT_ANGLE_LIST:
with doc.create(Subsection("List of Input Section")):
# with doc.create(LongTable('|p{8cm}|p{8cm}|', row_height=1.2)) as table:
with doc.create(Tabularx('|p{4cm}|X|',
row_height=1.2)) as table:
table.add_hline()
table.add_row((
MultiColumn(
1,
align='|c|',
data=i,
),
MultiColumn(1,
align='|X|',
data=uiObj[i].strip("[]")),
))
# str_len = len(uiObj[i])
# loop_len = round_up((str_len/100),1,1)
# table.add_hline()
# for j in range(1,loop_len+1):
# b= 100*j+1
# if j ==1:
# table.add_row((MultiColumn(1, align='|c|', data=i, ),
# MultiColumn(1, align='|X|', data=uiObj[i][0:b]),))
# else:
# table.add_row((MultiColumn(1, align='|c|', data=" ", ),
# MultiColumn(1, align='|X|', data=uiObj[i][b-100:b]),))
table.add_hline()
doc.append(
pyl.Command('Needspace', arguments=NoEscape(r'10\baselineskip')))
doc.append(NewPage())
count = 0
with doc.create(Section('Design Checks')):
with doc.create(
Tabularx(
r'|>{\centering}p{12.5cm}|>{\centering\arraybackslash}X|',
row_height=1.2)) as table:
table.add_hline()
# Fail = TextColor("FailColor", bold("Fail"))
# Pass = TextColor("PassColor", bold("Pass"))
if does_design_exist != True:
table.add_row(bold('Design Status'),
color_cell("Red", bold("Fail")))
else:
table.add_row(bold('Design Status'),
color_cell("OsdagGreen", bold("Pass")))
table.add_hline()
for check in Design_Check:
if check[0] == 'SubSection':
if count >= 1:
# doc.append(NewPage())
doc.append(
pyl.Command(
'Needspace',
arguments=NoEscape(r'10\baselineskip')))
with doc.create(Subsection(check[1])):
#########################
# if uiObj== "WELDImage":
# table.add_hline()
# table.add_row((MultiColumn(5, align='|c|', data=bold(i), ),))
# table.add_hline()
# else:
#########################
with doc.create(LongTable(check[2], row_height=1.2)
) as table: # todo anjali remove
table.add_hline()
table.add_row(
('Check', 'Required', 'Provided', 'Remarks'),
color='OsdagGreen')
table.add_hline()
table.end_table_header()
table.add_hline()
count = count + 1
elif check[0] == "Selected":
if count >= 1:
# doc.append(NewPage())
doc.append(
pyl.Command(
'Needspace',
arguments=NoEscape(r'10\baselineskip')))
with doc.create(Subsection(check[1])):
with doc.create(LongTable(check[2],
row_height=1.2)) as table:
table.add_hline()
for i in uiObj:
# row_cells = ('9', MultiColumn(3, align='|c|', data='Multicolumn not on left'))
print(i)
if type(
uiObj[i]
) == dict and i == 'Selected Section Details':
table.add_hline()
sectiondetails = uiObj[i]
image_name = sectiondetails[
KEY_DISP_SEC_PROFILE]
Img_path = '/ResourceFiles/images/' + image_name + '.png'
if (len(sectiondetails)) % 2 == 0:
# merge_rows = int(round_up(len(sectiondetails),2)/2 + 2)
merge_rows = int(
round_up((len(sectiondetails) /
2), 1, 0) + 2)
else:
merge_rows = int(
round_up((len(sectiondetails) /
2), 1, 0) + 1)
print('Hi',
len(sectiondetails) / 2,
round_up(len(sectiondetails), 2) / 2,
merge_rows)
if (len(sectiondetails)) % 2 == 0:
sectiondetails[''] = ''
a = list(sectiondetails.keys())
# index=0
for x in range(1, (merge_rows + 1)):
# table.add_row("Col.Det.",i,columndetails[i])
if x == 1:
table.add_row((
MultiRow(
merge_rows,
data=StandAloneGraphic(
image_options=
"width=5cm,height=5cm",
filename=rel_path +
Img_path)),
MultiColumn(2,
align='|c|',
data=NoEscape(
a[x])),
MultiColumn(
2,
align='|c|',
data=NoEscape(
sectiondetails[a[x]])),
))
elif x <= 4:
table.add_row((
'',
MultiColumn(2,
align='|c|',
data=NoEscape(
a[x])),
MultiColumn(
2,
align='|c|',
data=sectiondetails[a[x]]),
))
else:
table.add_row((
'',
NoEscape(a[x]),
sectiondetails[a[x]],
NoEscape(a[merge_rows + x -
4]),
sectiondetails[a[merge_rows +
x - 4]],
))
table.add_hline(2, 5)
table.add_hline()
count = count + 1
else:
if check[3] == 'Fail':
table.add_row((NoEscape(check[0])), check[1], check[2],
TextColor("Red", bold(check[3])))
else:
table.add_row((NoEscape(check[0])), check[1], check[2],
TextColor("OsdagGreen", bold(check[3])))
table.add_hline()
# 2D images
if len(Disp_2d_image) != 0:
if module == KEY_DISP_BCENDPLATE or module == KEY_DISP_BB_EP_SPLICE:
if does_design_exist and sys.platform != 'darwin':
doc.append(NewPage())
weld_details = rel_path + Disp_2d_image[0]
detailing_details = rel_path + Disp_2d_image[1]
stiffener_details = rel_path + Disp_2d_image[2]
with doc.create(Section('2D Drawings (Typical)')):
with doc.create(Figure()) as image:
image.add_image(weld_details,
width=NoEscape(r'0.7\textwidth'),
placement=NoEscape(r'\centering'))
image.add_caption(
'Typical Weld Details -- Beam to End Plate Connection'
)
# doc.append(NewPage())
with doc.create(Figure()) as image_2:
image_2.add_image(
detailing_details,
width=NoEscape(r'0.7\textwidth'),
placement=NoEscape(r'\centering'))
image_2.add_caption('Typical Detailing')
# doc.append(NewPage())
with doc.create(Figure()) as image_3:
image_3.add_image(
stiffener_details,
width=NoEscape(r'0.9\textwidth'),
placement=NoEscape(r'\centering'))
image_3.add_caption('Typical Stiffener Details')
# doc.append(NewPage())
elif module == KEY_DISP_BASE_PLATE:
if does_design_exist and sys.platform != 'darwin':
doc.append(NewPage())
bp_sketch = rel_path + Disp_2d_image[0]
bp_detailing = rel_path + Disp_2d_image[1]
bp_weld = rel_path + Disp_2d_image[2]
bp_anchor = rel_path + Disp_2d_image[3]
bp_key = rel_path + Disp_2d_image[4]
with doc.create(Section('2D Drawings (Typical)')):
with doc.create(Figure()) as image_1:
image_1.add_image(
bp_sketch,
width=NoEscape(r'1.0\textwidth'),
placement=NoEscape(r'\centering'))
image_1.add_caption('Typical Base Plate Details')
# doc.append(NewPage())
with doc.create(Figure()) as image_2:
image_2.add_image(
bp_detailing,
width=NoEscape(r'1.0\textwidth'),
placement=NoEscape(r'\centering'))
image_2.add_caption('Typical Base Plate Detailing')
# doc.append(NewPage())
with doc.create(Figure()) as image_3:
image_3.add_image(
bp_weld,
width=NoEscape(r'1.0\textwidth'),
placement=NoEscape(r'\centering'))
image_3.add_caption('Typical Weld Details')
# doc.append(NewPage())
with doc.create(Figure()) as image_4:
image_4.add_image(
bp_anchor,
width=NoEscape(r'0.5\textwidth'),
placement=NoEscape(r'\centering'))
image_4.add_caption('Typical Anchor Bolt Details')
# doc.append(NewPage())
if len(Disp_2d_image[-1]) > 0:
with doc.create(Figure()) as image_5:
image_5.add_image(
bp_key,
width=NoEscape(r'0.9\textwidth'),
placement=NoEscape(r'\centering'))
image_5.add_caption(
'Typical Shear Key Details')
# doc.append(NewPage())
if does_design_exist and sys.platform != 'darwin':
doc.append(NewPage())
Disp_top_image = "/ResourceFiles/images/top.png"
Disp_side_image = "/ResourceFiles/images/side.png"
Disp_front_image = "/ResourceFiles/images/front.png"
view_3dimg_path = rel_path + Disp_3d_image
view_topimg_path = rel_path + Disp_top_image
view_sideimg_path = rel_path + Disp_side_image
view_frontimg_path = rel_path + Disp_front_image
with doc.create(Section('3D Views')):
with doc.create(
Tabularx(
r'|>{\centering}X|>{\centering\arraybackslash}X|',
row_height=1.2)) as table:
view_3dimg_path = rel_path + Disp_3d_image
view_topimg_path = rel_path + Disp_top_image
view_sideimg_path = rel_path + Disp_side_image
view_frontimg_path = rel_path + Disp_front_image
table.add_hline()
table.add_row([
StandAloneGraphic(image_options="height=4cm",
filename=view_3dimg_path),
StandAloneGraphic(image_options="height=4cm",
filename=view_topimg_path)
])
table.add_row('(a) 3D View', '(b) Top View')
table.add_hline()
table.add_row([
StandAloneGraphic(image_options="height=4cm",
filename=view_sideimg_path),
StandAloneGraphic(image_options="height=4cm",
filename=view_frontimg_path)
])
table.add_row('(c) Side View', '(d) Front View')
table.add_hline()
# with doc.create(Figure(position='h!')) as view_3D:
# view_3dimg_path = rel_path + Disp_3d_image
# # view_3D.add_image(filename=view_3dimg_path, width=NoEscape(r'\linewidth'))
#
# view_3D.add_image(filename=view_3dimg_path,width=NoEscape(r'\linewidth,height=6.5cm'))
#
# view_3D.add_caption('3D View')
with doc.create(Section('Design Log')):
doc.append(
pyl.Command('Needspace',
arguments=NoEscape(r'10\baselineskip')))
logger_msgs = reportsummary['logger_messages'].split('\n')
for msg in logger_msgs:
if ('WARNING' in msg):
colour = 'blue'
elif ('INFO' in msg):
colour = 'OsdagGreen'
elif ('ERROR' in msg):
colour = 'red'
else:
continue
doc.append(TextColor(colour, '\n' + msg))
try:
doc.generate_pdf(filename, compiler='pdflatex', clean_tex=False)
except:
pass
