###################################################################################### # # #Ideologia e Partidos no Brasil: reflexão e prática a partir dos programas de governo# # # ###################################################################################### #Limpa o ambiente à direita para começar as atividades rm(list = ls()) #Instala pacotes para a análise (É necessário instalar apenas uma vez. Depois, colocar "#" no início de cada linha) install.packages("quanteda", dependencies = TRUE) #Para a análise automatizada de texto install.packages("ggplot2", dependencies = TRUE) #Para a construção de gráficos install.packages("quanteda.textmodels", dependencies = TRUE) #Para aplicar os textos a modelos install.packages("RColorBrewer", dependencies = TRUE) #Para escalas de cores dos gráficos #Abre os pacotes instalados library(quanteda) library(ggplot2) library(quanteda.textmodels) library(RColorBrewer) #Indica o diretório onde está o banco de dados setwd("C:\\Users\\Desktop\\publicações\\política hoje\\dados") #Trocar endereço entre parêntese para a pasta onde armazenou o banco, usando barras duplas e aspas #Abre o banco de dados com os programas de governo progs <- readRDS("programas.rds") #Cria corpus a partir do banco de dados corpus <- corpus(progs, docid_field = "doc", text_field = "texto", meta = list(), unique_docnames = TRUE) #Conta número de tokens por nível tokeninfo <- summary(corpus, n = 889) #Faz gráfico com número de tokens (Gráfico 2) ggplot(data = tokeninfo, aes(x = partido, y = Tokens, shape = nivel, color = nivel)) + geom_point() + xlab(" ") + scale_color_brewer(palette="Dark2") ###############Parte 1 - Termos mais frequentes por nível e ideologia #######Eleições presidenciais #Cria corpus apenas com programas presidenciais cbr <- corpus_subset(corpus, nivel == "BR") #Conta documentos por partido no nível presidencial (Coluna 1 da Tabela 1) pfreqbr <- as.data.frame(table(cbr$partido)) pfreqbr #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tbr <- quanteda::tokens(cbr, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tbr <- tokens_remove(tbr, stopwords("portuguese")) tbr <- tokens_remove(tbr, "programa") #Transforma tokens em stems tbr <- tokens_wordstem(tbr, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmbr <- dfm(tbr, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmbr <- dfm_select(dfmbr, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmbr <- dfm_select(dfmbr, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nas disputas presidenciais (Coluna "Total" da Tabela 2) tfreqbr<- textstat_frequency(dfmbr, n = 20) head(tfreqbr, 20) #Cria novo corpus, apenas com programas presidenciais de partidos de direita cbrD <- corpus_subset(cbr, ideologia == "DIREITA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tbrD <- quanteda::tokens(cbrD, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tbrD <- tokens_remove(tbrD, stopwords("portuguese")) tbrD <- tokens_remove(tbrD, "programa") #Transforma tokens em stems tbrD <- tokens_wordstem(tbrD, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmbrD <- dfm(tbrD, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmbrD <- dfm_select(dfmbrD, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmbrD <- dfm_select(dfmbrD, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de direita nas disputas presidenciais (Coluna "Direita" da Tabela 2) tfreqbrD <- textstat_frequency(dfmbrD, n = 20) head(tfreqbrD, 20) #Cria novo corpus, apenas com programas presidenciais de partidos de centro cbrC <- corpus_subset(cbr, ideologia == "CENTRO") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tbrC <- quanteda::tokens(cbrC, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tbrC <- tokens_remove(tbrC, stopwords("portuguese")) tbrC <- tokens_remove(tbrC, "programa") #Transforma tokens em stems tbrC <- tokens_wordstem(tbrC, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmbrC <- dfm(tbrC, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmbrC <- dfm_select(dfmbrC, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmbrC <- dfm_select(dfmbrC, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de direita nas disputas presidenciais (Coluna "Centro" da Tabela 2) tfreqbrC <- textstat_frequency(dfmbrC, n = 20) head(tfreqbrC, 20) #Cria novo corpus, apenas com programas presidenciais de partidos de esquerda cbrE <- corpus_subset(cbr, ideologia == "ESQUERDA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tbrE <- quanteda::tokens(cbrE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tbrE <- tokens_remove(tbrE, stopwords("portuguese")) tbrE <- tokens_remove(tbrE, "programa") #Transforma tokens em stems tbrE <- tokens_wordstem(tbrE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmbrE <- dfm(tbrE, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmbrE <- dfm_select(dfmbrE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmbrE <- dfm_select(dfmbrE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de esquerda nas disputas presidenciais (Coluna "Esquerda" da Tabela 2) tfreqbrE <- textstat_frequency(dfmbrE, n = 20) head(tfreqbrE, 20) #######Eleições estaduais #Cria corpus apenas com programas estaduais cuf <- corpus_subset(corpus, nivel == "UF") #Conta documentos por partido no nível estadual (Coluna 2 da Tabela 1) pfrequf <- as.data.frame(table(cuf$partido)) pfrequf #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tuf <- quanteda::tokens(cuf, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tuf <- tokens_remove(tuf, stopwords("portuguese")) tuf <- tokens_remove(tuf, "programa") #Transforma tokens em stems tuf <- tokens_wordstem(tuf, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmuf <- dfm(tuf, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmuf <- dfm_select(dfmuf, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmuf <- dfm_select(dfmuf, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nas disputas presidenciais (Coluna "Total" da Tabela 3) tfrequf<- textstat_frequency(dfmuf, n = 20) head(tfrequf, 20) #Cria novo corpus, apenas com programas estaduais de partidos de direita cufD <- corpus_subset(cuf, ideologia == "DIREITA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tufD <- quanteda::tokens(cufD, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tufD <- tokens_remove(tufD, stopwords("portuguese")) tufD <- tokens_remove(tufD, "programa") #Transforma tokens em stems tufD <- tokens_wordstem(tufD, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmufD <- dfm(tufD, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmufD <- dfm_select(dfmufD, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmufD <- dfm_select(dfmufD, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de direita nas disputas estaduais (Coluna "Direita" da Tabela 3) tfrequfD <- textstat_frequency(dfmufD, n = 20) head(tfrequfD, 20) #Cria novo corpus, apenas com programas estaduais de partidos de centro cufC <- corpus_subset(cuf, ideologia == "CENTRO") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tufC <- quanteda::tokens(cufC, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tufC <- tokens_remove(tufC, stopwords("portuguese")) tufC <- tokens_remove(tufC, "programa") #Transforma tokens em stems tufC <- tokens_wordstem(tufC, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmufC <- dfm(tufC, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmufC <- dfm_select(dfmufC, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmufC <- dfm_select(dfmufC, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de direita nas disputas estaduais (Coluna "Centro" da Tabela 3) tfrequfC <- textstat_frequency(dfmufC, n = 20) head(tfrequfC, 20) #Cria novo corpus, apenas com programas estaduais de partidos de esquerda cufE <- corpus_subset(cuf, ideologia == "ESQUERDA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tufE <- quanteda::tokens(cufE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tufE <- tokens_remove(tufE, stopwords("portuguese")) tufE <- tokens_remove(tufE, "programa") #Transforma tokens em stems tufE <- tokens_wordstem(tufE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmufE <- dfm(tufE, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmufE <- dfm_select(dfmufE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmufE <- dfm_select(dfmufE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de esquerda nas disputas estaduais (Coluna "Esquerda" da Tabela 3) tfrequfE <- textstat_frequency(dfmufE, n = 20) head(tfrequfE, 20) #######Eleições municipais #Cria corpus apenas com programas municipais cmun <- corpus_subset(corpus, nivel == "MUN") #Conta documentos por partido no nível municipal (Coluna 3 da Tabela 1) pfreqmun <- as.data.frame(table(cmun$partido)) pfreqmun #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tmun <- quanteda::tokens(cmun, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tmun <- tokens_remove(tmun, stopwords("portuguese")) tmun <- tokens_remove(tmun, "programa") #Transforma tokens em stems tmun <- tokens_wordstem(tmun, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmmun <- dfm(tmun, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmmun <- dfm_select(dfmmun, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmmun <- dfm_select(dfmmun, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nas disputas municipais (Coluna "Total" da Tabela 4) tfreqmun<- textstat_frequency(dfmmun, n = 20) head(tfreqmun, 20) #Cria novo corpus, apenas com programas municipais de partidos de direita cmunD <- corpus_subset(cmun, ideologia == "DIREITA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tmunD <- quanteda::tokens(cmunD, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tmunD <- tokens_remove(tmunD, stopwords("portuguese")) tmunD <- tokens_remove(tmunD, "programa") #Transforma tokens em stems tmunD <- tokens_wordstem(tmunD, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmmunD <- dfm(tmunD, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmmunD <- dfm_select(dfmmunD, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmmunD <- dfm_select(dfmmunD, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de direita nas disputas municipais (Coluna "Direita" da Tabela 4) tfreqmunD <- textstat_frequency(dfmmunD, n = 20) head(tfreqmunD, 20) #Cria novo corpus, apenas com programas municipais de partidos de centro cmunC <- corpus_subset(cmun, ideologia == "CENTRO") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tmunC <- quanteda::tokens(cmunC, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tmunC <- tokens_remove(tmunC, stopwords("portuguese")) tmunC <- tokens_remove(tmunC, "programa") #Transforma tokens em stems tmunC <- tokens_wordstem(tmunC, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmmunC <- dfm(tmunC, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmmunC <- dfm_select(dfmmunC, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmmunC <- dfm_select(dfmmunC, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de direita nas disputas municipais, desconsiderando letras isoladas (Coluna "Centro" da Tabela 4) tfreqmunC <- textstat_frequency(dfmmunC, n = 22) head(tfreqmunC, 22) #Cria novo corpus, apenas com programas municipais de partidos de esquerda cmunE <- corpus_subset(cmun, ideologia == "ESQUERDA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tmunE <- quanteda::tokens(cmunE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tmunE <- tokens_remove(tmunE, stopwords("portuguese")) tmunE <- tokens_remove(tmunE, "programa") #Transforma tokens em stems tmunE <- tokens_wordstem(tmunE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmmunE <- dfm(tmunE, tolower = TRUE) #Remove caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos dfmmunE <- dfm_select(dfmmunE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmmunE <- dfm_select(dfmmunE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") #Mostra 20 termos mais frequentes nos programas de esquerda nas disputas municipais (Coluna "Esquerda" da Tabela 4) tfreqmunE <- textstat_frequency(dfmmunE, n = 20) head(tfreqmunE, 20) ###############Parte 2 - Roda o wordfish #######Eleições presidenciais #Retira da matriz termos com frequência menor que 2 x o número de documentos dfmbr <- dfm_trim(dfmbr, min_termfreq = 66, termfreq_type = "count") #Roda o wordfish tmod_wfbr <- textmodel_wordfish(dfmbr) wfbr <- predict(tmod_wfbr, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico (Gráfico 3) textplot_scale1d(tmod_wfbr, doclabels = dfmbr$partano) #######Eleições estaduais + municipais por UF ####Acre #Cria corpus com programas estaduais cAC <- corpus_subset(corpus, local == "AC") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tAC <- quanteda::tokens(cAC, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tAC <- tokens_remove(tAC, stopwords("portuguese")) tAC <- tokens_remove(tAC, c("programa")) #Transforma tokens em stems tAC <- tokens_wordstem(tAC, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmAC <- dfm(tAC, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmAC <- dfm_select(dfmAC, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmAC <- dfm_select(dfmAC, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmAC <- dfm_trim(dfmAC, min_termfreq = 24, termfreq_type = "count") #Roda o wordfish tmod_wfAC <- textmodel_wordfish(dfmAC) wfAC <- predict(tmod_wfAC, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 4) textplot_scale1d(tmod_wfAC, doclabels = dfmAC$partano, groups = docvars(dfmAC, "ideologia")) #Cria corpus com programas da capital cCAC <- corpus_subset(corpus, local == "Rio Branco") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCAC <- quanteda::tokens(cCAC, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCAC <- tokens_remove(tCAC, stopwords("portuguese")) tCAC <- tokens_remove(tCAC, c("programa")) #Transforma tokens em stems tCAC <- tokens_wordstem(tCAC, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCAC <- dfm(tCAC, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCAC <- dfm_select(dfmCAC, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCAC <- dfm_select(dfmCAC, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCAC <- dfm_trim(dfmCAC, min_termfreq = 18, termfreq_type = "count") #Roda o wordfish tmod_wfCAC <- textmodel_wordfish(dfmCAC) wfCAC <- predict(tmod_wfCAC, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 4) textplot_scale1d(tmod_wfCAC, doclabels = dfmCAC$partano, groups = docvars(dfmCAC, "ideologia")) ####Alagoas #Cria corpus com programas estaduais cAL <- corpus_subset(corpus, locAL == "AL") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tAL <- quanteda::tokens(cAL, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tAL <- tokens_remove(tAL, stopwords("portuguese")) tAL <- tokens_remove(tAL, c("programa")) #Transforma tokens em stems tAL <- tokens_wordstem(tAL, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmAL <- dfm(tAL, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmAL <- dfm_select(dfmAL, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmAL <- dfm_select(dfmAL, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmAL <- dfm_trim(dfmAL, min_termfreq = 14, termfreq_type = "count") #Roda o wordfish tmod_wfAL <- textmodel_wordfish(dfmAL) wfAL <- predict(tmod_wfAL, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 5) textplot_scale1d(tmod_wfAL, doclabels = dfmAL$partano, groups = docvars(dfmAL, "ideologia")) ##Cria corpus com programas da capital cCAL <- corpus_subset(corpus, local == "Maceio") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCAL <- quanteda::tokens(cCAL, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCAL <- tokens_remove(tCAL, stopwords("portuguese")) tCAL <- tokens_remove(tCAL, c("programa")) #Transforma tokens em stems tCAL <- tokens_wordstem(tCAL, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCAL <- dfm(tCAL, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCAL <- dfm_select(dfmCAL, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCAL <- dfm_select(dfmCAL, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCAL <- dfm_trim(dfmCAL, min_termfreq = 32, termfreq_type = "count") #Roda o wordfish tmod_wfCAL <- textmodel_wordfish(dfmCAL) wfCAL <- predict(tmod_wfCAL, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 5) textplot_scale1d(tmod_wfCAL, doclabels = dfmCAL$partano, groups = docvars(dfmCAL, "ideologia")) ####Amapá ##Cria corpus com programas estaduais cAP <- corpus_subset(corpus, local == "AP") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tAP <- quanteda::tokens(cAP, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tAP <- tokens_remove(tAP, stopwords("portuguese")) tAP <- tokens_remove(tAP, c("programa")) #Transforma tokens em stems tAP <- tokens_wordstem(tAP, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmAP <- dfm(tAP, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmAP <- dfm_select(dfmAP, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmAP <- dfm_select(dfmAP, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmAP <- dfm_trim(dfmAP, min_termfreq = 14, termfreq_type = "count") #Roda o wordfish tmod_wfAP <- textmodel_wordfish(dfmAP) wfAP <- predict(tmod_wfAP, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 6) textplot_scale1d(tmod_wfAP, doclabels = dfmAP$partano, groups = docvars(dfmAP, "ideologia")) #Cria corpus com programas da capital cCAP <- corpus_subset(corpus, local == "Macapa") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCAP <- quanteda::tokens(cCAP, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCAP <- tokens_remove(tCAP, stopwords("portuguese")) tCAP <- tokens_remove(tCAP, c("programa")) #Transforma tokens em stems tCAP <- tokens_wordstem(tCAP, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCAP <- dfm(tCAP, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCAP <- dfm_select(dfmCAP, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCAP <- dfm_select(dfmCAP, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCAP <- dfm_trim(dfmCAP, min_termfreq = 28, termfreq_type = "count") #Roda o wordfish tmod_wfCAP <- textmodel_wordfish(dfmCAP) wfCAP <- predict(tmod_wfCAP, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 6) textplot_scale1d(tmod_wfCAP, doclabels = dfmCAP$partano, groups = docvars(dfmCAP, "ideologia")) ####Amazonas #Cria corpus com programas estaduais cAM <- corpus_subset(corpus, local == "AM") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tAM <- quanteda::tokens(cAM, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tAM <- tokens_remove(tAM, stopwords("portuguese")) tAM <- tokens_remove(tAM, c("programa")) #Transforma tokens em stems tAM <- tokens_wordstem(tAM, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmAM <- dfm(tAM, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmAM <- dfm_select(dfmAM, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmAM <- dfm_select(dfmAM, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmAM <- dfm_trim(dfmAM, min_termfreq = 36, termfreq_type = "count") #Roda o wordfish tmod_wfAM <- textmodel_wordfish(dfmAM) wfAM <- predict(tmod_wfAM, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 7) textplot_scale1d(tmod_wfAM, doclabels = dfmAM$partano, groups = docvars(dfmAM, "ideologia")) ##Cria corpus com programas da capital cCAM <- corpus_subset(corpus, local == "Manaus") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCAM <- quanteda::tokens(cCAM, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCAM <- tokens_remove(tCAM, stopwords("portuguese")) tCAM <- tokens_remove(tCAM, c("programa")) #Transforma tokens em stems tCAM <- tokens_wordstem(tCAM, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCAM <- dfm(tCAM, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCAM <- dfm_select(dfmCAM, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCAM <- dfm_select(dfmCAM, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCAM <- dfm_trim(dfmCAM, min_termfreq = 36, termfreq_type = "count") #Roda o wordfish tmod_wfCAM <- textmodel_wordfish(dfmCAM) wfCAM <- predict(tmod_wfCAM, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 7) textplot_scale1d(tmod_wfCAM, doclabels = dfmCAM$partano, groups = docvars(dfmCAM, "ideologia")) ####Bahia #Cria corpus com programas estaduais cBA <- corpus_subset(corpus, local == "BA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tBA <- quanteda::tokens(cBA, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tBA <- tokens_remove(tBA, stopwords("portuguese")) tBA <- tokens_remove(tBA, c("programa")) #Transforma tokens em stems tBA <- tokens_wordstem(tBA, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmBA <- dfm(tBA, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmBA <- dfm_select(dfmBA, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmBA <- dfm_select(dfmBA, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmBA <- dfm_trim(dfmBA, min_termfreq = 38, termfreq_type = "count") #Roda o wordfish tmod_wfBA <- textmodel_wordfish(dfmBA) wfBA <- predict(tmod_wfBA, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 8) textplot_scale1d(tmod_wfBA, doclabels = dfmBA$partano, groups = docvars(dfmBA, "ideologia")) ##Cria corpus com programas da capital cCBA <- corpus_subset(corpus, local == "Salvador") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCBA <- quanteda::tokens(cCBA, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCBA <- tokens_remove(tCBA, stopwords("portuguese")) tCBA <- tokens_remove(tCBA, c("programa")) #Transforma tokens em stems tCBA <- tokens_wordstem(tCBA, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCBA <- dfm(tCBA, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCBA <- dfm_select(dfmCBA, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCBA <- dfm_select(dfmCBA, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCBA <- dfm_trim(dfmCBA, min_termfreq = 26, termfreq_type = "count") #Roda o wordfish tmod_wfCBA <- textmodel_wordfish(dfmCBA) wfCBA <- predict(tmod_wfCBA, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 8) textplot_scale1d(tmod_wfCBA, doclabels = dfmCBA$partano, groups = docvars(dfmCBA, "ideologia")) ####Ceará #Cria corpus com programas estaduais cCE <- corpus_subset(corpus, local == "CE") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCE <- quanteda::tokens(cCE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCE <- tokens_remove(tCE, stopwords("portuguese")) tCE <- tokens_remove(tCE, c("programa")) #Transforma tokens em stems tCE <- tokens_wordstem(tCE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCE <- dfm(tCE, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCE <- dfm_select(dfmCE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCE <- dfm_select(dfmCE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCE <- dfm_trim(dfmCE, min_termfreq = 28, termfreq_type = "count") #Roda o wordfish tmod_wfCE <- textmodel_wordfish(dfmCE) wfCE <- predict(tmod_wfCE, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 9) textplot_scale1d(tmod_wfCE, doclabels = dfmCE$partano, groups = docvars(dfmCE, "ideologia")) ##Cria corpus com programas da capital cCCE <- corpus_subset(corpus, local == "Fortaleza") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCCE <- quanteda::tokens(cCCE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCCE <- tokens_remove(tCCE, stopwords("portuguese")) tCCE <- tokens_remove(tCCE, c("programa")) #Transforma tokens em stems tCCE <- tokens_wordstem(tCCE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCCE <- dfm(tCCE, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCCE <- dfm_select(dfmCCE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCCE <- dfm_select(dfmCCE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCCE <- dfm_trim(dfmCCE, min_termfreq = 36, termfreq_type = "count") #Roda o wordfish tmod_wfCCE <- textmodel_wordfish(dfmCCE) wfCCE <- predict(tmod_wfCCE, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 9) textplot_scale1d(tmod_wfCCE, doclabels = dfmCCE$partano, groups = docvars(dfmCCE, "ideologia")) ####Distrito Federal #Cria corpus com programas estaduais cDF <- corpus_subset(corpus, local == "DF") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tDF <- quanteda::tokens(cDF, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tDF <- tokens_remove(tDF, stopwords("portuguese")) tDF <- tokens_remove(tDF, c("programa")) #Transforma tokens em stems tDF <- tokens_wordstem(tDF, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmDF <- dfm(tDF, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmDF <- dfm_select(dfmDF, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmDF <- dfm_select(dfmDF, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmDF <- dfm_trim(dfmDF, min_termfreq = 46, termfreq_type = "count") #Roda o wordfish tmod_wfDF <- textmodel_wordfish(dfmDF) wfDF <- predict(tmod_wfDF, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 10) textplot_scale1d(tmod_wfDF, doclabels = dfmDF$partano, groups = docvars(dfmDF, "ideologia")) ####Espírito Santo #Cria corpus com programas estaduais cES <- corpus_subset(corpus, local == "ES") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tES <- quanteda::tokens(cES, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tES <- tokens_remove(tES, stopwords("portuguese")) tES <- tokens_remove(tES, c("programa")) #Transforma tokens em stems tES <- tokens_wordstem(tES, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmES <- dfm(tES, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmES <- dfm_select(dfmES, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmES <- dfm_select(dfmES, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmES <- dfm_trim(dfmES, min_termfreq = 30, termfreq_type = "count") #Roda o wordfish tmod_wfES <- textmodel_wordfish(dfmES) wfES <- predict(tmod_wfES, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 11) textplot_scale1d(tmod_wfES, doclabels = dfmES$partano, groups = docvars(dfmES, "ideologia")) ##Cria corpus com programas da capital cCES <- corpus_subset(corpus, local == "Vitoria") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCES <- quanteda::tokens(cCES, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCES <- tokens_remove(tCES, stopwords("portuguese")) tCES <- tokens_remove(tCES, c("programa")) #Transforma tokens em stems tCES <- tokens_wordstem(tCES, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCES <- dfm(tCES, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCES <- dfm_select(dfmCES, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCES <- dfm_select(dfmCES, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCES <- dfm_trim(dfmCES, min_termfreq = 24, termfreq_type = "count") #Roda o wordfish tmod_wfCES <- textmodel_wordfish(dfmCES) wfCES <- predict(tmod_wfCES, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 11) textplot_scale1d(tmod_wfCES, doclabels = dfmCES$partano, groups = docvars(dfmCES, "ideologia")) ####Goiás #Cria corpus com programas estaduais cGO <- corpus_subset(corpus, local == "GO") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tGO <- quanteda::tokens(cGO, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tGO <- tokens_remove(tGO, stopwords("portuguese")) tGO <- tokens_remove(tGO, c("programa")) #Transforma tokens em stems tGO <- tokens_wordstem(tGO, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmGO <- dfm(tGO, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmGO <- dfm_select(dfmGO, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmGO <- dfm_select(dfmGO, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmGO <- dfm_trim(dfmGO, min_termfreq = 36, termfreq_type = "count") #Roda o wordfish tmod_wfGO <- textmodel_wordfish(dfmGO) wfGO <- predict(tmod_wfGO, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 12) textplot_scale1d(tmod_wfGO, doclabels = dfmGO$partano, groups = docvars(dfmGO, "ideologia")) ##Cria corpus com programas da capital cCGO <- corpus_subset(corpus, local == "Goiania") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCGO <- quanteda::tokens(cCGO, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCGO <- tokens_remove(tCGO, stopwords("portuguese")) tCGO <- tokens_remove(tCGO, c("programa")) #Transforma tokens em stems tCGO <- tokens_wordstem(tCGO, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCGO <- dfm(tCGO, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCGO <- dfm_select(dfmCGO, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCGO <- dfm_select(dfmCGO, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCGO <- dfm_trim(dfmCGO, min_termfreq = 28, termfreq_type = "count") #Roda o wordfish tmod_wfCGO <- textmodel_wordfish(dfmCGO) wfCGO <- predict(tmod_wfCGO, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 12) textplot_scale1d(tmod_wfCGO, doclabels = dfmCGO$partano, groups = docvars(dfmCGO, "ideologia")) ####Maranhão #Cria corpus com programas estaduais cMA <- corpus_subset(corpus, local == "MA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tMA <- quanteda::tokens(cMA, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tMA <- tokens_remove(tMA, stopwords("portuguese")) tMA <- tokens_remove(tMA, c("programa")) #Transforma tokens em stems tMA <- tokens_wordstem(tMA, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmMA <- dfm(tMA, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmMA <- dfm_select(dfmMA, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmMA <- dfm_select(dfmMA, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmMA <- dfm_trim(dfmMA, min_termfreq = 34, termfreq_type = "count") #Roda o wordfish tmod_wfMA <- textmodel_wordfish(dfmMA) wfMA <- predict(tmod_wfMA, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 13) textplot_scale1d(tmod_wfMA, doclabels = dfmMA$partano, groups = docvars(dfmMA, "ideologia")) ##Cria corpus com programas da capital cCMA <- corpus_subset(corpus, local == "Sao Luis") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCMA <- quanteda::tokens(cCMA, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCMA <- tokens_remove(tCMA, stopwords("portuguese")) tCMA <- tokens_remove(tCMA, c("programa")) #Transforma tokens em stems tCMA <- tokens_wordstem(tCMA, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCMA <- dfm(tCMA, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCMA <- dfm_select(dfmCMA, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCMA <- dfm_select(dfmCMA, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCMA <- dfm_trim(dfmCMA, min_termfreq = 32, termfreq_type = "count") #Roda o wordfish tmod_wfCMA <- textmodel_wordfish(dfmCMA) wfCMA <- predict(tmod_wfCMA, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 13) textplot_scale1d(tmod_wfCMA, doclabels = dfmCMA$partano, groups = docvars(dfmCMA, "ideologia")) ####Mato Grosso #Cria corpus com programas estaduais cMT <- corpus_subset(corpus, local == "MT") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tMT <- quanteda::tokens(cMT, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tMT <- tokens_remove(tMT, stopwords("portuguese")) tMT <- tokens_remove(tMT, c("programa")) #Transforma tokens em stems tMT <- tokens_wordstem(tMT, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmMT <- dfm(tMT, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmMT <- dfm_select(dfmMT, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmMT <- dfm_select(dfmMT, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmMT <- dfm_trim(dfmMT, min_termfreq = 28, termfreq_type = "count") #Roda o wordfish tmod_wfMT <- textmodel_wordfish(dfmMT) wfMT <- predict(tmod_wfMT, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 14) textplot_scale1d(tmod_wfMT, doclabels = dfmMT$partano, groups = docvars(dfmMT, "ideologia")) ##Cria corpus com programas da capital cCMT <- corpus_subset(corpus, local == "Cuiaba") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCMT <- quanteda::tokens(cCMT, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCMT <- tokens_remove(tCMT, stopwords("portuguese")) tCMT <- tokens_remove(tCMT, c("programa")) #Transforma tokens em stems tCMT <- tokens_wordstem(tCMT, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCMT <- dfm(tCMT, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCMT <- dfm_select(dfmCMT, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCMT <- dfm_select(dfmCMT, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCMT <- dfm_trim(dfmCMT, min_termfreq = 24, termfreq_type = "count") #Roda o wordfish tmod_wfCMT <- textmodel_wordfish(dfmCMT) wfCMT <- predict(tmod_wfCMT, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 14) textplot_scale1d(tmod_wfCMT, doclabels = dfmCMT$partano, groups = docvars(dfmCMT, "ideologia")) ####Mato Grosso do Sul #Cria corpus com programas estaduais cMS <- corpus_subset(corpus, local == "MS") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tMS <- quanteda::tokens(cMS, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tMS <- tokens_remove(tMS, stopwords("portuguese")) tMS <- tokens_remove(tMS, c("programa")) #Transforma tokens em stems tMS <- tokens_wordstem(tMS, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmMS <- dfm(tMS, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmMS <- dfm_select(dfmMS, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmMS <- dfm_select(dfmMS, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmMS <- dfm_trim(dfmMS, min_termfreq = 28, termfreq_type = "count") #Roda o wordfish tmod_wfMS <- textmodel_wordfish(dfmMS) wfMS <- predict(tmod_wfMS, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 15) textplot_scale1d(tmod_wfMS, doclabels = dfmMS$partano, groups = docvars(dfmMS, "ideologia")) ##Cria corpus com programas da capital cCMS <- corpus_subset(corpus, local == "Campo Grande") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCMS <- quanteda::tokens(cCMS, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCMS <- tokens_remove(tCMS, stopwords("portuguese")) tCMS <- tokens_remove(tCMS, c("programa")) #Transforma tokens em stems tCMS <- tokens_wordstem(tCMS, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCMS <- dfm(tCMS, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCMS <- dfm_select(dfmCMS, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCMS <- dfm_select(dfmCMS, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCMS <- dfm_trim(dfmCMS, min_termfreq = 42, termfreq_type = "count") #Roda o wordfish tmod_wfCMS <- textmodel_wordfish(dfmCMS) wfCMS <- predict(tmod_wfCMS, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 15) textplot_scale1d(tmod_wfCMS, doclabels = dfmCMS$partano, groups = docvars(dfmCMS, "ideologia")) ####Minas Gerais #Cria corpus com programas estaduais cMG <- corpus_subset(corpus, local == "MG") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tMG <- quanteda::tokens(cMG, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tMG <- tokens_remove(tMG, stopwords("portuguese")) tMG <- tokens_remove(tMG, c("programa")) #Transforma tokens em stems tMG <- tokens_wordstem(tMG, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmMG <- dfm(tMG, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmMG <- dfm_select(dfmMG, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmMG <- dfm_select(dfmMG, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmMG <- dfm_trim(dfmMG, min_termfreq = 42, termfreq_type = "count") #Roda o wordfish tmod_wfMG <- textmodel_wordfish(dfmMG) wfMG <- predict(tmod_wfMG, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 16) textplot_scale1d(tmod_wfMG, doclabels = dfmMG$partano, groups = docvars(dfmMG, "ideologia")) #Cria corpus com programas da capital cCMG <- corpus_subset(corpus, local == "Belo Horizonte") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCMG <- quanteda::tokens(cCMG, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCMG <- tokens_remove(tCMG, stopwords("portuguese")) tCMG <- tokens_remove(tCMG, c("programa")) #Transforma tokens em stems tCMG <- tokens_wordstem(tCMG, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCMG <- dfm(tCMG, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCMG <- dfm_select(dfmCMG, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCMG <- dfm_select(dfmCMG, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCMG <- dfm_trim(dfmCMG, min_termfreq = 36, termfreq_type = "count") #Roda o wordfish tmod_wfCMG <- textmodel_wordfish(dfmCMG) wfCMG <- predict(tmod_wfCMG, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 16) textplot_scale1d(tmod_wfCMG, doclabels = dfmCMG$partano, groups = docvars(dfmCMG, "ideologia")) ####Pará #Cria corpus com programas estaduais cPA <- corpus_subset(corpus, local == "PA") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tPA <- quanteda::tokens(cPA, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tPA <- tokens_remove(tPA, stopwords("portuguese")) tPA <- tokens_remove(tPA, c("programa")) #Transforma tokens em stems tPA <- tokens_wordstem(tPA, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmPA <- dfm(tPA, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmPA <- dfm_select(dfmPA, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmPA <- dfm_select(dfmPA, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmPA <- dfm_trim(dfmPA, min_termfreq = 30, termfreq_type = "count") #Roda o wordfish tmod_wfPA <- textmodel_wordfish(dfmPA) wfPA <- predict(tmod_wfPA, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 17) textplot_scale1d(tmod_wfPA, doclabels = dfmPA$partano, groups = docvars(dfmPA, "ideologia")) #Cria corpus com programas da capital cCPA <- corpus_subset(corpus, local == "Belem") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCPA <- quanteda::tokens(cCPA, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCPA <- tokens_remove(tCPA, stopwords("portuguese")) tCPA <- tokens_remove(tCPA, c("programa")) #Transforma tokens em stems tCPA <- tokens_wordstem(tCPA, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCPA <- dfm(tCPA, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCPA <- dfm_select(dfmCPA, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCPA <- dfm_select(dfmCPA, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCPA <- dfm_trim(dfmCPA, min_termfreq = 26, termfreq_type = "count") #Roda o wordfish tmod_wfCPA <- textmodel_wordfish(dfmCPA) wfCPA <- predict(tmod_wfCPA, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 17) textplot_scale1d(tmod_wfCPA, doclabels = dfmCPA$partano, groups = docvars(dfmCPA, "ideologia")) ####Paraíba #Cria corpus com programas estaduais cPB <- corpus_subset(corpus, local == "PB") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tPB <- quanteda::tokens(cPB, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tPB <- tokens_remove(tPB, stopwords("portuguese")) tPB <- tokens_remove(tPB, c("programa")) #Transforma tokens em stems tPB <- tokens_wordstem(tPB, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmPB <- dfm(tPB, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmPB <- dfm_select(dfmPB, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmPB <- dfm_select(dfmPB, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmPB <- dfm_trim(dfmPB, min_termfreq = 30, termfreq_type = "count") #Roda o wordfish tmod_wfPB <- textmodel_wordfish(dfmPB) wfPB <- predict(tmod_wfPB, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 18) textplot_scale1d(tmod_wfPB, doclabels = dfmPB$partano, groups = docvars(dfmPB, "ideologia")) ##Cria corpus com programas da capital cCPB <- corpus_subset(corpus, local == "Joao Pessoa") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCPB <- quanteda::tokens(cCPB, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCPB <- tokens_remove(tCPB, stopwords("portuguese")) tCPB <- tokens_remove(tCPB, c("programa")) #Transforma tokens em stems tCPB <- tokens_wordstem(tCPB, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCPB <- dfm(tCPB, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCPB <- dfm_select(dfmCPB, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCPB <- dfm_select(dfmCPB, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCPB <- dfm_trim(dfmCPB, min_termfreq = 26, termfreq_type = "count") #Roda o wordfish tmod_wfCPB <- textmodel_wordfish(dfmCPB) wfCPB <- predict(tmod_wfCPB, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 18) textplot_scale1d(tmod_wfCPB, doclabels = dfmCPB$partano, groups = docvars(dfmCPB, "ideologia")) ####Paraná #Cria corpus com programas estaduais cPR <- corpus_subset(corpus, local == "PR") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tPR <- quanteda::tokens(cPR, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tPR <- tokens_remove(tPR, stopwords("portuguese")) tPR <- tokens_remove(tPR, c("programa")) #Transforma tokens em stems tPR <- tokens_wordstem(tPR, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmPR <- dfm(tPR, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmPR <- dfm_select(dfmPR, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmPR <- dfm_select(dfmPR, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmPR <- dfm_trim(dfmPR, min_termfreq = 46, termfreq_type = "count") #Roda o wordfish tmod_wfPR <- textmodel_wordfish(dfmPR) wfPR <- predict(tmod_wfPR, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 19) textplot_scale1d(tmod_wfPR, doclabels = dfmPR$partano, groups = docvars(dfmPR, "ideologia")) #Cria corpus com programas da capital cCPR <- corpus_subset(corpus, local == "Curitiba") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCPR <- quanteda::tokens(cCPR, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCPR <- tokens_remove(tCPR, stopwords("portuguese")) tCPR <- tokens_remove(tCPR, c("programa")) #Transforma tokens em stems tCPR <- tokens_wordstem(tCPR, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCPR <- dfm(tCPR, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCPR <- dfm_select(dfmCPR, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCPR <- dfm_select(dfmCPR, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCPR <- dfm_trim(dfmCPR, min_termfreq = 24, termfreq_type = "count") #Roda o wordfish tmod_wfCPR <- textmodel_wordfish(dfmCPR) wfCPR <- predict(tmod_wfCPR, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 19) textplot_scale1d(tmod_wfCPR, doclabels = dfmCPR$partano, groups = docvars(dfmCPR, "ideologia")) ####Pernambuco #Cria corpus com programas estaduais cPE <- corpus_subset(corpus, local == "PE") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tPE <- quanteda::tokens(cPE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tPE <- tokens_remove(tPE, stopwords("portuguese")) tPE <- tokens_remove(tPE, c("programa")) #Transforma tokens em stems tPE <- tokens_wordstem(tPE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmPE <- dfm(tPE, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmPE <- dfm_select(dfmPE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmPE <- dfm_select(dfmPE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmPE <- dfm_trim(dfmPE, min_termfreq = 36, termfreq_type = "count") #Roda o wordfish tmod_wfPE <- textmodel_wordfish(dfmPE) wfPE <- predict(tmod_wfPE, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 20) textplot_scale1d(tmod_wfPE, doclabels = dfmPE$partano, groups = docvars(dfmPE, "ideologia")) #Cria corpus com programas da capital cCPE <- corpus_subset(corpus, local == "Recife") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCPE <- quanteda::tokens(cCPE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCPE <- tokens_remove(tCPE, stopwords("portuguese")) tCPE <- tokens_remove(tCPE, c("programa")) #Transforma tokens em stems tCPE <- tokens_wordstem(tCPE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCPE <- dfm(tCPE, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCPE <- dfm_select(dfmCPE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCPE <- dfm_select(dfmCPE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCPE <- dfm_trim(dfmCPE, min_termfreq = 32, termfreq_type = "count") #Roda o wordfish tmod_wfCPE <- textmodel_wordfish(dfmCPE) wfCPE <- predict(tmod_wfCPE, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 20) textplot_scale1d(tmod_wfCPE, doclabels = dfmCPE$partano, groups = docvars(dfmCPE, "ideologia")) ####Piauí #Cria corpus com programas estaduais cPI <- corpus_subset(corpus, local == "PI") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tPI <- quanteda::tokens(cPI, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tPI <- tokens_remove(tPI, stopwords("portuguese")) tPI <- tokens_remove(tPI, c("programa")) #Transforma tokens em stems tPI <- tokens_wordstem(tPI, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmPI <- dfm(tPI, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmPI <- dfm_select(dfmPI, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmPI <- dfm_select(dfmPI, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmPI <- dfm_trim(dfmPI, min_termfreq = 48, termfreq_type = "count") #Roda o wordfish tmod_wfPI <- textmodel_wordfish(dfmPI) wfPI <- predict(tmod_wfPI, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 21) textplot_scale1d(tmod_wfPI, doclabels = dfmPI$partano, groups = docvars(dfmPI, "ideologia")) #Cria corpus com programas da capital cCPI <- corpus_subset(corpus, local == "Teresina") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCPI <- quanteda::tokens(cCPI, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCPI <- tokens_remove(tCPI, stopwords("portuguese")) tCPI <- tokens_remove(tCPI, c("programa")) #Transforma tokens em stems tCPI <- tokens_wordstem(tCPI, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCPI <- dfm(tCPI, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCPI <- dfm_select(dfmCPI, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCPI <- dfm_select(dfmCPI, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCPI <- dfm_trim(dfmCPI, min_termfreq = 28, termfreq_type = "count") #Roda o wordfish tmod_wfCPI <- textmodel_wordfish(dfmCPI) wfCPI <- predict(tmod_wfCPI, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 21) textplot_scale1d(tmod_wfCPI, doclabels = dfmCPI$partano, groups = docvars(dfmCPI, "ideologia")) ####Rio de Janeiro #Cria corpus com programas estaduais cRJ <- corpus_subset(corpus, local == "RJ") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tRJ <- quanteda::tokens(cRJ, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tRJ <- tokens_remove(tRJ, stopwords("portuguese")) tRJ <- tokens_remove(tRJ, c("programa")) #Transforma tokens em stems tRJ <- tokens_wordstem(tRJ, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmRJ <- dfm(tRJ, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmRJ <- dfm_select(dfmRJ, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmRJ <- dfm_select(dfmRJ, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmRJ <- dfm_trim(dfmRJ, min_termfreq = 42, termfreq_type = "count") #Roda o wordfish tmod_wfRJ <- textmodel_wordfish(dfmRJ) wfRJ <- predict(tmod_wfRJ, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 22) textplot_scale1d(tmod_wfRJ, doclabels = dfmRJ$partano, groups = docvars(dfmRJ, "ideologia")) #Cria corpus com programas da capital cCRJ <- corpus_subset(corpus, local == "Rio de Janeiro") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCRJ <- quanteda::tokens(cCRJ, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCRJ <- tokens_remove(tCRJ, stopwords("portuguese")) tCRJ <- tokens_remove(tCRJ, c("programa")) #Transforma tokens em stems tCRJ <- tokens_wordstem(tCRJ, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCRJ <- dfm(tCRJ, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCRJ <- dfm_select(dfmCRJ, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCRJ <- dfm_select(dfmCRJ, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCRJ <- dfm_trim(dfmCRJ, min_termfreq = 38, termfreq_type = "count") #Roda o wordfish tmod_wfCRJ <- textmodel_wordfish(dfmCRJ) wfCRJ <- predict(tmod_wfCRJ, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 22) textplot_scale1d(tmod_wfCRJ, doclabels = dfmCRJ$partano, groups = docvars(dfmCRJ, "ideologia")) ####Rio Grande do Norte #Cria corpus com programas estaduais cRN <- corpus_subset(corpus, local == "RN") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tRN <- quanteda::tokens(cRN, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tRN <- tokens_remove(tRN, stopwords("portuguese")) tRN <- tokens_remove(tRN, c("programa")) #Transforma tokens em stems tRN <- tokens_wordstem(tRN, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmRN <- dfm(tRN, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmRN <- dfm_select(dfmRN, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmRN <- dfm_select(dfmRN, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmRN <- dfm_trim(dfmRN, min_termfreq = 36, termfreq_type = "count") #Roda o wordfish tmod_wfRN <- textmodel_wordfish(dfmRN) wfRN <- predict(tmod_wfRN, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 23) textplot_scale1d(tmod_wfRN, doclabels = dfmRN$partano, groups = docvars(dfmRN, "ideologia")) #Cria corpus com programas da capital cCRN <- corpus_subset(corpus, local == "Natal") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCRN <- quanteda::tokens(cCRN, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCRN <- tokens_remove(tCRN, stopwords("portuguese")) tCRN <- tokens_remove(tCRN, c("programa")) #Transforma tokens em stems tCRN <- tokens_wordstem(tCRN, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCRN <- dfm(tCRN, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCRN <- dfm_select(dfmCRN, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCRN <- dfm_select(dfmCRN, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCRN <- dfm_trim(dfmCRN, min_termfreq = 26, termfreq_type = "count") #Roda o wordfish tmod_wfCRN <- textmodel_wordfish(dfmCRN) wfCRN <- predict(tmod_wfCRN, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 23) textplot_scale1d(tmod_wfCRN, doclabels = dfmCRN$partano, groups = docvars(dfmCRN, "ideologia")) ####Rio Grande do Sul #Cria corpus com programas estaduais cRS <- corpus_subset(corpus, local == "RS") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tRS <- quanteda::tokens(cRS, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tRS <- tokens_remove(tRS, stopwords("portuguese")) tRS <- tokens_remove(tRS, c("programa")) #Transforma tokens em stems tRS <- tokens_wordstem(tRS, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmRS <- dfm(tRS, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmRS <- dfm_select(dfmRS, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmRS <- dfm_select(dfmRS, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmRS <- dfm_trim(dfmRS, min_termfreq = 44, termfreq_type = "count") #Roda o wordfish tmod_wfRS <- textmodel_wordfish(dfmRS) wfRS <- predict(tmod_wfRS, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 24) textplot_scale1d(tmod_wfRS, doclabels = dfmRS$partano, groups = docvars(dfmRS, "ideologia")) #Cria corpus com programas da capital cCRS <- corpus_subset(corpus, local == "Porto Alegre") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCRS <- quanteda::tokens(cCRS, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCRS <- tokens_remove(tCRS, stopwords("portuguese")) tCRS <- tokens_remove(tCRS, c("programa")) #Transforma tokens em stems tCRS <- tokens_wordstem(tCRS, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCRS <- dfm(tCRS, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCRS <- dfm_select(dfmCRS, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCRS <- dfm_select(dfmCRS, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCRS <- dfm_trim(dfmCRS, min_termfreq = 32, termfreq_type = "count") #Roda o wordfish tmod_wfCRS <- textmodel_wordfish(dfmCRS) wfCRS <- predict(tmod_wfCRS, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 24) textplot_scale1d(tmod_wfCRS, doclabels = dfmCRS$partano, groups = docvars(dfmCRS, "ideologia")) ####Rondônia #Cria corpus com programas estaduais cRO <- corpus_subset(corpus, local == "RO") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tRO <- quanteda::tokens(cRO, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tRO <- tokens_remove(tRO, stopwords("portuguese")) tRO <- tokens_remove(tRO, c("programa")) #Transforma tokens em stems tRO <- tokens_wordstem(tRO, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmRO <- dfm(tRO, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmRO <- dfm_select(dfmRO, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmRO <- dfm_select(dfmRO, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmRO <- dfm_trim(dfmRO, min_termfreq = 36, termfreq_type = "count") #Roda o wordfish tmod_wfRO <- textmodel_wordfish(dfmRO) wfRO <- predict(tmod_wfRO, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 25) textplot_scale1d(tmod_wfRO, doclabels = dfmRO$partano, groups = docvars(dfmRO, "ideologia")) #Cria corpus com programas da capital cCRO <- corpus_subset(corpus, local == "Porto Velho") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCRO <- quanteda::tokens(cCRO, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCRO <- tokens_remove(tCRO, stopwords("portuguese")) tCRO <- tokens_remove(tCRO, c("programa")) #Transforma tokens em stems tCRO <- tokens_wordstem(tCRO, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCRO <- dfm(tCRO, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCRO <- dfm_select(dfmCRO, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCRO <- dfm_select(dfmCRO, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCRO <- dfm_trim(dfmCRO, min_termfreq = 32, termfreq_type = "count") #Roda o wordfish tmod_wfCRO <- textmodel_wordfish(dfmCRO) wfCRO <- predict(tmod_wfCRO, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 25) textplot_scale1d(tmod_wfCRO, doclabels = dfmCRO$partano, groups = docvars(dfmCRO, "ideologia")) ####Roraima ##Cria corpus com programas estaduais cRR <- corpus_subset(corpus, local == "RR") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tRR <- quanteda::tokens(cRR, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tRR <- tokens_remove(tRR, stopwords("portuguese")) tRR <- tokens_remove(tRR, c("programa")) #Transforma tokens em stems tRR <- tokens_wordstem(tRR, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmRR <- dfm(tRR, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmRR <- dfm_select(dfmRR, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmRR <- dfm_select(dfmRR, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmRR <- dfm_trim(dfmRR, min_termfreq = 16, termfreq_type = "count") #Roda o wordfish tmod_wfRR <- textmodel_wordfish(dfmRR) wfRR <- predict(tmod_wfRR, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 26) textplot_scale1d(tmod_wfRR, doclabels = dfmRR$partano, groups = docvars(dfmRR, "ideologia")) #Cria corpus com programas da capital cCRR <- corpus_subset(corpus, local == "Boa Vista") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCRR <- quanteda::tokens(cCRR, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCRR <- tokens_remove(tCRR, stopwords("portuguese")) tCRR <- tokens_remove(tCRR, c("programa")) #Transforma tokens em stems tCRR <- tokens_wordstem(tCRR, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCRR <- dfm(tCRR, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCRR <- dfm_select(dfmCRR, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCRR <- dfm_select(dfmCRR, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCRR <- dfm_trim(dfmCRR, min_termfreq = 24, termfreq_type = "count") #Roda o wordfish tmod_wfCRR <- textmodel_wordfish(dfmCRR) wfCRR <- predict(tmod_wfCRR, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 26) textplot_scale1d(tmod_wfCRR, doclabels = dfmCRR$partano, groups = docvars(dfmCRR, "ideologia")) ####Santa Catarina #Cria corpus com programas estaduais cSC <- corpus_subset(corpus, local == "SC") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tSC <- quanteda::tokens(cSC, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tSC <- tokens_remove(tSC, stopwords("portuguese")) tSC <- tokens_remove(tSC, c("programa")) #Transforma tokens em stems tSC <- tokens_wordstem(tSC, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmSC <- dfm(tSC, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmSC <- dfm_select(dfmSC, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmSC <- dfm_select(dfmSC, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmSC <- dfm_trim(dfmSC, min_termfreq = 46, termfreq_type = "count") #Roda o wordfish tmod_wfSC <- textmodel_wordfish(dfmSC) wfSC <- predict(tmod_wfSC, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 27) textplot_scale1d(tmod_wfSC, doclabels = dfmSC$partano, groups = docvars(dfmSC, "ideologia")) #Cria corpus com programas da capital cCSC <- corpus_subset(corpus, local == "Florianopolis") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCSC <- quanteda::tokens(cCSC, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCSC <- tokens_remove(tCSC, stopwords("portuguese")) tCSC <- tokens_remove(tCSC, c("programa")) #Transforma tokens em stems tCSC <- tokens_wordstem(tCSC, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCSC <- dfm(tCSC, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCSC <- dfm_select(dfmCSC, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCSC <- dfm_select(dfmCSC, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCSC <- dfm_trim(dfmCSC, min_termfreq = 26, termfreq_type = "count") #Roda o wordfish tmod_wfCSC <- textmodel_wordfish(dfmCSC) wfCSC <- predict(tmod_wfCSC, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 27) textplot_scale1d(tmod_wfCSC, doclabels = dfmCSC$partano, groups = docvars(dfmCSC, "ideologia")) ####São Paulo #Cria corpus com programas estaduais cSP <- corpus_subset(corpus, local == "SP") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tSP <- quanteda::tokens(cSP, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tSP <- tokens_remove(tSP, stopwords("portuguese")) tSP <- tokens_remove(tSP, c("programa")) #Transforma tokens em stems tSP <- tokens_wordstem(tSP, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmSP <- dfm(tSP, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmSP <- dfm_select(dfmSP, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmSP <- dfm_select(dfmSP, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmSP <- dfm_trim(dfmSP, min_termfreq = 54, termfreq_type = "count") #Roda o wordfish tmod_wfSP <- textmodel_wordfish(dfmSP) wfSP <- predict(tmod_wfSP, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 28) textplot_scale1d(tmod_wfSP, doclabels = dfmSP$partano, groups = docvars(dfmSP, "ideologia")) #Cria corpus com programas da capital cCSP <- corpus_subset(corpus, local == "Sao Paulo") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCSP <- quanteda::tokens(cCSP, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCSP <- tokens_remove(tCSP, stopwords("portuguese")) tCSP <- tokens_remove(tCSP, c("programa")) #Transforma tokens em stems tCSP <- tokens_wordstem(tCSP, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCSP <- dfm(tCSP, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCSP <- dfm_select(dfmCSP, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCSP <- dfm_select(dfmCSP, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCSP <- dfm_trim(dfmCSP, min_termfreq = 40, termfreq_type = "count") #Roda o wordfish tmod_wfCSP <- textmodel_wordfish(dfmCSP) wfCSP <- predict(tmod_wfCSP, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 28) textplot_scale1d(tmod_wfCSP, doclabels = dfmCSP$partano, groups = docvars(dfmCSP, "ideologia")) ####Sergipe #Cria corpus com programas estaduais cSE <- corpus_subset(corpus, local == "SE") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tSE <- quanteda::tokens(cSE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tSE <- tokens_remove(tSE, stopwords("portuguese")) tSE <- tokens_remove(tSE, c("programa")) #Transforma tokens em stems tSE <- tokens_wordstem(tSE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmSE <- dfm(tSE, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmSE <- dfm_select(dfmSE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmSE <- dfm_select(dfmSE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmSE <- dfm_trim(dfmSE, min_termfreq = 32, termfreq_type = "count") #Roda o wordfish tmod_wfSE <- textmodel_wordfish(dfmSE) wfSE <- predict(tmod_wfSE, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 29) textplot_scale1d(tmod_wfSE, doclabels = dfmSE$partano, groups = docvars(dfmSE, "ideologia")) #Cria corpus com programas da capital cCSE <- corpus_subset(corpus, local == "Aracaju") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCSE <- quanteda::tokens(cCSE, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCSE <- tokens_remove(tCSE, stopwords("portuguese")) tCSE <- tokens_remove(tCSE, c("programa")) #Transforma tokens em stems tCSE <- tokens_wordstem(tCSE, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCSE <- dfm(tCSE, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCSE <- dfm_select(dfmCSE, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCSE <- dfm_select(dfmCSE, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCSE <- dfm_trim(dfmCSE, min_termfreq = 24, termfreq_type = "count") #Roda o wordfish tmod_wfCSE <- textmodel_wordfish(dfmCSE) wfCSE <- predict(tmod_wfCSE, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 29) textplot_scale1d(tmod_wfCSE, doclabels = dfmCSE$partano, groups = docvars(dfmCSE, "ideologia")) ####Tocantins #Cria corpus com programas estaduais cTO <- corpus_subset(corpus, local == "TO") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tTO <- quanteda::tokens(cTO, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tTO <- tokens_remove(tTO, stopwords("portuguese")) tTO <- tokens_remove(tTO, c("programa")) #Transforma tokens em stems tTO <- tokens_wordstem(tTO, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmTO <- dfm(tTO, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmTO <- dfm_select(dfmTO, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmTO <- dfm_select(dfmTO, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmTO <- dfm_trim(dfmTO, min_termfreq = 24, termfreq_type = "count") #Roda o wordfish tmod_wfTO <- textmodel_wordfish(dfmTO) wfTO <- predict(tmod_wfTO, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível estadual (Gráfico 30) textplot_scale1d(tmod_wfTO, doclabels = dfmTO$partano, groups = docvars(dfmTO, "ideologia")) #Cria corpus com programas da capital cCTO <- corpus_subset(corpus, local == "Palmas") #Tokeniza corpus, removendo números, pontuação, stopwords e a palavra "programa" tCTO <- quanteda::tokens(cCTO, remove_numbers = TRUE, remove_punct = TRUE, remove_separators = TRUE) tCTO <- tokens_remove(tCTO, stopwords("portuguese")) tCTO <- tokens_remove(tCTO, c("programa")) #Transforma tokens em stems tCTO <- tokens_wordstem(tCTO, language = "portuguese") #Cria matriz de frequência de termos por documento, todos com letras minúsculas dfmCTO <- dfm(tCTO, tolower = TRUE) #Remove da matriz: caracteres especiais da matriz e outros termos a serem desconsiderados, como números romanos e termos com frequência < que 2 * o número de documentos dfmCTO <- dfm_select(dfmCTO, pattern = "[^0-9A-Za-z///' ]", selection = "remove", valuetype = "regex") dfmCTO <- dfm_select(dfmCTO, pattern = c("ii", "iii", "iv", "vi", "vii", "viii", "ix", "4o", "il"), selection = "remove", valuetype = "regex") dfmCTO <- dfm_trim(dfmCTO, min_termfreq = 22, termfreq_type = "count") #Roda o wordfish tmod_wfCTO <- textmodel_wordfish(dfmCTO) wfCTO <- predict(tmod_wfCTO, se.fit = TRUE, interval = "confidence", level = 0.95) #Faz gráfico do nível municipal (Gráfico 30) textplot_scale1d(tmod_wfCTO, doclabels = dfmCTO$partano, groups = docvars(dfmCTO, "ideologia"))