Henrique Sequine

Introdução John é monitor na matéria de Introdução à Produção Textual I na Penn State University (PSU). Durante esse período, John descobriu que uma epidemia de COH-PIAH estava se espalhando pela PSU. Esses doença rara e altamente contagiosa faz com que as pessoas contaminadas produzam textos extremamente semelhantes de forma involuntária. Após a entrega da primeira redação, John desconfiou que alguns alunos estavam sofrendo de COH-PIAH. John, se preocupando com a saúde da turma, resolveu buscar um método para identificar os casos de COH-PIAH. Para isso, ele necessita da sua ajuda para desenvolver um programa que o auxilie a identificar os alunos contaminados. Detecção de autoria Utilizando diferentes estatísticas do texto, é possível identificar aspectos que funcionam como uma “assinatura” do autor. Diferentes pessoas possuem diferentes estilos de escrita, algumas preferindo sentenças mais curtas, outras preferindo sentenças mais longas. Essas “assinatura” pode ser utilizada para detecção de plágio, evidência forense, ou nesse caso, para detectar a grave doença COH-PIAH. Traços linguísticos Nesse exercício utilizaremos as seguintes estatísticas para detectar a doença: Tamanho médio de palavra: Média simples do número de caracteres por palavra. Relação Type-Token: Número de palavras diferentes utilizadas em um texto divididas pelo total de palavras. Razão Hapax Legomana: Número de palavras utilizadas uma vez dividido pelo número total de palavras. Tamanho médio de sentença: Média simples do número de caracteres por sentença. Complexidade de sentença: Média simples do número de frases por sentença. Tamanho médio de frase: Média simples do número de caracteres por frase. Funcionamento do programa Diversos estudos foram compilados e hoje se conhece precisamente a assinatura de um portador de COH-PIAH. Seu programa deverá receber diversos textos e calcular os valores dos diferentes traços linguísticos da seguinte forma: Tamanho médio de palavra é a soma dos tamanhos das palavras dividida pelo número total de palavras. Relação Type-Token é o número de palavras diferentes dividido pelo número total de palavras. Por exemplo, na frase "O gato caçava o rato", temos 5 palavras no total (o, gato, caçava, o, rato) mas somente 4 diferentes (o, gato, caçava, rato). Nessa frase, a relação Type-Token vale 45=0.8 Razão Hapax Legomana é o número de palavras que aparecem uma única vez dividido pelo total de palavras. Por exemplo, na frase "O gato caçava o rato", temos 5 palavras no total (o, gato, caçava, o, rato) mas somente 3 que aparecem só uma vez (gato, caçava, rato). Nessa frase, a relação Hapax Legomana vale 35=0.6 Tamanho médio de sentença é a soma dos números de caracteres em todas as sentenças dividida pelo número de sentenças (os caracteres que separam uma sentença da outra não devem ser contabilizados como parte da sentença). Complexidade de sentença é o número total de frases divido pelo número de sentenças. Tamanho médio de frase é a soma do número de caracteres em cada frase dividida pelo número de frases no texto (os caracteres que separam uma frase da outra não devem ser contabilizados como parte da frase). Após calcular esses valores para cada texto, você deve comparar com a assinatura fornecida para os infectados por COH-PIAH. O grau de similaridade entre dois textos, a e b, é dado pela fórmula: Sab=∑6i=1||fi,a−fi,b||6 Onde: Sab é o grau de similaridade entre os textos a e b; fi,a é o valor de cada traço linguístico i no texto a; e fi,b é o valor de cada traço linguístico i no texto b. Perceba que quanto mais similares a e b forem, menor Sab será. Para cada texto, você deve calcular o grau de similaridade com a assinatura do portador de COH-PIAH e no final exibir qual o texto que mais provavelmente foi escrito por algum aluno infectado. Funções de suporte As seguintes funções devem ser utilizadas no seu programa; algumas já estão implementadas, outras devem ser completadas por você. Sinta-se livre para criar funções adicionais, caso necessário. Utilize este esqueleto como base para começar o seu programa. Dica: aproveite as funções pré-prontas do esqueleto, como "separa_sentenca", "separa_frase" etc.! Como há mais de uma maneira de pensar a separação entre frases/palavras/sentenças, usando essas funções você vai fazer o cálculo da maneira esperada pelo corretor automático. Cuidado: A função le_textos() considera que um "texto" é uma linha de texto, ou seja, não é possível inserir parágrafos separados. Se você digitar algum "enter", a função vai entender que você está começando um novo texto. Preste especial atenção a isso se usar "copiar/colar" para inserir os textos! Atenção: avalia_textos() deve devolver um número de 0 a n-1, mas ao mostrar a resposta para o usuário você vai imprimir um número de 1 a n. Note também que, no cálculo de similaridade, é preciso encontrar o valor absoluto de cada uma das diferenças. ESSE É O ENUNCIADO!! Agora meu código, que o corretor diz que esta na nota 3 de, 10. Preciso de 8 no mínimo. Qualquer ajuda ja é ótimo. import re def main(): ass_main = le_assinatura() textos_main = le_textos() matriz_ass = calcula_assinatura(textos_main) ass_comparadas = compara_assinatura(ass_main, matriz_ass) copiah = avalia_textos(textos_main, ass_comparadas) + 1 return print("O autor do texto", copiah, "está infectado com COH-PIAH.") def le_assinatura(): """ A funcao le os valores dos tracos linguisticos do modelo e devolve uma assinatura a ser comparada com os textos fornecidos. """ print("Bem-vindo ao detector automático de COH-PIAH.") tam_m_pal = float(input("Entre o tamanho medio de palavra:")) type_token = float(input("Entre a relação Type-Token:")) h_lego = float(input("Entre a Razão Hapax Legomana:")) tam_m_sent = float(input("Entre o tamanho médio de sentença:")) compx_med = float(input("Entre a complexidade média da sentença:")) tam_m_frase = float(input("Entre o tamanho medio de frase:")) return [tam_m_pal, type_token, h_lego, tam_m_sent, compx_med, tam_m_frase] def le_textos(): i = 1 textos = [] texto = input("Digite o texto " + str(i) + "(aperte enter para sair):") while texto: textos.append(texto) i += 1 texto = input("Digite o texto " + str(i) + "(aperte enter para sair):") return textos def calcula_assinatura(texto): """ Essa funcao recebe um texto e deve devolver a assinatura do texto. """ if type(texto) != list: aux = texto texto = [] texto.append(aux) matriz_ass_input = [] for i in texto: sentencas = [] sentencas = separa_sentencas(int(i)) # sent.. = lista comum, ~matriz frases = [] num_tot_sentencas = 0 soma_cat_sentencas = 0 for i in range(len(sentencas)): frase_i = separa_frases(int(sentencas)) frases.append(frase_i) # frases = matriz, lista de listas num_tot_sentencas += 1 soma_cat_sentencas = soma_cat_sentencas + len(sentencas) palavras = [] num_tot_frases = 0 soma_cat_frases = 0 for lin in range(len(frases)): for col in range(len(frases[lin])): palavra_i = separa_palavras(int(frases[lin][col])) palavras.append(palavra_i) # palav.. = matriz, lista de listas num_tot_frases += 1 soma_cat_frases = soma_cat_frases + len(str(frases[lin][col])) mtrx_para_lista = [] # transform.. palavras de matriz para lista for lin in range(len(palavras)): for col in range(len(palavras[lin])): mtrx_para_lista.append(palavras[lin][col]) palavras = mtrx_para_lista[:] soma_comp_palavras = 0 num_tot_palavras = 0 for lin in range(len(palavras)): for col in range(len(palavras[lin])): soma_comp_palavras = soma_comp_palavras + len(str(palavras[lin][col])) num_tot_palavras += 1 ass_txt = [] ass_txt.append(tam_m_pal(soma_comp_palavras, num_tot_palavras)) ass_txt.append(type_token(palavras, num_tot_palavras)) ass_txt.append(h_lego(palavras, num_tot_palavras)) ass_txt.append(tam_m_sent(soma_cat_sentencas, num_tot_sentencas)) ass_txt.append(compx_med(num_tot_frases, num_tot_sentencas)) ass_txt.append(tam_m_frase(soma_cat_frases, num_tot_frases)) matriz_ass_input.append(ass_txt) return matriz_ass_input # matriz, lista de listas dos valores das assina.. def tam_m_pal(soma_comp_palavras, num_tot_palavras): if num_tot_palavras != 0: tam_m_pal = soma_comp_palavras / num_tot_palavras else: tam_m_pal = 0 return tam_m_pal def type_token(lista_palavras, num_tot_palavras): num_pal_dif = n_palavras_diferentes(lista_palavras) if num_tot_palavras != 0: type_token = num_pal_dif / num_tot_palavras else: type_token = 0 return type_token def h_lego(lista_palavras, num_tot_palavras): num_pal_uni = n_palavras_unicas(lista_palavras) if num_tot_palavras != 0: h_lego = num_pal_uni / num_tot_palavras else: h_lego = 0 return h_lego def tam_m_sent(soma_num_cat, num_sent): if num_sent != 0: tam_m_sent = soma_num_cat / num_sent else: tam_m_sent = 0 return tam_m_sent def compx_med(num_tot_frases, num_tot_sentencas): if num_tot_sentencas != 0: compx_med = num_tot_frases / num_tot_sentencas else: compx_med = 0 return compx_med def tam_m_frase(soma_cat_frases, num_tot_frases): if num_tot_frases != 0: tam_m_frase = soma_cat_frases / num_tot_frases else: tam_m_frase = 0 return tam_m_frase def separa_sentencas(texto): """ A funcao recebe um texto e devolve uma lista das sentencas dentro do texto. """ sentencas = re.split(r'[.!?]+', texto) if sentencas[-1] == '': del sentencas[-1] return sentencas def separa_frases(sentenca): """ A funcao recebe uma sentenca e devolve uma lista das frases dentro da sentenca. """ return re.split(r'[,:;]+', sentenca) def separa_palavras(frase): """ A funcao recebe uma frase e devolve uma lista das palavras dentro da frase. """ return frase.split() def n_palavras_unicas(lista_palavras): """ Essa funcao recebe uma lista de palavras e devolve o numero de palavras que aparecem uma unica vez. """ freq = dict() unicas = 0 for palavra in lista_palavras: p = palavra.lower() if p in freq: if freq[p] == 1: unicas -= 1 freq[p] += 1 else: freq[p] = 1 unicas += 1 return unicas def n_palavras_diferentes(lista_palavras): """ Essa funcao recebe uma lista de palavras e devolve o numero de palavras diferentes utilizadas. """ freq = dict() for palavra in lista_palavras: p = palavra.lower() if p in freq: freq[p] += 1 else: freq[p] = 1 return len(freq) def compara_assinatura(ass_main, matriz_ass_input): """ Essa funcao recebe duas assinaturas de texto e deve devolver o grau de similaridade nas assinaturas. """ lista_Sab = [] soma_mod = 0 if type(matriz_ass_input[0]) is list: for lin in range(len(matriz_ass_input)): for col in range(len(matriz_ass_input[lin])): soma_mod += abs(ass_main[col] - matriz_ass_input[lin][col]) Sab = soma_mod / 6 lista_Sab.append(Sab) return lista_Sab else: for i in range(len(matriz_ass_input)): soma_mod += abs(ass_main - matriz_ass_input) Sab = soma_mod / 6 return Sab def avalia_textos(textos_main, ass_comparadas): """ Essa funcao recebe uma lista de textos e deve devolver o numero (0 a n-1) do texto com maior probabilidade de ter sido infectado por COH-PIAH. """ aux_ass_com = ass_comparadas[:] aux_ass_com.sort() for indice in range(len(ass_comparadas)): if aux_ass_com[0] == ass_comparadas[indice]: copiah = indice return copiah