def main():
config = get_config()
for key, value in config.items():
if key == 'pixel':
_is_pixel_ = value
if key == 'filename':
file_name = value
if key == 'outpath':
outpath = value
if key == 'tree':
if_tree = value
timer = time.time()
dcm = dcm_read(file_name)
print(dcm)
print('The reading of dcm file takes {} seconds'.format(time.time() -
timer))
"""
from dcmwrite import write
write(dcm,outpath='./',filename='write.dcm')
sys.exit()
"""
timer = time.time()
write_to_csv(dcm, outpath, file_name, _is_pixel_)
print('The writing to csv files takes {} seconds'.format(time.time() -
timer))
if if_tree:
from treeview import write_tree
timer = time.time()
write_tree(dcm, outpath, file_name)
print('The writing to treeview takes {} seconds'.format(time.time() -
timer))
def obtain_resource(id, filename=None):
# This function pulls information from a particular resource on a
# CKAN instance and outputs it to a CSV file.
# Tests suggest that there are some small differences between this
# file and the one downloaded directly through the CKAN web
# interface: 1) the row order is different (this version is ordered
# by _id (logically) while the downloaded version has the same weird
# order as that shown in the Data Explorer (which can have an _id
# sequence like 1,2,3,4,5,6,7,45,8,9,10... for no obvious reason)
# and 2) weird non-ASCII characters are not being handled optimally,
# so probably some work on character encoding is in order in the
# Python script.
if filename is None:
filename = "{}.csv".format(id)
list_of_dicts, fields, success = get_resource(DEFAULT_CKAN_INSTANCE,
id,
chunk_size=1000)
if not success:
print("Something went wrong and the resource was not obtained.")
else:
#Eliminate _id field
fields.remove("_id")
print("The resource has the following fields: {}".format(fields))
write_to_csv(filename, list_of_dicts, fields)
def processa_paises():
who_doctors, who_nurses = util.read_pais()
# remove duplicatas, deixando apenas os dados mais recentes
util.drop_pais_dupl(who_doctors, "Country")
util.drop_pais_dupl(who_nurses, "Country")
# cada bloco a seguir cria um atributo da tabela final
# a lista de paises nao eh igual entre os datasets
# para igualar, concatenamos e fazemos os ajustes pertinentes
nome = []
nome_aux = pd.concat([who_doctors["Country"], who_nurses["Country"]], join='inner', ignore_index=True)
nome_aux.drop_duplicates(inplace=True)
nome_series = nome_aux.reset_index() # reseta indices
nome_series.drop(["index"], axis=1, inplace=True) # remove indices antigos
for i in range(len(nome_series)):
nome.append(nome_series["Country"][i])
nome.sort(key=str.lower) # organiza em ordem alfabetica
med_total = util.match(nome, who_doctors, "Medical doctors (number)", "Country")
med_10k = util.match(nome, who_doctors, "Medical doctors (per 10 000 population)", "Country")
enf_total = util.match(nome, who_nurses, "Nursing and midwifery personnel (number)", "Country")
enf_10k = util.match(nome, who_nurses, "Nursing and midwifery personnel (per 10 000 population)", "Country")
dados = {'País': nome,
'Profissionais de enfermagem - Total': enf_total,
'Profissionais de enfermagem a cada 10k habitantes': enf_10k,
'Médicos - Total': med_total,
'Médicos a cada 10k habitantes': med_10k}
df = pd.DataFrame(data=dados)
util.write_to_csv(df, "Mundo (OMS)")
stats.stats_paises(pd.read_csv("../data/processed/Mundo (OMS).csv"))
"""
Script Runner: Executes nominations.py and films.py to extract all relevant information.
"""
import os
import csv
import util
import films
import nominations as noms
if __name__ == '__main__':
# Step 1: Extract award-nominated films from Wikipedia
with open('../data/inputs.csv', 'r') as inputs:
reader = csv.DictReader(inputs)
for row in reader:
util.write_to_csv('../data/nominations.csv',
noms.extract(row, min_year=1960, max_year=2016))
print("Nominations extracted.")
# Step 2: Extract film-specific information from Wikipedia, Box Office Mojo, Rotten Tomatoes, etc.
with open('../data/nominations.csv', 'r') as inputs:
reader = csv.DictReader(inputs)
visited = []
for row in reader:
row['href'] = "".join(['https://en.wikipedia.org', row['href']])
if row['film'] in visited:
continue
print row['year']
print "Context independence model.."
context_ind_model = model.Model(\
map(lambda x: (x[0], x[1], x[3]), reviews), util.parse_sentence)
context_ind_model.build_classifier(util.extract_features)
### Get Yelp data
crawler = crawler.Crawler()
yelp_data = crawler.get_yelp_data(\
'http://www.yelp.com/biz/5-napkin-burger-new-york')
print "Got", len(yelp_data), "yelp reviews"
yelp_sentences = []
for text in yelp_data:
yelp_sentences.extend(util.sentence_tokenize(text))
### Predict
predicted_factoids = factoid_model.predict(\
yelp_sentences, util.parse_sentence, util.extract_features)
predicted_context_independence = context_ind_model.predict(\
yelp_sentences, util.parse_sentence, util.extract_features)
yelp_sentences = map(lambda x: x.encode('utf-8'), yelp_sentences)
yelp_tagged = zip(yelp_sentences, predicted_factoids,\
predicted_context_independence)
### Write to csv
util.write_to_csv('yelp.predict.csv', yelp_tagged)
def processa_estados():
enf_uf, med_uf, hosp_uf, leitos_uf, uti_uf, uti_sus_uf, ibge_uf = util.read_uf_reg()
# troca "-" pelo valor 0 nas celulas em que aparece
util.dash_to_zero(enf_uf)
util.dash_to_zero(med_uf)
util.dash_to_zero(hosp_uf)
util.dash_to_zero(leitos_uf)
util.dash_to_zero(uti_uf)
util.dash_to_zero(uti_sus_uf)
# converte strings para valores numericos quando pertinente
util.str_to_int(enf_uf)
util.str_to_int(med_uf)
util.str_to_int(hosp_uf)
util.str_to_int(leitos_uf)
util.str_to_int(uti_uf)
util.str_to_int(uti_sus_uf)
# retira linhas com informacoes desnecessarias
util.drop(enf_uf, [-1, -1, -1])
util.drop(med_uf, [-1, -1, -1])
util.drop(hosp_uf, [-1, -1])
util.drop(leitos_uf, [-1, -1])
util.drop(uti_uf, [-1, -1])
util.drop(uti_sus_uf, [-1, -1, -1])
# cada bloco a seguir cria um atributo da tabela final
nome = enf_uf["Região/Unidade da Federação"]
# remove caracteres desnecessarios
for i in range(len(nome)):
nome[i] = nome[i].strip(". ")
pop = []
for item in ibge_uf["EST_POP_19"]:
pop.append(item)
# adiciona populacoes de cada regiao
pop.insert(0, sum(ibge_uf["EST_POP_19"][0:7])) # norte
pop.insert(8, sum(ibge_uf["EST_POP_19"][7:16])) # nordeste
pop.insert(18, sum(ibge_uf["EST_POP_19"][16:20])) # sudeste
pop.insert(23, sum(ibge_uf["EST_POP_19"][20:23])) # sul
pop.insert(27, sum(ibge_uf["EST_POP_19"][23:27])) # centro-oeste
enf_sus = enf_uf["Sim"]
enf_nsus = enf_uf["Não"]
enf_total = enf_uf["Total"]
enf_sus_percent = util.percent(enf_sus, enf_total)
enf_10k = util.pop_ratio(enf_total, 10000, pop)
med_sus = med_uf["Sim"]
med_nsus = med_uf["Não"]
med_total = med_uf["Total"]
med_sus_percent = util.percent(med_sus, med_total)
med_10k = util.pop_ratio(med_total, 10000, pop)
hosp_publ = []
for i in range(len(hosp_uf)):
hosp_publ.append(int(sum([hosp_uf["Administração Pública Federal"][i],
hosp_uf["Administração Pública Estadual ou Distrito Federal"][i],
hosp_uf["Administração Pública Municipal"][i],
hosp_uf["Administração Pública - Outros"][i],
hosp_uf["Empresa Pública ou Sociedade de Economia Mista"][i]])))
hosp_npubl = []
for i in range(len(hosp_uf)):
hosp_npubl.append(int(sum([hosp_uf["Demais Entidades Empresariais"][i],
hosp_uf["Entidades sem Fins Lucrativos"][i]])))
hosp_total = []
for i in range(len(hosp_uf)):
hosp_total.append(int(hosp_publ[i] + hosp_npubl[i]))
hosp_publ_percent = util.percent(hosp_publ, hosp_total)
hosp_100k = util.pop_ratio(hosp_total, 100000, pop)
leitos_sus = []
for i in range(len(leitos_uf)):
leitos_sus.append(int(leitos_uf["Quantidade SUS"][i]))
leitos_nsus = []
for i in range(len(leitos_uf)):
leitos_nsus.append(int(leitos_uf["Quantidade Não SUS"][i]))
leitos_total = []
for i in range(len(leitos_uf)):
leitos_total.append(int(leitos_sus[i] + leitos_nsus[i]))
leitos_sus_percent = util.percent(leitos_sus, leitos_total)
leitos_10k = util.pop_ratio(leitos_total, 10000, pop)
leitos_uti_total = []
for i in range(len(uti_uf)):
leitos_uti_total.append(int(uti_uf["Total"][i]))
leitos_uti_sus = uti_sus_uf["Total"]
leitos_uti_nsus = []
for i in range(len(leitos_uti_total)):
leitos_uti_nsus.append(int(leitos_uti_total[i] - leitos_uti_sus[i]))
leitos_uti_sus_percent = util.percent(leitos_uti_sus, leitos_uti_total)
leitos_uti_10k = util.pop_ratio(leitos_uti_total, 10000, pop)
leitos_covid_total = []
for i in range(len(uti_uf)):
leitos_covid_total.append(int(uti_uf["UTI adulto II COVID-19"][i] +
uti_uf["UTI pediátrica II COVID-19"][i]))
leitos_covid_sus = []
for i in range(len(uti_sus_uf)):
leitos_covid_sus.append(int(uti_sus_uf["UTI adulto II COVID-19"][i] +
uti_sus_uf["UTI pediátrica II COVID-19"][i]))
leitos_covid_nsus = []
for i in range(len(leitos_covid_total)):
leitos_covid_nsus.append(int(leitos_covid_total[i] - leitos_covid_sus[i]))
leitos_covid_sus_percent = util.percent(leitos_covid_sus, leitos_covid_total)
leitos_covid_10k = util.pop_ratio(leitos_covid_total, 10000, pop)
# deficit ou excesso de profissionais de saude no estado ou regiao
# em relacao a densidade populacional
# considerando referencia oms (health workforce requirements, 2016)
# recomendado = 44.5 medicos/enfs a cada 10k habitantes
rel_prof_saude_recomend = []
recomend = 44.5
for i in range(len(enf_total)):
med_e_enf_10k = med_10k[i] + enf_10k[i]
dfca = med_e_enf_10k - recomend # valor pos indica excesso; valor neg indica deficit
rel_prof_saude_recomend.append(round((dfca*pop[i])/10000, 2))
dados = {'Região ou UF': nome,
'População': pop,
'Enfermeiros SUS': enf_sus,
'Enfermeiros não-SUS': enf_nsus,
'Enfermeiros - Total': enf_total,
'%' + ' de enfermeiros SUS': enf_sus_percent,
'Enfermeiros a cada 10k habitantes': enf_10k,
'Médicos SUS': med_sus,
'Médicos não-SUS': med_nsus,
'Médicos - Total': med_total,
'%' + ' de médicos SUS': med_sus_percent,
'Médicos a cada 10k habitantes': med_10k,
'Déficit ou excesso de médicos/enfermeiros': rel_prof_saude_recomend,
'Hospitais públicos': hosp_publ,
'Hospitais não-públicos': hosp_npubl,
'Hospitais - Total': hosp_total,
'%' + ' de hospitais públicos': hosp_publ_percent,
'Hospitais a cada 100k habitantes': hosp_100k,
'Leitos (internação) SUS': leitos_sus,
'Leitos (internação) não-SUS': leitos_nsus,
'Leitos (internação) - Total': leitos_total,
'%' + ' de leitos (internação) SUS': leitos_sus_percent,
'Leitos (internação) a cada 10k habitantes': leitos_10k,
'Leitos UTI SUS': leitos_uti_sus,
'Leitos UTI não-SUS': leitos_uti_nsus,
'Leitos UTI - Total': leitos_uti_total,
'%' + ' de leitos UTI SUS': leitos_uti_sus_percent,
'Leitos UTI a cada 10k habitantes': leitos_uti_10k,
'Leitos UTI COVID-19 SUS': leitos_covid_sus,
'Leitos UTI COVID-19 não-SUS': leitos_covid_nsus,
'Leitos UTI COVID-19 - Total': leitos_covid_total,
'%' + ' de leitos UTI COVID-19 SUS': leitos_covid_sus_percent,
'Leitos UTI COVID-19 a cada 10k habitantes': leitos_covid_10k}
df = pd.DataFrame(data=dados)
util.write_to_csv(df, "Brasil - UFs e Regiões")
stats.stats_estados(pd.read_csv("../data/processed/Brasil - UFs e Regiões.csv"))
def train(model: StringNet,
train_data,
val_data=None,
lr=1e-4,
epochs=100,
log_path: str = None,
save_path: str = None,
verbose: bool = False) -> List[Dict[str, Any]]:
# TODO: Early stopping
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
floss = loss_func()
history = []
batch_timer = Timer()
epoch_timer = Timer()
total_batches = len(train_data)
for epoch in range(epochs):
model.train()
epoch_timer.start()
batch_timer.reset()
total_loss = num_samples = total_distance = total_accuracy = 0
dummy_images = dummy_batch_targets = None
for batch_num, (image, str_targets) in enumerate(train_data):
batch_timer.start()
# string to individual ints
int_targets = [[int(c) for c in gt] for gt in str_targets]
# Prepare image
image = image.to(device)
# Forward
optimizer.zero_grad()
output = model(image)
loss = apply_ctc_loss(floss, output, int_targets)
# Backward
loss.backward(torch.ones_like(loss.data))
# Update
optimizer.step()
distances = calc_lv_dist(output, str_targets)
total_distance += sum(distances)
accuracy = calc_acc(output, str_targets)
total_accuracy += sum(accuracy)
total_loss += loss.sum().item()
num_samples += len(str_targets)
if verbose:
dummy_images = image
dummy_batch_targets = str_targets
batch_timer.stop()
if batch_num % 10 == 0:
print(batch_timer.format_status(num_total=total_batches -
batch_num) + 20 * " ",
end='\r',
flush=True)
epoch_timer.stop()
if verbose:
print("Train examples: ")
print(
model(dummy_images).argmax(2)[:, :10],
dummy_batch_targets[:10])
if val_data is not None:
val_results = test(model, val_data, verbose)
else:
val_results = {}
history_item = {}
history_item['epoch'] = epoch + 1
history_item['avg_dist'] = total_distance / num_samples
history_item['avg_loss'] = total_loss / num_samples
history_item['accuracy'] = total_accuracy / num_samples
history_item['time'] = epoch_timer.last()
history_item.update(
{"val_" + key: value
for key, value in val_results.items()})
history.append(history_item)
status_line = format_status_line(history_item)
print(status_line)
if log_path is not None:
write_to_csv(history_item,
log_path,
write_header=epoch == 0,
append=epoch != 0)
if save_path is not None:
torch.save(model, save_path)
return history
def processa_municipios():
enf_mun, med_mun, hosp_mun, leitos_mun, uti_mun, uti_sus_mun, ibge_mun = util.read_mun()
# troca "-" pelo valor 0 nas celulas em que aparece
util.dash_to_zero(enf_mun)
util.dash_to_zero(med_mun)
util.dash_to_zero(hosp_mun)
util.dash_to_zero(leitos_mun)
util.dash_to_zero(uti_mun)
util.dash_to_zero(uti_sus_mun)
# converte strings para valores numericos quando pertinente
util.str_to_int(enf_mun)
util.str_to_int(med_mun)
util.str_to_int(hosp_mun)
util.str_to_int(leitos_mun)
util.str_to_int(uti_mun)
util.str_to_int(uti_sus_mun)
# retira linhas com informacoes desnecessarias
util.drop(enf_mun, [-1, -1, -1])
util.drop(med_mun, [-1, -1, -1])
util.drop(hosp_mun, [-1, -1, -1])
util.drop(leitos_mun, [-1, -1, -1])
util.drop(uti_mun, [-1, -1, -1])
util.drop(uti_sus_mun, [-1, -1, -1])
util.drop_mun(enf_mun)
util.drop_mun(med_mun)
util.drop_mun(hosp_mun)
util.drop_mun(leitos_mun)
util.drop_mun(uti_mun)
util.drop_mun(uti_sus_mun)
# adiciona informacao sobre sigla correspondente a cada codigo uf
siglas_uf = util.cod_to_uf(ibge_mun)
ibge_mun["NM_UF"] = siglas_uf
# remove ultimo digito do codigo municipal do dataset do ibge
# o objetivo eh igualar ao codigo municipal dos datasets do datasus
for i in range(len(ibge_mun)):
ibge_mun.at[i, "CD_MUN"] = ibge_mun["CD_MUN"][i]//10
# cada bloco a seguir cria um atributo da tabela final
cod = []
for i in range(len(enf_mun)):
cod.append(int(enf_mun["Município"][i][0:7])) # primeiros seis digitos
nome = []
for i in range(len(enf_mun)):
nome.append(enf_mun["Município"][i][7:]) # todos os digitos menos 7 primeiros (6 do codigo + espaco)
pop = []
# insere na ordem dos datasets do datasus
for i in range(len(cod)):
# pop_cod = populacao registrada para a linha em que cd_mun == cod[i]
pop_cod = ibge_mun["EST_POP_19"][ibge_mun["CD_MUN"] == cod[i]].iloc[0]
pop.append(pop_cod)
uf = []
# insere na ordem dos datasets do datasus
for i in range(len(cod)):
# uf_cod = sigla da uf registrada para a linha em que cd_mun == cod[i]
uf_cod = ibge_mun["NM_UF"][ibge_mun["CD_MUN"] == cod[i]].iloc[0]
uf.append(uf_cod)
enf_sus = enf_mun["Sim"]
enf_nsus = enf_mun["Não"]
enf_total = enf_mun["Total"]
enf_sus_percent = util.percent(enf_sus, enf_total)
enf_10k = util.pop_ratio(enf_total, 10000, pop)
med_sus = med_mun["Sim"]
med_nsus = med_mun["Não"]
med_total = med_mun["Total"]
med_sus_percent = util.percent(med_sus, med_total)
med_10k = util.pop_ratio(med_total, 10000, pop)
hosp_publ = []
for i in range(len(hosp_mun)):
hosp_publ.append(int(sum([hosp_mun["Administração Pública Federal"][i],
hosp_mun["Administração Pública Estadual ou Distrito Federal"][i],
hosp_mun["Administração Pública Municipal"][i],
hosp_mun["Administração Pública - Outros"][i],
hosp_mun["Empresa Pública ou Sociedade de Economia Mista"][i]])))
hosp_npubl = []
for i in range(len(hosp_mun)):
hosp_npubl.append(int(sum([hosp_mun["Demais Entidades Empresariais"][i],
hosp_mun["Entidades sem Fins Lucrativos"][i]])))
hosp_total = []
for i in range(len(hosp_mun)):
hosp_total.append(int(hosp_publ[i] + hosp_npubl[i]))
hosp_publ_percent = util.percent(hosp_publ, hosp_total)
hosp_100k = util.pop_ratio(hosp_total, 100000, pop)
leitos_sus = leitos_mun["Quantidade SUS"]
leitos_nsus = leitos_mun["Quantidade Não SUS"]
leitos_total = []
for i in range(len(leitos_mun)):
leitos_total.append(int(leitos_sus[i] + leitos_nsus[i]))
leitos_sus_percent = util.percent(leitos_sus, leitos_total)
leitos_10k = util.pop_ratio(leitos_total, 10000, pop)
leitos_uti_total = uti_mun["Total"]
leitos_uti_sus = uti_sus_mun["Total"]
leitos_uti_nsus = []
for i in range(len(leitos_uti_total)):
leitos_uti_nsus.append(int(leitos_uti_total[i] - leitos_uti_sus[i]))
leitos_uti_sus_percent = util.percent(leitos_uti_sus, leitos_uti_total)
leitos_uti_10k = util.pop_ratio(leitos_uti_total, 10000, pop)
leitos_covid_total = []
for i in range(len(uti_mun)):
leitos_covid_total.append(int(uti_mun["UTI adulto II COVID-19"][i] +
uti_mun["UTI pediátrica II COVID-19"][i]))
leitos_covid_sus = []
for i in range(len(uti_sus_mun)):
leitos_covid_sus.append(int(uti_sus_mun["UTI adulto II COVID-19"][i] +
uti_sus_mun["UTI pediátrica II COVID-19"][i]))
leitos_covid_nsus = []
for i in range(len(leitos_covid_total)):
leitos_covid_nsus.append(int(leitos_covid_total[i] - leitos_covid_sus[i]))
leitos_covid_sus_percent = util.percent(leitos_covid_sus, leitos_covid_total)
leitos_covid_10k = util.pop_ratio(leitos_covid_total, 10000, pop)
# deficit ou excesso de profissionais de saude no municipio
# em relacao a densidade populacional
# considerando referencia oms (health workforce requirements, 2016)
# recomendado = 44.5 medicos/enfs a cada 10k habitantes
rel_prof_saude_recomend = []
recomend = 44.5
for i in range(len(enf_total)):
med_e_enf_10k = med_10k[i] + enf_10k[i]
dfca = med_e_enf_10k - recomend # valor pos indica excesso; valor neg indica deficit
rel_prof_saude_recomend.append(round((dfca*pop[i])/10000, 2))
dados = {'Código Municipal': cod,
'Município': nome,
'População': pop,
'UF': uf,
'Enfermeiros SUS': enf_sus,
'Enfermeiros não-SUS': enf_nsus,
'Enfermeiros - Total': enf_total,
'%' + ' de enfermeiros SUS': enf_sus_percent,
'Enfermeiros a cada 10k habitantes': enf_10k,
'Médicos SUS': med_sus,
'Médicos não-SUS': med_nsus,
'Médicos - Total': med_total,
'%' + ' de médicos SUS': med_sus_percent,
'Médicos a cada 10k habitantes': med_10k,
'Déficit ou excesso de médicos/enfermeiros': rel_prof_saude_recomend,
'Hospitais públicos': hosp_publ,
'Hospitais não-públicos': hosp_npubl,
'Hospitais - Total': hosp_total,
'%' + ' de hospitais públicos': hosp_publ_percent,
'Hospitais a cada 100k habitantes': hosp_100k,
'Leitos (internação) SUS': leitos_sus,
'Leitos (internação) não-SUS': leitos_nsus,
'Leitos (internação) - Total': leitos_total,
'%' + ' de leitos (internação) SUS': leitos_sus_percent,
'Leitos (internação) a cada 10k habitantes': leitos_10k,
'Leitos UTI SUS': leitos_uti_sus,
'Leitos UTI não-SUS': leitos_uti_nsus,
'Leitos UTI - Total': leitos_uti_total,
'%' + ' de leitos UTI SUS': leitos_uti_sus_percent,
'Leitos UTI a cada 10k habitantes': leitos_uti_10k,
'Leitos UTI COVID-19 SUS': leitos_covid_sus,
'Leitos UTI COVID-19 não-SUS': leitos_covid_nsus,
'Leitos UTI COVID-19 - Total': leitos_covid_total,
'%' + ' de leitos UTI COVID-19 SUS': leitos_covid_sus_percent,
'Leitos UTI COVID-19 a cada 10k habitantes': leitos_covid_10k}
df = pd.DataFrame(data=dados)
util.write_to_csv(df, "Brasil - Municípios")
stats.stats_municipios(pd.read_csv("../data/processed/Brasil - Municípios.csv"))