예제 #1
0
파일: c.py 프로젝트: ccstuff/dam-course
def train(data):
    splits_dist = []
    for i, (X_train, X_test, y_train, y_test) in enumerate(load_train_test_split(data, n=3)):
        clfs = {}
        for name, group in X_train.groupby(main_bs_cols):
            group = util.drop(group, cols=['RNCID', 'CellID'])
            rf = RandomForestClassifier()
            rf.fit(group, y_train.loc[group.index][relaive_gps_cols].astype('int'))
            clfs[str(name)] = rf

        test_pred = pd.DataFrame(index=X_test.index, columns=relaive_gps_cols)
        for name, group in X_test.groupby(main_bs_cols):
            group = util.drop(group, cols=['RNCID', 'CellID'])
            group_test_pred = clfs[str(name)].predict(group)
            test_pred.loc[group.index] = group_test_pred

        test_pred['pred_longitude'] = test_pred[relaive_gps_cols[0]] / pow(10, 20) + X_test['Longitude_1']
        test_pred['pred_latitude'] = test_pred[relaive_gps_cols[1]] / pow(10, 20) + X_test['Latitude_1']

        split_dist = distance_evaluation(test_pred, y_test)
        splits_dist.append(split_dist)
    dist_df = X_test[main_bs_cols]
    dist = get_average_dist(splits_dist)
    dist_df['dist'] = dist
    pickle.dump(dist_df, open(params.c_errors_pkl, 'wb'))
예제 #2
0
def train(data):
    splits_dist = []
    top, dap = get_k_data()

    for i, (X_train, X_test, y_train,
            y_test) in enumerate(load_train_test_split(data, n=2)):
        print('Split:', i + 1)
        top_mr = []
        clfs = {}
        # get top-k data
        for name, group in X_train.groupby(main_bs_cols):
            if str(name) in top[:, 0]:
                top_mr = np.append(top_mr, group.index)
                print('top group:', len(group.index))
        top_data = X_train.loc[top_mr]

        #train
        for name, group in X_train.groupby(main_bs_cols):
            if str(name) in dap[:, 0]:
                print('dap group:', group.shape[0])
                group = pd.concat([group, top_data.iloc[:top_data.shape[0]]])
            group = util.drop(group, cols=['RNCID', 'CellID'])
            rf = RandomForestClassifier()
            rf.fit(group,
                   y_train.loc[group.index][relaive_gps_cols].astype('int'))
            clfs[str(name)] = rf

        #predict
        test_pred = pd.DataFrame(index=X_test.index, columns=relaive_gps_cols)
        for name, group in X_test.groupby(main_bs_cols):
            group = util.drop(group, cols=['RNCID', 'CellID'])
            group_test_pred = clfs[str(name)].predict(group)
            test_pred.loc[group.index] = group_test_pred

        test_pred['pred_longitude'] = test_pred['relative_longitude'] / pow(
            10, 20) + X_test['Longitude_1']
        test_pred['pred_latitude'] = test_pred['relative_latitude'] / pow(
            10, 20) + X_test['Latitude_1']

        split_dist = distance_evaluation(test_pred, y_test)
        splits_dist.append(split_dist)

    dist_df = X_test[main_bs_cols]
    dist = get_average_dist(splits_dist)
    dist_df['dist'] = dist
    pickle.dump(dist_df, open(params.d_errors_pkl, 'wb'))
예제 #3
0
def train(data):
    splits_dist = []
    dist_df = pickle.load(open(params.c_errors_pkl, 'rb'))
    for i, (X_train, X_test, y_train,
            y_test) in enumerate(load_train_test_split(data, n=2)):
        print('Split:', i + 1)
        clfs = {}
        #train
        dap, dap_mr = get_top_data(dist_df, X_train)
        dap = np.array(dap)[:, 0]
        for name, group in X_train.groupby(main_bs_cols):
            if str(name) in dap:
                print('before concat', group.shape)
                for n, g in X_train.groupby(['RNCID_1', 'CellID_1']):
                    if dap_mr[str(name)][(n[0] == dap_mr[str(name)]['RNCID_1'])
                                         & (n[1] == dap_mr[str(name)]
                                            ['CellID_1'])].shape[0]:
                        group = pd.concat([group, g])
                print('after concat', group.shape)
            group = util.drop(group, cols=['RNCID', 'CellID'])
            rf = RandomForestClassifier()
            rf.fit(group,
                   y_train.loc[group.index][relaive_gps_cols].astype('int'))
            clfs[str(name)] = rf

        test_pred = pd.DataFrame(index=X_test.index, columns=relaive_gps_cols)
        for name, group in X_test.groupby(main_bs_cols):
            group = util.drop(group, cols=['RNCID', 'CellID'])
            group_test_pred = clfs[str(name)].predict(group)
            test_pred.loc[group.index] = group_test_pred

        test_pred['pred_longitude'] = test_pred['relative_longitude'] / pow(
            10, 20) + X_test['Longitude_1']
        test_pred['pred_latitude'] = test_pred['relative_latitude'] / pow(
            10, 20) + X_test['Latitude_1']

        split_dist = util.distance_evaluation(test_pred, y_test)
        splits_dist.append(split_dist)

    dist_df = X_test[main_bs_cols]
    dist = get_average_dist(splits_dist)
    dist_df['dist'] = dist
    pickle.dump(dist_df, open(params.e_errors_pkl, 'wb'))
예제 #4
0
        split_dist = util.distance_evaluation(test_pred, y_test)
        splits_dist.append(split_dist)

    dist_df = X_test[main_bs_cols]
    dist = get_average_dist(splits_dist)
    dist_df['dist'] = dist
    pickle.dump(dist_df, open(params.e_errors_pkl, 'wb'))


if __name__ == '__main__':
    train_flag = 0
    if train_flag:
        data = util.generate(fillna_with_0=True)
        data = get_relative_pos(data)
        print(data[relaive_gps_cols].isnull())
        data = util.drop(data,
                         cols=['SignalLevel', 'AsuLevel', 'IMSI', 'MRTime'])
        train(data)
        plot(file=[params.c_errors_pkl, params.e_errors_pkl])
        plot_median_errors_comparison(file=[
            params.c_errors_pkl, params.d_errors_pkl, params.e_errors_pkl
        ])

    else:
        plot(file=[
            params.c_errors_pkl, params.d_errors_pkl, params.e_errors_pkl
        ])
        plot_median_errors_comparison(file=[
            params.c_errors_pkl, params.d_errors_pkl, params.e_errors_pkl
        ])
        # plot_median_errors_comparison(file=[, params.e_errors_pkl])
        # plot(params.c_errors_pkl)
예제 #5
0
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"))
예제 #6
0
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"))