Tarefa de programação: Programa completo - Similaridades entre textos - Caso COH-PIAH

AVF99999999999999 · Dezembro 27, 2020

Tarefa de programação: Programa completo - Similaridades entre textos - Caso COH-PIAH

Enunciado

Prólogo

Neste último exercício da Parte 1, iremos praticar não só o que vimos até agora no curso mas também outra habilidade importante de um programador: utilizar e interagir com código escrito por terceiros. Aqui, você não irá implementar o seu programa do zero. Você irá partir de um programa já iniciado e irá completá-lo. Na verdade, esse é o caso mais comum na indústria de software, onde muitos desenvolvedores trabalham colaborativamente em um mesmo programa.

Introdução

Manuel Estandarte é monitor na disciplina Introdução à Produção Textual I na Universidade de Pasárgada (UPA). Durante o período letivo, Manuel descobriu que uma epidemia de COH-PIAH estava se espalhando pela UPA. Essa doença rara e altamente contagiosa faz com que indivíduos contaminados produzam, involuntariamente, textos muito semelhantes aos de outras pessoas. Após a entrega da primeira redação, Manuel desconfiou que alguns alunos estavam sofrendo de COH-PIAH. Manuel, preocupado 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

Diferentes pessoas possuem diferentes estilos de escrita; por exemplo, algumas pessoas preferem sentenças mais curtas, outras preferem sentenças mais longas. Utilizando diversas estatísticas do texto, é possível identificar aspectos que funcionam como uma “assinatura” do seu autor e, portanto, é possível detectar se dois textos dados foram escritos por uma mesma pessoa. Ou seja, essa “assinatura” pode ser utilizada para detecção de plágio, evidência forense ou, neste caso, para diagnosticar a grave doença COH-PIAH.

Traços linguísticos

Neste 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 única 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

A partir da assinatura conhecida de um portador de COH-PIAH, seu programa deverá receber diversos textos e calcular os valores dos diferentes traços linguísticos desses textos para compará-los com a assinatura dada. Os traços linguísticos que seu programa deve utilizar são calculados 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 4/5=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 3;5=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 compará-los com a assinatura fornecida para os infectados por COH-PIAH. O grau de similaridade entre dois textos, a a e b b, é dado pela fórmula:

Sab=∑⁶_i=1∣∣fi,a−fi,b∣∣

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.

No nosso caso, o texto b b não é conhecido, mas temos a assinatura correspondente: a assinatura de um aluno infectado com COH-PIAH. Ou seja, sabemos o valor de fi,b que é dado como valor de entrada do programa.

Caso você não esteja acostumado com a notação matemática, podemos destrinchar essa fórmula da seguinte maneira:

Para cada traço linguístico i i (tamanho médio da palavra, relação type-token etc.) se quer a diferença entre o valor obtido em cada texto dado ( a a) e o valor típico do texto de uma pessoa infectada ( b)fi,a−fi,b

Dessa diferença se toma o módulo ( ∣∣…∣∣), lembre-se da função abs do python.

Somamos os resultados dos 6 traços linguísticos (∑⁶_i=1)

E por final dividimos por 6 (x/6)

Perceba que quanto mais similares a a e b 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 texto mais provavelmente foi escrito por algum aluno infectado (ou seja, o texto com assinatura mais similar à assinatura dada).

Exemplo:

$ > python3 coh_piah.py

Bem-vindo ao detector automático de COH-PIAH.
Informe a assinatura típica de um aluno infectado:

Entre o tamanho médio de palavra: 4.79
Entre a relação Type-Token: 0.72
Entre a Razão Hapax Legomana: 0.56
Entre o tamanho médio de sentença: 80.5
Entre a complexidade média da sentença: 2.5
Entre o tamanho médio de frase: 31.6

Digite o texto 1 (aperte enter para sair): Navegadores antigos tinham uma frase gloriosa:"Navegar é preciso; viver não é preciso". Quero para mim o espírito [d]esta frase, transformada a forma para a casar como eu sou: Viver não é necessário; o que é necessário é criar. Não conto gozar a minha vida; nem em gozá-la penso. Só quero torná-la grande,ainda que para isso tenha de ser o meu corpo e a (minha alma) a lenha desse fogo. Só quero torná-la de toda a humanidade;ainda que para isso tenha de a perder como minha. Cada vez mais assim penso.Cada vez mais ponho da essência anímica do meu sangueo propósito impessoal de engrandecer a pátria e contribuirpara a evolução da humanidade.É a forma que em mim tomou o misticismo da nossa Raça.

Digite o texto 2 (aperte enter para sair): Voltei-me para ela; Capitu tinha os olhos no chão. Ergueu-os logo, devagar, e ficamos a olhar um para o outro... Confissão de crianças, tu valias bem duas ou três páginas, mas quero ser poupado. Em verdade, não falamos nada; o muro falou por nós. Não nos movemos, as mãos é que se estenderam pouco a pouco, todas quatro, pegando-se, apertando-se, fundindo-se. Não marquei a hora exata daquele gesto. Devia tê-la marcado; sinto a falta de uma nota escrita naquela mesma noite, e que eu poria aqui com os erros de ortografia que trouxesse, mas não traria nenhum, tal era a diferença entre o estudante e o adolescente. Conhecia as regras do escrever, sem suspeitar as do amar; tinha orgias de latim e era virgem de mulheres.

Digite o texto 3 (aperte enter para sair): NOSSA alegria diante dum sistema metafisico, nossa satisfação em presença duma construção do pensamento, em que a organização espiritual do mundo se mostra num conjunto lógico, coerente a harmônico, sempre dependem eminentemente da estética; têm a mesma origem que o prazer, que a alta satisfação, sempre serena afinal, que a atividade artística nos proporciona quando cria a ordem e a forma a nos permite abranger com a vista o caos da vida, dando-lhe transparência.

Digite o texto 4 (aperte enter para sair):

O autor do texto 2 está infectado com COH-PIAH

Funções de suporte

Para facilitar seu trabalho, fornecemos para você um esqueleto do programa completo como base. Use-o! As funções definidas nele devem ser utilizadas no seu programa; algumas já estão implementadas, outras devem ser implementadas por você (conforme indicado pelo comentário "IMPLEMENTAR"). Sinta-se livre para criar funções adicionais, caso necessário.

import re

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.")

print("Informe a assinatura típica de um aluno infectado:")

wal = float(input("Entre o tamanho médio de palavra:"))

ttr = float(input("Entre a relação Type-Token:"))

hlr = float(input("Entre a Razão Hapax Legomana:"))

sal = float(input("Entre o tamanho médio de sentença:"))

sac = float(input("Entre a complexidade média da sentença:"))

pal = float(input("Entre o tamanho medio de frase:"))

return [wal, ttr, hlr, sal, sac, pal]

def le_textos():

'''A funcao le todos os textos a serem comparados e devolve uma lista contendo cada texto como um elemento'''

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 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(as_a, as_b):

'''IMPLEMENTAR. Essa funcao recebe duas assinaturas de texto e deve devolver o grau de similaridade nas assinaturas.'''

pass

def calcula_assinatura(texto):

'''IMPLEMENTAR. Essa funcao recebe um texto e deve devolver a assinatura do texto.'''

pass

def avalia_textos(textos, ass_cp):

'''IMPLEMENTAR. Essa funcao recebe uma lista de textos e uma assinatura ass_cp e deve devolver o numero (1 a n) do texto com maior probabilidade de ter sido infectado por COH-PIAH.'''

pass

Dica: não se preocupe com os detalhes de implementação das funções pré-prontas do esqueleto, como "separa_sentenca()", "separa_frase()" etc. nem com as definições exatas de frase e sentença. Essas funções já cuidam disso para você, e podem ser pensadas como "caixas pretas": você pode utilizá-las sabendo o que recebem e o que devolvem, mas não é necessário saber sobre os seus detalhes internos. Além de isso ser muito comum ao programar em equipe, 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! Note também que, no cálculo de similaridade, é preciso encontrar o valor absoluto de cada uma das diferenças.

Exemplo de Assinatura

Um passo importante para seu programa é calcular a assinatura dos textos corretamente. Para testar se sua função calcula_assinatura() está correta, deixamos aqui um exemplo de execução:

texto = "Muito além, nos confins inexplorados da região mais brega da Borda Ocidental desta Galáxia, há um pequeno sol amarelo e esquecido. Girando em torno deste sol, a uma distancia de cerca de 148 milhões de quilômetros, há um planetinha verde-azulado absolutamente insignificante, cujas formas de vida, descendentes de primatas, são tão extraordinariamente primitivas que ainda acham que relógios digitais são uma grande ideia."

calcula_assinatura(texto)

>[5.571428571428571, 0.8253968253968254, 0.6984126984126984, 210.0, 4.5, 45.888888888888886]

Concluindo

Basicamente, sua tarefa é implementar corretamente as seguintes funções:

compara_assinatura(as_a, as_b)
calcula_assinatura(texto)
avalia_textos(textos, ass_cp)

Usando o esqueleto que oferecemos acima e implementando essas 3 funções, seu detector de plágio estará completo e você poderá submetê-lo ao corretor automático. Caso o corretor automático aponte erros, tente ler com bastante cuidado e atenção a mensagem fornecida por ele, pois ela normalmente ajuda a identificar o erro.

Boa sorte! Não desista!

Sabemos que é um desafio, mas você vai aprender muito com ele.

Pense no prazer que você vai sentir quando sua solução final for aceita!!!

Minha resposta (nota 5 de 10)

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(i) # sent.. = lista comum, ~matriz
frases = []
num_tot_sentencas = 0
soma_cat_sentencas = 0
for i in range(len(sentencas)):
frase_i = separa_frases(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(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

Erros do apontados pelo contador de pontuação

O resultado dos testes com seu programa foi:

***** [0.25 pontos]: Comparando assinaturas do textos (ass1 = [4.33, 0.23, 0.14, 13.28, 1.86, 0.0], ass2 = [4.33, 0.23, 0.14, 13.28, 1.86, 0.0]) - Falhou *****

TypeError: unsupported operand type(s) for -: 'list' and 'list'

***** [0.25 pontos]: Comparando assinaturas do textos (ass1 = [4.34, 0.05, 0.02, 12.81, 2.16, 0.0], ass2 = [3.96, 0.05, 0.02, 22.22, 3.41, 0.0]) - Falhou *****

TypeError: unsupported operand type(s) for -: 'list' and 'list'

***** [0.25 pontos]: Testando calculo assinatura (text = NOSSA alegria diante dum sistema metafisico, nossa satisfação em presença duma construção do pensamento, em que a organização espiritual do mundo se mostra num conjunto lógico, coerente a harmônico, sempre dependem eminentemente da estética; têm a mesma origem que o prazer, que a alta satisfação, sempre serena afinal, que a atividade artística nos proporciona quando cria a ordem e a forma a nos permite abranger com a vista o caos da vida, dando-lhe transparência.) - Falhou *****

TypeError: expected string or bytes-like object

***** [0.25 pontos]: Testando calculo assinatura (text = Voltei-me para ela; Capitu tinha os olhos no chão. Ergueu-os logo, devagar, e ficamos a olhar um para o outro... Confissão de crianças, tu valias bem duas ou três páginas, mas quero ser poupado. Em verdade, não falamos nada; o muro falou por nós. Não nos movemos, as mãos é que se estenderam pouco a pouco, todas quatro, pegando-se, apertando-se, fundindo-se. Não marquei a hora exata daquele gesto. Devia tê-la marcado; sinto a falta de uma nota escrita naquela mesma noite, e que eu poria aqui com os erros de ortografia que trouxesse, mas não traria nenhum, tal era a diferença entre o estudante e o adolescente. Conhecia as regras do escrever, sem suspeitar as do amar; tinha orgias de latim e era virgem de mulheres.) - Falhou *****

TypeError: expected string or bytes-like object *****

[0.25 pontos]: Testando calculo assinatura (text = Navegadores antigos tinham uma frase gloriosa:"Navegar é preciso; viver não é preciso".Quero para mim o espírito [d]esta frase,transformada a forma para a casar como eu sou:Viver não é necessário; o que é necessário é criar.Não conto gozar a minha vida; nem em gozá-la penso.Só quero torná-la grande,ainda que para isso tenha de ser o meu corpo e a (minha alma) a lenha desse fogo.Só quero torná-la de toda a humanidade;ainda que para isso tenha de a perder como minha.Cada vez mais assim penso.Cada vez mais ponho da essência anímica do meu sangueo propósito impessoal de engrandecer a pátria e contribuirpara a evolução da humanidade.É a forma que em mim tomou o misticismo da nossa Raça.) - Falhou *****

TypeError: expected string or bytes-like object

Editado Dezembro 28, 2020 por AVF99999999999999

ArteEN · Dezembro 28, 2020

Em 27/12/2020 em 17:15, AVF99999999999999 disse:

TypeError: unsupported operand type(s) for -: 'list' and 'list'

você não pode usar operação de subtração entre listas

>>> [1,2,3]-[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'list' and 'list'

Allan · Junho 24, 2021

import re

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.")

wal = float(input("Entre o tamanho medio de palavra:"))
ttr = float(input("Entre a relação Type-Token:"))
hlr = float(input("Entre a Razão Hapax Legomana:"))
sal = float(input("Entre o tamanho médio de sentença:"))
sac = float(input("Entre a complexidade média da sentença:"))
pal = float(input("Entre o tamanho medio de frase:"))

return [wal, ttr, hlr, sal, sac, pal]

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 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(as_a, as_b):
'''IMPLEMENTAR. Essa funcao recebe duas assinaturas de texto e deve devolver o grau de similaridade nas assinaturas.'''
soma_temp = 0
for i in range(0,6):
soma_temp = soma_temp + (abs(as_a[i] - as_b[i]))

return soma_temp / 6

def calcula_assinatura(texto):
'''IMPLEMENTAR. Essa funcao recebe um texto e deve devolver a assinatura do texto.'''
sentencas = separa_sentencas(texto)
frases = []
palavras = []
meia_palavras = 0
meio_sentencas = 0
comp_sentenca = 0
rel_type_token = 0
hapax = 0
soma_car_sentenca = 0
soma_pal = 0
soma_car_frase = 0
tam_meio_frase = 0

for sentenca in sentencas:
soma_car_sentenca = soma_car_sentenca + len(sentenca)
l_frases = separa_frases(sentenca)

for f in l_frases:
frases.append(f)

for frase in frases:
soma_car_frase = soma_car_frase + len(frase)
l_pal = separa_palavras(frase)

for palavra in l_pal:
palavras.append(palavra)

for palavra in palavras:
soma_pal = soma_pal + len(palavra)

meia_palavras = soma_pal/len(palavras)
rel_type_token = n_palavras_diferentes(palavras)/len(palavras)
hapax = n_palavras_unicas(palavras)/len(palavras)
meio_sentencas = soma_car_sentenca / len(sentencas)
comp_sentenca = len(frases) / len(sentencas)
tam_meio_frase = soma_car_frase / len(frases)

return [meia_palavras, rel_type_token, hapax, meio_sentencas, comp_sentenca, tam_meio_frase]

def avalia_textos(textos, ass_cp):
'''IMPLEMENTAR. Essa funcao recebe uma lista de textos e deve devolver o numero (1 a n) do texto com maior probabilidade de ter sido infectado por COH-PIAH.'''
inf = []

for texto in textos:
ass_texto = calcula_assinatura(texto)
inf.append(compara_assinatura(ass_texto, ass_cp))

menor = inf[0]
c = 1

for i in range(1, len(inf)):
if (menor > inf[i]):
c = i
return c

def main():
assinatura = le_assinatura()
textos = le_textos()
c = avalia_textos(textos, assinatura)
print("O autor do texto {} está infectado com COH-PIAH".format(c))

main()

Postei meu codigo que implementei pro curso da USP - Coursera

ta funcionando e já consegui fazer valer nota 10..

valeu, espero ter ajudado..

Matos Oliveira · Fevereiro 11, 2022

Em 24/06/2021 em 12:04, Allan disse:

import re

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.")

wal = float(input("Entre o tamanho medio de palavra:"))
ttr = float(input("Entre a relação Type-Token:"))
hlr = float(input("Entre a Razão Hapax Legomana:"))
sal = float(input("Entre o tamanho médio de sentença:"))
sac = float(input("Entre a complexidade média da sentença:"))
pal = float(input("Entre o tamanho medio de frase:"))

return [wal, ttr, hlr, sal, sac, pal]

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 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(as_a, as_b):
'''IMPLEMENTAR. Essa funcao recebe duas assinaturas de texto e deve devolver o grau de similaridade nas assinaturas.'''
soma_temp = 0
for i in range(0,6):
soma_temp = soma_temp + (abs(as_a[i] - as_b[i]))

return soma_temp / 6

def calcula_assinatura(texto):
'''IMPLEMENTAR. Essa funcao recebe um texto e deve devolver a assinatura do texto.'''
sentencas = separa_sentencas(texto)
frases = []
palavras = []
meia_palavras = 0
meio_sentencas = 0
comp_sentenca = 0
rel_type_token = 0
hapax = 0
soma_car_sentenca = 0
soma_pal = 0
soma_car_frase = 0
tam_meio_frase = 0

for sentenca in sentencas:
soma_car_sentenca = soma_car_sentenca + len(sentenca)
l_frases = separa_frases(sentenca)

for f in l_frases:
frases.append(f)

for frase in frases:
soma_car_frase = soma_car_frase + len(frase)
l_pal = separa_palavras(frase)

for palavra in l_pal:
palavras.append(palavra)

for palavra in palavras:
soma_pal = soma_pal + len(palavra)

meia_palavras = soma_pal/len(palavras)
rel_type_token = n_palavras_diferentes(palavras)/len(palavras)
hapax = n_palavras_unicas(palavras)/len(palavras)
meio_sentencas = soma_car_sentenca / len(sentencas)
comp_sentenca = len(frases) / len(sentencas)
tam_meio_frase = soma_car_frase / len(frases)

return [meia_palavras, rel_type_token, hapax, meio_sentencas, comp_sentenca, tam_meio_frase]

def avalia_textos(textos, ass_cp):
'''IMPLEMENTAR. Essa funcao recebe uma lista de textos e deve devolver o numero (1 a n) do texto com maior probabilidade de ter sido infectado por COH-PIAH.'''
inf = []

for texto in textos:
ass_texto = calcula_assinatura(texto)
inf.append(compara_assinatura(ass_texto, ass_cp))

menor = inf[0]
c = 1

for i in range(1, len(inf)):
if (menor > inf[i]):
c = i
return c

def main():
assinatura = le_assinatura()
textos = le_textos()
c = avalia_textos(textos, assinatura)
print("O autor do texto {} está infectado com COH-PIAH".format(c))

main()

Postei meu codigo que implementei pro curso da USP - Coursera

ta funcionando e já consegui fazer valer nota 10..

valeu, espero ter ajudado..

Valeu Allan! Muito obrigado pela ajuda. Abs

Editado Fevereiro 11, 2022 por Matos Oliveira

Entrar

Tarefa de programação: Programa completo - Similaridades entre textos - Caso COH-PIAH

Pergunta

AVF99999999999999