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 vale45=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 vale35=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 outranãodevem 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 outranãodevem 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,aeb, é dado pela fórmula:
Sab=∑6i=1||fi,a−fi,b||6
Onde:
Sabé o grau de similaridade entre os textosaeb;
fi,aé o valor de cada traço linguísticoino textoa; e
fi,bé o valor de cada traço linguísticoino textob.
Perceba que quanto mais similaresaebforem, menorSabserá. 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çõesdevemser 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.
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:"))
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 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
Pergunta
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:
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:
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:
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
Link para o comentário
Compartilhar em outros sites
2 respostass a esta questão
Posts Recomendados
Participe da discussão
Você pode postar agora e se registrar depois. Se você já tem uma conta, acesse agora para postar com sua conta.