Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Proyecto: análisis de sentimientos

11/28
Recursos

Aportes 55

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

import numpy as np
import pandas as pd


def feeling(Tweet):
  tweet = Tweet.replace("!","").replace(",","").replace(".","").lower().split(" ")

  palabras =['muerte','pérdida','luto','excelente','gran','positivo','bueno','inteligente','ignorante','platzi','aprender','estudio','bien','queiro']

  palabras_positivas =["excelente","gran","quiero","positivo",'bien','positivo','bueno','inteligente']
  palabras_neutras = ["pérdida",'aprender','estudio','platzi']
  palabras_negativas = ["muerte","luto",'ignorante']

  w = []
  positivas = 0
  neutras = 0
  negativas = 0
  

  for i in palabras:
    w.append(tweet.count(i))
    if i in tweet and i in palabras_positivas:
      positivas += 1
    elif i in tweet and i in palabras_neutras:
      neutras += 1
    elif i in tweet and i in palabras_negativas:
      negativas += 1

  s = np.array([positivas,neutras,negativas])
  w = np.array(w)

  avg = (np.ones(w.size)/w.size).T.dot(w)
  score = s/(s[0]+s[1]+s[2])
  return Tweet,avg,score[0],score[1],score[2]

tweet1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"

tweet2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt"

tweet3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"

tweet4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"

tweets = [tweet1,tweet2,tweet3,tweet4]
resultados = []

for j in tweets:
  resultados.append(feeling(j))
  
df = pd.DataFrame(resultados, columns=["Tweet","Calidad","P_positiva","P_neutra","P_negativa"])
df

![](

A como yo entendí la calidad del tweet (avg) es el promedio de palabras que coinciden en el tweet con las palabras de nuestra base de datos, y los score de palabras positivas, neutras y negativas, son las proporciones (promedio) de que tan positivo, neutro o negativo es un tweet. Si la calidad (avg) es mas grande significa que hubo muchas palabras que coinciden y es mas fiable determinar el sentimiento del tweet, en cambio si pocas palabras coinciden es mas difícil determinar el sentimiento del tweet aunque las proporciones de cada sentimiento sean cercanas a 1.

Para ser sincero he tardado bastante, pero al final me gusto el resultado.
Creo que seria genial que en la clase se hubiera dado una solución, ademas de explicar un poco mejor algunas cosas como el avg que me costo entender a que se referia 😮

import numpy as np

symbols = ['*', '!', '.', ',', '?', '¿', '¡', '(', ')']
positive_words = ["excelente", "gran", "quiero", "positivo", 'bien', 'positivo', 'bueno', 'inteligente']
negative_words = ["muerte", "luto", 'ignorante']
neutral_words = ["pérdida", 'aprender', 'estudio', 'platzi', 'informéis']
tweet_one = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!"
tweet_two = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt"
tweet_three = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo.  Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet_fourth = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"


def get_split_words(text):
    for symbol in symbols:
        text = text.replace(symbol, " ")
    text_arr = text.split(" ")
    return text_arr


def get_vector_w(text, words_arr):
    vector_word = [text.count(i) for i in words_arr]
    return np.array(vector_word)


def get_vector_s(text):
    positive = get_vector_w(text, positive_words).sum()
    neutral = get_vector_w(text, neutral_words).sum()
    negative = get_vector_w(text, negative_words).sum()
    return np.array([positive, neutral, negative])


def get_score(tweet):
    vector_s = get_vector_s(tweet)
    score_vector = np.array([1, 0, -1])

    return [f'Text: {tweet}', f'Score: {np.dot(vector_s, score_vector)}', f'Positive: {get_avg(tweet, positive_words)}',
            f'Negative: {get_avg(tweet, negative_words)}', f'Neutral: {get_avg(tweet, neutral_words)}']


def get_avg(tweet, word_arr):
    w = get_vector_w(tweet, word_arr)
    avg = (np.ones(w.size) / w.size).T.dot(w)
    return avg


if __name__ == '__main__':
    one = get_score(tweet_one)
    for line in one:
        print(line)




Adjunto el código que utilice para desarrollar el reto, si alguien quiere hacer un feedback estaría agradecido.

import numpy as np 

class twit:
    
    positivos = ['bien', 'bueno', 'excelente', 'inteligente', 'intentando', 'quiero', 'saldrá', 'sigo', 'vamos', 'gran']
    neutrales = ['entiendo', 'plazti', 'alguien', 'asesora', 'asesorarme', 'clases', 'conocerme', 'debería', 'decir', 'descargue',
               'didáctico', 'docente', 'dónde', 'empiezo', 'enorme', 'funciones', 'grabación', 'gratuita', 'informéis', 'llama',
               'llamo', 'mexicano', 'nacional', 'noticiero', 'ocurre', 'plataforma', 'preparar', 'remando', 'saludo', 'señora', 'tendría',
               'todos', 'transmisión', 'universitario', 'ver', 'videos', 'vídeo', 'área']
    negativas = ['ignorante', 'luto', 'muerte', 'perdida']
    words_specials = positivo + neutral + negativa

    def __init__(self, string):
        self.string = string
        self.string_split = None
        self.w = np.zeros(len(self.words_specials)).reshape(-1, 1)
        self.s = np.zeros(3).reshape(-1, 1)
        self.avg = None
        self.score = None
        

    def fit(self):
        self.string_split = self.string.lower()
        self.string_split = self.string_split.replace('!', '').replace(',', '').replace('.', '').replace('(', '').replace(')', '').split()
        self.string_split = np.asarray(self.string_split)

        words, times = np.unique(self.string_split, return_counts=True)
        for i, j in enumerate(self.words_specials):
            if j in words:
                index = np.where(j)
                self.w[i] = times[index]
        
        for i in self.string_split:
            if i in self.positivos:
                self.s[0] += 1
            elif i in self.negativas:
                self.s[2] += 1
            elif i in self.neutrales:
                self.s[1] += 1
                
        self.avg = (np.ones(len(self.w)).reshape(-1, 1)/len(self.w)).T.dot(self.w)
        self.score = np.array([1, 0, -1]).dot(self.s)
    
    def print_result(self):
        print(f'El twit: {self.string}')
        print(f'Tiene una suma w de: {int(sum(self.w))}')
        print(f'Una s de: \n{self.s}')
        print(f'Un avg de: {float(self.avg)}')
        print(f'Un score de: {int(self.score)}')
        
a = 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!'
b = 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.'
c = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo'
d = 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'

a = twit(a)
a.fit()
a.print_result()

b = twit(b)
b.fit()
b.print_result()

c = twit(c)
c.fit()
c.print_result()

d = twit(d)
d.fit()
d.print_result()

Este es mi codigo!! Me encantaria que me den algunas sugerencias de que podria cambiar!.

    • El cuarto.
    • El primero.
  1. 0.18432539682539684
  2. Avg lo interpreto como la frecuencia con la que aparacen las palabras claves que elegimos en nuestro tweet. Score lo interpreto como el porcentaje que representa en cada tweet una emocion en concreto.
    5)La calidad esta relacionada con lo anterior ya que a mayor calidad(avg) , es mas la probabilidad(score) de que un tweet se identifique concretamente con el area especifica que lo representa (positividad, negatividad, neutro).
def palabras(tweet):
    palabras_positivas = ['gran', 'excelente', 'bueno', 'inteligente', 'bien', 'didáctico', 'gratuita']
    palabras_negativas = ['muerte', 'luto', 'perdida', 'ignorante']
    palabras_neutras = ['asesora', 'informéis', 'ver', 'conocerme','remando']
    total_p = palabras_neutras + palabras_negativas + palabras_positivas
    primer_tweet = 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!'
    segundo_tweet = 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.'
    tercer_tweet = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo'
    cuarto_tweet = 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'
    if tweet == 1:
        tweet = primer_tweet
    elif tweet == 2:
        tweet = segundo_tweet
    elif tweet == 3:
        tweet = tercer_tweet
    elif tweet == 4:
        tweet = cuarto_tweet

    tweet = tweet.replace('!', "").replace(',', "").replace('(', "").replace(')', "").replace('.', "").lower().split(" ")

    return palabras_positivas, palabras_neutras, palabras_negativas, tweet, total_p


def evaluar(palabras_positivas, palabras_neutras, palabras_negativas, tweet, total_p):
    vector_w = []
    positivas = 0
    negativas = 0
    neutras = 0

    for i in tweet:
        if i in total_p:
            vector_w.append(tweet.count(i))
        else:
            vector_w.append(0)

    for i in tweet:
        if i in palabras_positivas:
            positivas += 1
        elif i in palabras_negativas:
            negativas += 1
        elif i in palabras_neutras:
            neutras += 1

    vector_s = np.array([positivas, neutras, negativas])
    vector_w = np.array(vector_w)

    avg_w = np.dot(np.ones(vector_w.size)/vector_w.size, vector_w)
    avg_s = vector_s/(positivas+negativas+neutras)

    print(avg_s)
    return avg_w


if __name__ == '__main__':
    tweets = [1, 2, 3, 4]
    promedios_w = []

    for tweet in tweets:
        p, pn, pneg, tweet, total_p = palabras(tweet)
        w = evaluar(p, pn, pneg, tweet, total_p)
        promedios_w.append(w)

    print(f'Los promedios de calidad son: {promedios_w} el promedio general es {(sum(promedios_w))/4} ')```





Les comparto el enlace a mi código en Colab, en el cual justifico mis respuestas.

Nota: cambié algunas métricas a como consideré que era mejor para calificar.

Está interesante ver como hay tantas versiones para un mismo ejercicio.

No se ustedes, pero yo quedé en cero cuando intenté hacer el ejercicio, y eso me frustra un montón.
Aprender a programar es un camino LAAAARGO y hay muchísimo más por aprender.

Les aporto para el desafío de la clase, la forma en que construí las funciones en python para obtener los vectores w y s:

#Vector de conteo de palabras: define tu lista de palabras en w
w = ['muerte','pérdida','luto','excelente','gran','positivo','bueno','inteligente','ignorante','platzi','aprender','estudio']

#Vector de sentimientos positivas, neutras y negativas
#en este caso separe un subvector por cada categoría de sentimiento
s_positivas = ["excelente","gran","positivo","bien",'positivo','bueno','inteligente']
s_neutras = ["pérdida",'aprender','estudio']
s_negativas = ["muerte","luto",'ignorante']

def w_vector(x):
    return [x.count(i) for i in w] 


def s_vector(x):
    positivas =[x.count(i) for i in s_positivas]
    positivas= np.array(positivas)
    positivas = np.dot(positivas,np.array(positivas))
    
    neutras =[x.count(i) for i in s_neutras]
    neutras= np.array(neutras)
    neutras = np.dot(neutras,np.array(neutras))
    
    negativas =[x.count(i) for i in s_negativas]
    negativas= np.array(negativas)
    negativas = np.dot(negativas,np.array(negativas))
    
    return (positivas,neutras,negativas)```

Me interesa recibir la retroalimentación de ustedes para seguir mejorando juntos!

Mi código:

import numpy as np
import pandas as pd

#funcion para eliminar simbolos de puntuación y caracteres especiales, así como tokenizar el tweet para generar un vector
#la misma función crear arreglos vacíos de +, - y neutral, después recorre cada tweet y le asigna una puntuación dependiendo del numero de coincidencias con +, - y n.

def prep(tweet):
  tweet = tweet.replace("!","").replace(",","").replace(".","").replace("(","").replace(")","").lower().split(" ")

  palabras = ["gran", "excelente", "muerte", "enorme", "perdida", "luto", "bueno", "inteligente", "ignorante", "video", "entiendo","bien", "platzi", "docente", "sé", "funciones", "gratuita"]

  p_positiva = ["gran", "excelente", "bueno", "inteligente","bien", "platzi", "gratuita"]
  p_negativa = ["muerte", "enorme", "luto","ignorante"]
  p_neutra = ["enorme", "perdida", "video", "entiendo","platzi", "docente", "sé", "funciones"]

  w = []
  positivas = 0
  negativas = 0
  neutras = 0

  for i in palabras:
    w.append(tweet.count(i))
    if i in tweet and i in p_positiva:
      positivas += 1
    elif i in tweet and i in p_negativa:
      negativas += 1
    elif i in tweet and i in p_neutra:
      neutras += 1

  s  = np.array([positivas, negativas, neutras])
  w = np.array(w)

  avg = (np.ones(w.size)/w.size).T.dot(w)
  score = s/(s[0]+s[1]+s[2]) 
  return tweet,avg, score[0], score[1], score[2] 

tweet_1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
tweet_2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
tweet_3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet_4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
tweets = [tweet_1, tweet_2, tweet_3, tweet_4]
resultados = [] 

for j in tweets:
  resultados.append(prep(j))

df = pd.DataFrame(resultados, columns = ["Tweet", "Calidad", "P Positiva", "P Neutra", "P Negativa"])
df
tweets=[t1,t2,t3,t4]  ## aqui guarden los tweet a analizar...
import re  
import numpy as np 

def cuenta_palabras(tweet:str,palabra:str)->int:
    """Devuelve las veces que encontro cada palabra"""
    return len(re.findall(palabra,tweet.lower()))

def sentimental(tweet:str):
    """Devuelve el valor sentimental del tweet como un numero """
    positivas = ['gran', 'excelente', 'bueno', 'inteligente', 'bien', 'gratuita']
    negativas = ['muerte', 'luto', 'perdida', 'ignorante']
    neutras = ['asesora', 'informéis', 'ver', 'conocerme','remando']

    tipos_de_palabras=[positivas,neutras,negativas]
    valores_sentimientos=np.array([1,0,-1])
    conteo_de_palabras=np.array([0,0,0])
    for i,tipo in enumerate(tipos_de_palabras):
        #print(i,tipo) # pueden descomentar aqui para ver sobre que itera
        conteo_de_palabras[i]=np.array(list(map(lambda x: cuenta_palabras(tweet,x),tipo))).sum()
    #print( conteo_de_palabras) pueden descomentar aqui para ver 
    return conteo_de_palabras.dot(valores_sentimientos)

for i,t in enumerate(tweets):
    print(f'El sentimiento del tweet {i+1} es {sentimental(t)}') ```

Estoy atento a sus comentarios, me ayudo mucho el código de JassielMG:

import numpy as np
import pandas as pd


def Analisis_sentimientos(lista, positive_words, negative_words, neutral_words):
    tweet = lista
    lista = divide_per_words(lista)
    w_lista = w_vector(lista,positive_words,negative_words,neutral_words)
    s_lista = s_vector(lista,positive_words,negative_words,neutral_words)
    w_average = average(w_lista)
    s_score = score(s_lista)
    s_average = average(s_lista)
    return tweet , w_average, s_score, s_average 


def score(lista):
    lista = np.array(lista)    
    return [1,0,-1]@lista


def average(lista):
    lista = np.array(lista)      
    return (np.ones(lista.size)/lista.size).T.dot(lista)


def s_vector(lista, positive_words, negative_words, neutral_words):
    positive = 0
    negative = 0
    neutral = 0

    for word in lista:
        if word in positive_words:
            positive += 1
        if word in negative_words:
            negative += 1
        if word in neutral_words:
            neutral += 1
    
    return [positive, neutral, negative]


def w_vector(lista, positive, negative, neutral):
    words = positive + negative + neutral
    w_vec = []
    for i in words:
        w_vec.append(words.count(i))
    return w_vec


def divide_per_words(lista):

    per_words = lista.replace("!"," ")
    per_words = per_words.replace(",","").replace(".","").replace("(","").replace(")","").split(" ")
    per_words = minusculas(per_words)
    return per_words


def minusculas(lista):
  for i in range(len(lista)):
    lista[i]=lista[i].lower()
  return lista
  

def main():
    a = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
    b = "Vaya señora que bueno que se asesora por alquien inteligente no por el ignorante del Gatt."
    c = "Se me ocurre y sin ver todos los videos de Platzi que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
    d = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didactico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"

    positive_words = ["gran","excelente","bueno","inteligente"]
    neutral_words = ["mexicano","area","perdida","enorme","nacional","señora","asesora","alguien","inteligente","videos","platzi","informéis","empiezo","entiendo","tendria","decir","vamos","conocerme","asesorarme","saludo","docente","universitario","intentando","preparar","clases","didactico","noticiero"]
    negative_words = ["muerte","luto","ignorante"]

    result = []

    for lista in [a, b, c, d]:
        result.append(Analisis_sentimientos(lista, positive_words, negative_words, neutral_words))
    
    df = pd.DataFrame(result, columns = ["Tweet", "Calidad", "S_score", "S_average"])
    df.to_csv("analisis_de_sentimientos.csv", index=False)

if __name__ == "__main__":
    main()```

Código a utilizar para calcular vectores:

Este es mi codigo

def data_feeling(tweet: str):

    tweet = tweet.replace("!", "").replace(",", "").replace(".", "").lower().split(" ")

    palabras_positivas =["excelente","gran","quiero","positivo",'bien','positivo','bueno','inteligente']
    palabras_neutras = ["pérdida",'aprender','estudio','platzi']
    palabras_negativas = ["muerte","luto",'ignorante']
    palabra = palabras_positivas + palabras_negativas + palabras_neutras

    positivo = [ i for i in tweet if i in palabras_positivas]
    negativo = [i for i in tweet if i in palabras_negativas]
    neutro = [i for i in tweet if i in palabras_neutras]


    s = np.array([len(positivo), len(neutro), len(negativo)])
    w = np.array([tweet.count(i) for i in palabra])

    avg = (np.ones(w.size)/w.size).dot(w)
    score = s/(s.sum())

aquí esta mi reto 🎇

para tener datos mas precisos le asigne un valor a las palabras por ejemplo excelente tenia un 5 y bueno un 3

con estos datos hice un grafico para ver la relaxion entre el score(que tan positivo era) y la quality(cual era la calidad)

con esto respondí las preguntas

  1. vaya señora que… por que el score es uno de los mas altos y además el error generado por la quality del análisis es muy bajo por lo que se puede estar mas seguro de los datos
  2. gran mexicano… por que su score es negativa además de que calidad también es alta
  3. 0.17
  4. el avg score me indica la relaxion entre las palabras que se pudieron anáizar frente a las que no por lo que entre mas alto significa que mas se analizo y el score me mostraba la diferencia entre cuantas palabras negativas y positivas había, además personalmente lo divide por la longitud de la farce para que la comparación entre twits cortos a largos fuera mas equitativa
  5. el score me decía que tan positivo era y la quality me decía que segura era la predicción

espero que les haya ayudado les dejo el cod aca abajo

Esta clase pudo ser mucho más entretenida con un ejemplo realizado por el profesor. Terminé construyendo mi propio programa y haciendo todo por mi cuenta en esta clase.

Este es mi aporte al reto, le he añadido cosas interesantes que no he visto en otros comentarios, espero les guste.

mi set de palabras. 8 positivas, 4 neutras y 4 negativas.

palabras_positivas =['excelente','gran','quiero','positivo','bien','bueno','inteligente','saludo']
palabras_neutras = ['aprender','estudio','platzi','nacional']
palabras_negativas = ["muerte","luto",'ignorante','perdida']

mis funciones (les dejo una explicación):

  • En la funcion convertir_a_lista convierto todas las vocales con tilde a vocales sin tilde. (esto lo hago por medio de la opción translate. Es muy interesante, revisalo!, es sencillo)
  • Convierto las mayusculas a minusculas. (la palabra “Gran” del primer twit es la razón de hacer esto)
  • Tambien elimino parentesis, y soluciono el problema que comento el profe del twitter 4 en el que el signo de admiración está pegado a la siguiente palabra (esto lo hago reemplazando por un espacio " " en lugar de eliminar el caracter con “”.
import numpy as np

def convertir_a_lista(frase):
    filtro_tildes = ''.maketrans( "áéíóú", "aeiou")
    frase = frase.translate(filtro_tildes)
    frase = frase.lower()
    palabras = frase.replace("!"," ").replace(","," ").replace("("," ").replace(")"," ").replace("\n"," ")
    palabras = palabras.split(' ')
    return palabras

def conteo(palabras):
    keys = palabras_positivas + palabras_neutras + palabras_negativas
    return [palabras.count(key) for key in keys]

def sentimiento(w):
    return [sum(w[0:8]), sum(w[8:12]), sum(w[12:])]

def promedio(vector):
    n = len(vector)
    return (np.ones(n)/n).T @ vector

def score(vector):
    return np.array([1, 0, -1]) @ vector

Por último, hago todos los pasos para hallar el score y la calidad de cada twit.

palabras1 = convertir_a_lista(frase1)
palabras2 = convertir_a_lista(frase2)
palabras3 = convertir_a_lista(frase3)
palabras4 = convertir_a_lista(frase4)
# print(palabras1)

w1 = conteo(palabras1)
w2 = conteo(palabras2)
w3 = conteo(palabras3)
w4 = conteo(palabras4)
# print("w = ", w1)

s1 = sentimiento(w1)
s2 = sentimiento(w2)
s3 = sentimiento(w3)
s4 = sentimiento(w4)
# print("sentimiento = ", s1)

calidad1 = promedio(w1)
calidad2 = promedio(w2)
calidad3 = promedio(w3)
calidad4 = promedio(w4)
print("calidad = ", round(calidad1,2))
print("calidad = ", round(calidad2,2))
print("calidad = ", round(calidad3,2))
print("calidad = ", round(calidad4,2))

score1 = score(s1)
score2 = score(s2)
score3 = score(s3)
score4 = score(s4)
print("score = ", score1)
print("score = ", score2)
print("score = ", score3)
print("score = ", score4)

Con lo que determino que el twit más negativo es el primero.

Hola a todos, este fue el resultado del ejercicio propuesto:

Solo me quedo la duda con el score, lo que entendí es que teníamos que multiplicar el vector [1,0,-1] por los vectores que nos tiera de cada tweet (vector: [Ppositivas, Pneutras, Pnegativas]) y en base a esa multiplicación de vectores nos debería salir que sentimiento transmitía el tweet, sin embargo, no tiene mucho sentido porque el neutro se multiplica por cero y así nunca saldrían tweets neutros, así que no lo tomé en cuenta.

Respuestas a las preguntas realizadas:

Comparto el código que utilice:

def tweet_feelings(tweet, negativew, neutralw, positivew, all):
  positivos= 0
  negativos= 0
  neutros= 0

  a_= 'positivos'
  b_= 'negativos'
  c_= 'neutros'

  for i in all:
    if i in tweet and i in positivew:
      positivos += 1
    elif i in tweet and i in negativew:
      negativos += 1
    elif i in tweet and i in neutralw:
      neutros += 1
  
  resultado= [positivos, neutros, negativos]
  return resultado

def transformacion(res):
  tweet = [res]
  a= 'POSITIVOS'
  b= 'NEUTROS'
  c= 'NEGATIVOS'
  d= "NOS DEFINIDOS"

  for i in tweet:
    if i[0] > i[1] and i[0] > i[2]:
      return a
    elif i[1] > i[0] and i[1] > i[2]:
      return b
    elif i[2] > i[0] and i[2] > i[1]:
      return c
    else:
      return d

def count(cadena_a_contar):
  j= [cadena_a_contar]
  for i in j:
    a= i[0]+i[1]+i[2]
  return a

a = 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!'
b = 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.'
c = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo'
d = 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'

a = a.replace("!","").replace(",","").split(" ")
b = b.replace(".","").split(" ")
c = c.replace(",","").replace(".","").split(" ")
d = d.replace(",","").replace("!"," ").replace("(","").replace(")","").split(" ")

a = [i.upper() for i in a]
b = [i.upper() for i in b]
c = [i.upper() for i in c]
d = [i.upper() for i in d]
all = a+b+c+d

negative_words = ['PERDIDA', 'MUERTE', 'LUTO', 'IGNORANTE']
neutral_words = ['PLATZI', 'DOCENTE', 'TODOS', 'SOY', 'ALGO']
positive_words = ['GRAN', 'EXCELENTE', 'BUENO', 'INTELIGENTE', 'BIEN']
w= negative_words+neutral_words+positive_words

a_1= tweet_feelings(a, negative_words, neutral_words, positive_words, all)
b_1= tweet_feelings(b, negative_words, neutral_words, positive_words, all)
c_1= tweet_feelings(c, negative_words, neutral_words, positive_words, all)
d_1= tweet_feelings(d, negative_words, neutral_words, positive_words, all)


a_2= transformacion(a_1)
b_2= transformacion(b_1)
c_2= transformacion(c_1)
d_2= transformacion(d_1)

#CALIDAD DE NUESTRO FEELING TWEETS
total= int(len(w))
calidad_1= int(count(a_1))
calidad_2= int(count(b_1))
calidad_3= int(count(c_1))
calidad_4= int(count(d_1))

c_tweet1= (calidad_1/total)*100
c_tweet2= (calidad_2/total)*100
c_tweet3= (calidad_3/total)*100
c_tweet4= (calidad_4/total)*100

print("No. tweet|+ neutro - | vector:[+,N.-]|     % calidad     | ")
print("Tweet 1  | "+str(a_2)+" |   "+str(a_1)+"   |"+str(c_tweet1)+" |")
print("Tweet 2  | "+str(b_2)+" |   "+str(b_1)+"   |"+str(c_tweet2)+"  |")
print("Tweet 3  | "+str(c_2)+"   |   "+str(c_1)+"   |"+str(c_tweet3)+" |")
print("Tweet 4  | "+str(d_2)+"   |   "+str(d_1)+"   |"+str(c_tweet4)+"  |")

💻Mis solucion al reto.💻
Funciones:

import numpay as np

def split_words(text):
    for symbol in symbols:
        text= text.lower()
        text = text.replace(symbol, "")
    text_arr = text.split(" ")
    return text_arr

#vector w
def vector_w(tw,pa):
    vec=[]
    l=len(pa)
    for i in range(l):
        if pa[i] in tw:
            vec.append(1)
        else :
            vec.append(0)
    return vec

#Funcion vector _S
def vector_s(vector,n1,n2,n3):
    Sp=np.array(vector[0:n1]).dot(np.ones(n1-0))
    Sn=np.array(vector[n1:n2]).dot(np.ones(n2-n1))
    Sb=np.array(vector[n2:n3]).dot(np.ones(n3-n2))
    s=[Sp,Sn,Sb]
    return s

# Funcion avg
avg=lambda x :np.array(x).dot(np.ones(len(x)))/len(x)
avg2=lambda x :(np.ones(len(x))/float(len(x)))[email protected]


symbols = ['*', '!', '.', ',', '?', '¿', '¡', '(', ')']
positive_words = ["excelente", "gran", "quiero", "positivo", 'bien', 'positivo', 'bueno', 'inteligente']
negative_words = ["muerte", "luto", 'ignorante','perdida']
neutral_words = ['aprender', 'estudio', 'platzi', 'informéis','area','enorme','nacional','mexicano']
words=positive_words+neutral_words+negative_words
tweet_one = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!"
tweet_two = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt"
tweet_three = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo.  Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet_fourth = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"


Buenas noches, me tarde un poco pero finalmente pude terminar este proyecto, dando click aquí pueden visualizarlo. Ahora me toca responder las preguntas, en base al código que realice no hubo uno que fuera más negativo que los demás, hasta podría decir que todos fueron positivos pero el más positivo fue el último. Mi calidad promedio fue de 0.29, considero que no supe escoger las palabras necesarias para manejar los datos. Yo interpreto que a mayor sea mi avg mejor va a ser mi score.

Esta metodología para hacer proyectos es muy buena. Seria bueno implementarla en otros cursos.

Hola compañeros les comparto mi solución en deepnote, paso a paso espero les ayude.

link

Aquí esta mi código del reto jejeej ojala sea algo distinto

import numpy as np


def sentimientos(tweet=''):
    Tf = tweet.replace('!', ' ').replace(',', ' ').replace('.', ' ').replace('(', ' ').replace(')', ' ').split()
    s = [0, 0, 0]
    dic_palab = {
        'excelente': 0, 'gran': 0, 'positivo': 0, 'bien': 0, 'bueno': 0, 'inteligente': 0,
        'aprender': 0, 'estudio': 0, 'platzi': 0, 'pérdida': 0, 'muerte': 0, 'luto': 0, 'ignorante': 0
    }
    palabras_valor = {
        'excelente': 0, 'gran': 0, 'positivo': 0, 'bien': 0, 'bueno': 0, 'inteligente': 0, 'aprender': 1, 'estudio': 1,
        'platzi': 1, 'pérdida': 2, 'muerte': 2, 'luto': 2, 'ignorante': 2
    }
    for i in Tf:
        try:
            if dic_palab[i.lower()] >= 0:
                dic_palab[i.lower()] += 1
        except:
            continue
    w = list(dic_palab.values())
    for i in range(w.__len__()):
        if w[i] > 0:
            s[list(palabras_valor.values())[i]] += 1
    w = np.array(w)
    s = np.array([s])
    avg = (np.ones(len(w)) / len(w)).T.dot(w)
    score = s / s.sum()

    return avg, score


if __name__ == "__main__":
    tweet = [0, 0, 0, 0]
    tweet[0] = 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!'
    tweet[1] = 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.'
    tweet[2] = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo'
    tweet[3] = 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'
    resultados = [['Tweet', 'Calidad', 'Positivo', 'Neutro', 'Negativo']]

    for i in range(4):
        x, y = sentimientos(tweet[i])
        resultados.append(['tweet' + str(i + 1), x, y[0][0], y[0][1], y[0][2]])

    for i in resultados:
        print(i)

Mi código para realizar el análisis de sentimientos y la calidad del resultado. Usé la librería de REGEX de Python para eliminar signos de puntuación.

def sentimientos_2(enunciado):
  enunciado = re.sub(r'[^\w^\s]','',enunciado).lower().replace('á','a').replace('é','e').replace('í','i').replace('ó','o').replace('ú','u').replace('ñ','n').split(' ')
  print(enunciado)
  positivo = ['gran','excelente','bueno','inteligente','quiero','bien','didactico','vamos','interesante','todos']
  neutral = ['perdida','vaya','asesora','ocurre','donde','entiendo','quien','preparar']
  negativo = ['muerte','luto','ignorante','sin']
  keywords_array = positivo + neutral + negativo

  #creacion de w
  keywords_dict = {}
  for word in keywords_array:
    keywords_dict[word] = 0
  
  for key,value in keywords_dict.items():
    for word in enunciado:
      if word == key:
        keywords_dict[key] += 1
  
  w = []
  for word in keywords_array:
    w.append(keywords_dict[word])
  w = np.array(w)

  #creacion de s  
  feel_dict = {'positive': 0, 'neutral': 0, 'negative': 0}
  for word in enunciado:
    if word in positivo:
      feel_dict['positive'] += 1
    elif word in neutral:
      feel_dict['neutral'] += 1
    elif word in negativo:
      feel_dict['negative'] += 1

  s_v = []
  s_v = np.array([feel_dict['positive'],feel_dict['neutral'],feel_dict['negative']])
  print(s_v)
  unos = np.array([1 for i in range(len(w))])
  
  avg_w = np.dot((unos/len(w)),w)
  score_s = np.dot(np.array([1,0,-1]),s_v)

  return avg_w, score_s

Mis reultados fueron:

['gran', 'mexicano', 'y', 'excelente', 'en', 'su', 'area', 'su', 'muerte', 'es', 'una', 'enorme', 'perdida', 'y', 'deberia', 'ser', 'luto', 'nacional']
[2 1 2]
(0.2272727272727273, 0)
['vaya', 'senora', 'que', 'bueno', 'que', 'se', 'asesora', 'por', 'alguien', 'inteligente', 'no', 'por', 'el', 'ignorante', 'del', 'gatt']
[2 2 1]
(0.2272727272727273, 1)
['se', 'me', 'ocurre', 'y', 'sin', 'ver', 'todos', 'los', 'videos', 'de', 'plazti', 'que', 'me', 'informeis', 'por', 'donde', 'empiezo', 'entiendo', 'que', 'os', 'tendria', 'que', 'decir', 'quien', 'soy', 'y', 'que', 'quiero', 'vamos', 'conocerme', 'para', 'asesorarme', 'bien', 'un', 'saludo']
[4 4 1]
(0.4090909090909091, 3)
['soy', 'docente', 'universitario', 'estoy', 'intentando', 'preparar', 'mis', 'clases', 'en', 'modo', 'platzi', 'bien', 'didactico', 'le', 'llamo', 'modo', 'noticiero', 'descargue', 'una', 'plataforma', 'gratuita', 'de', 'grabacion', 'y', 'transmision', 'de', 'video', 'se', 'llama', 'obs', 'estudiobueno', 'la', 'sigo', 'remando', 'con', 'sus', 'funciones', 'pero', 'se', 'que', 'saldra', 'algo']
[2 1 0]
(0.13636363636363635, 2)

Les comparto mi código del reto:

import numpy as np
from collections import Counter

# Removed symbols and get a word list from string.
def get_words(string):
    string = string.lower()
    removed_symbols = ["¿","?","!","¡",",",";",".","(",")","[","]","{","}"]
    removed_connections = ["a", "ante", "bajo", "cabe", "con", "contra", "de",
                           "desde","durante", "en", "entre", "hacia", "hasta",
                           "mediante","para", "por", "segun", "sin", "so",
                           "sobre", "tras","versus","via", "y", "e", "ni",
                           "que", "ni", "solo", "no", "sino", "tambien",
                           "siquiera", "pero", "aunque", "porque", "debido",
                           "cuando", "como", "donde", "tan", "su", "tu", "mi"]
    removed_accents = {"á":"a","é":"e","í":"i","ó":"o","ú":"u"}

    # Removed unwanted symbols.
    for i in range(len(string)):
        if string[i] in removed_symbols:
            if i == 0 or string[i-1] == " ":
                new_string = string.replace(string[i],"")
            else:
                new_string = string.replace(string[i]," ")

    # Removed unwanted accents
    for rem, rep in removed_accents.items():
        new_string = new_string.replace(rem,rep)
    
    # Removed unwanted prepositions
    word_list = new_string.split(" ")
    npr_word_list = []
    for word in word_list:
        if word == "":
            continue
        elif word not in removed_connections:
            npr_word_list.append(word)

    return npr_word_list

def avg(vector):
    div = np.ones(len(vector)) * 1/len(vector)
    return round([email protected],4)

# Calculate the quality of the result, based on the number of instances
# of each word.

def calc_quality(word_list, searched_words):
    counted = []
    for searched in searched_words:
        counted.append(word_list.count(searched))
    qual_param = avg(np.array(counted))

    if qual_param < 0.5:
        return qual_param, "Bad quality"
    elif qual_param > 1:
        return qual_param, "Good quality"
    else:
        return qual_param, "Sufficient quality"

def calc_score(word_list, pos_words, neg_words):
    s = np.zeros(3)
    wgt = np.array([1,0,-1])

    for word in word_list:
        if word in pos_words:
            s[0] += 1
        elif word in neg_words:
            s[2] += 1
        else:
            s[1] += 1
    
    s_score = [email protected]
    if s_score < 0:
        s_tag = "Negative"
    elif s_score >= 1:
        s_tag = "Positive"
    else:
        s_tag = "Neutral"
        
    return s_score, s, avg(s), s_tag

pos_words = ["excelente","bueno","inteligente","asesorarme","saludo","bien",
             "gratuita","intentando","vamos","entiendo"]
neg_words = ["muerte","perdida","luto","ignorante"]

tweet1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
tweet2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
tweet3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
tweet5 = "Hola, que tal"
tweet6 = "El día de hoy me siento excelente, bien e inteligente. Si bien tuve que asesorarme por ignorante, fue bueno (excelente diría yo) poder hacerlo de forma gratuita. Entiendo será complicado, pero bueno, vamos intentando."

tweets = [tweet1, tweet2, tweet3, tweet4, tweet5, tweet6]
qualities, scores, s_avgs = [], [], []
i = 1
for tweet in tweets:
    words = get_words(tweet)
    qual_pts, qual_tag = calc_quality(words, pos_words+neg_words)
    score, s, s_avg, s_tag = calc_score(words, pos_words, neg_words)
    qualities.append(qual_pts)
    scores.append(score)
    s_avgs.append(s_avg)
    print(f"--- tweet {i}")
    print("Quote: ",tweet)
    print("Quality: ",qual_pts,", ",qual_tag)
    print("s: ", s)
    print("Sentiment score: ",score,", ",s_tag)
    print("Sentiment avg: ",s_avg)
    print()
    i+=1

print("\n·············\n")
print("Quality avg: ", round(np.array(qualities).mean(),4))
print("Score avg: ", round(np.array(scores).mean(),4))
print("Sentiment average avg: ", round(np.array(s_avgs).mean(),4))

Clasifique las palabras de esta manera, me parece interesante que ciertas palabras tuvieran pesos correspondientes a su nivel de positividad o negatividad.
https://colab.research.google.com/drive/11Ff7GFuliynu39sZWBHP4NxF3sth9l_a?usp=sharing

positive = ["gran", "excelente", "bueno", "inteligente", "platzi"]
negative = ["muerte", "perdida", "luto", "ignorante", "remando"]
neutral  = ["enorme", "asesora", "informéis", "empiezo", "entiendo", "conocerme", "asesorarme", "intentando", "gratuita"]

Vale la pena hacer el proyecto para consolidar conocimientos de python intermdio.
He aquí mi aporte:

https://colab.research.google.com/drive/19WcEiiaEwtj3vCuNdZy2Vde0yELC6tU5?usp=sharing

Vale la pena hacer el proyecto para consolidar conocimientos de python intermdio.
He aquí mi aporte:

Hola.
Comparto el script que desarrolle.
Con base a lo que entendí, el analizador se basa en dos factores: por una parte, el promedio general de sentimientos en donde indica que tan certera es la predicción del sentimiento, en donde, el valor mas cercano al 1 indica una predicción adecuada y el mas cercano a 0 indica una predicción no tan acertada.
Por otra parte, el promedio por cada rubro (positivo, negativo y neutro) indica en valores que, aquel que tenga el número mayor, es el que representa el sentimiento del tweet.
Esta interesante el ejercicio.

https://tuit.es/Hdzdr

import numpy as np


words = ['Gran', 'excelente', 'bueno', 'inteligente', 'bien','muerte', 'perdida', 'luto', 'ignorante', 'intentando', 'Entiendo', 'conocerme', 'saludo']


tw1 = 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!'
tw2 = 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.'
tw3 = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo'
tw4 = 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'



def estadarize (twit):
    symbols = ['!', ',', '.', '(', ')']
    for i in symbols:
        if i in twit:
            twit = twit.replace(i, ' ')
    twit = twit.split(' ')
    return twit

def word_count(twit):
    word_vector = np.array([0,0,0,0,0,0,0,0,0,0,0,0,0])
    for i, word in enumerate(words):
        if word in twit:
            count = twit.count(word)
            word_vector[i] = count
    return word_vector

def word_clasification(vector):
    vector = word_count(estadarize(vector))
    positive_vector = np.array([1,1,1,1,1,0,0,0,0,0,0,0,0])
    negative_vector = np.array([0,0,0,0,0,1,1,1,1,0,0,0,0])
    neutral_vector = np.array([0,0,0,0,0,0,0,0,0,1,1,1,1])
    positive = [email protected]_vector
    neutral = [email protected]_vector
    negative = [email protected]_vector

    clasification_vector = np.array([positive,neutral,negative])
    
    return clasification_vector

def run():
    print("""Los twits que se medirán son:
    1. Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!
    2. Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.
    3. Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo
    4. Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!
    """)
    print('--------------------------------------------------------------------------')

    one_vector = np.array([1,1,1,1,1,1,1,1,1,1,1,1,1])
    sentiment_vector = np.array([1,0,-1])
    
    
    prom1 = (word_count(estadarize(tw1))@one_vector)/13
    score1 = word_clasification(tw1)@sentiment_vector

    prom2 = (word_count(estadarize(tw2))@one_vector)/13
    score2 = word_clasification(tw2)@sentiment_vector

    prom3 = (word_count(estadarize(tw3))@one_vector)/13
    score3 = word_clasification(tw3)@sentiment_vector

    prom4 = (word_count(estadarize(tw4))@one_vector)/13
    score4 = word_clasification(tw4)@sentiment_vector

    print(f'puntaje primer twit: {score1}, su calidad es: {prom1} y tiene {word_clasification(tw1)[0]} palabras positivas, {word_clasification(tw1)[1]} neutras y {word_clasification(tw1)[2]} negativas')
    print(f'puntaje segundo twit: {score2}, su calidad es: {prom2} y tiene {word_clasification(tw2)[0]} palabras positivas, {word_clasification(tw2)[1]} neutras y {word_clasification(tw2)[2]} negativas')
    print(f'puntaje tercer twit: {score3}, su calidad es: {prom3} y tiene {word_clasification(tw3)[0]} palabras positivas, {word_clasification(tw3)[1]} neutras y {word_clasification(tw3)[2]} negativas')
    print(f'puntaje cuarto twit: {score4}, su calidad es: {prom4} y tiene {word_clasification(tw4)[0]} palabras positivas, {word_clasification(tw4)[1]} neutras y {word_clasification(tw4)[2]} negativas')
    


if __name__ == '__main__':
    run()

Creo que quedo más o menos, les comparto mi código

# %% [markdown]
# # Ejercicios
# %% [markdown]
# ## Problema 1: Análisis de sentimiento de tweets

# %%
# Tweets
A = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
B ="Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
C =  "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
D = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
TWEETS = (A,B,C,D)


# %%
PST_WORDS = ("excelente","gran","quiero","positivo",'bien','positivo','bueno','inteligente')

NTR_WORDS = ("pérdida",'aprender','estudio','platzi')

NGT_WORDS = ("muerte","luto",'ignorante')

PST_WORDS = tuple(set(PST_WORDS))
NTR_WORDS = tuple(set(NTR_WORDS))
NGT_WORDS = tuple(set(NGT_WORDS))
WORDS = PST_WORDS + NGT_WORDS + NTR_WORDS


# %%
def normalize_tweets(tweets: tuple) -> list:
    tweets_list = []
    for tweet in tweets:
        for i in "!().,":
            tweet = tweet.replace(i,"")
            tweet = tweet.lower()
        list_tweet = tweet.split()
        tweets_list.append(list_tweet)
    return tweets_list


# %%
tweets_list = normalize_tweets(TWEETS)


# %%
from collections import Counter


# %%
def counting_words(words: tuple, tweets_list: list) -> list:
    counted_words_list = []
    counted_words_vector = []

    for i in tweets_list:
        cw_dict = {}
        all_words_dict = Counter(i)

        for word in words:
            cw_dict[word] = all_words_dict.get(word,0)

        counted_words_list.append(cw_dict)
        counted_words_vector.append(list(cw_dict.values()))

    return counted_words_list, np.array(counted_words_vector)


# %%
counted_words, w_vectors = counting_words(WORDS, tweets_list)
w_vectors
# array([[0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
#        [0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
#        [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
#        [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0]])


# %%
def classified_vectors(counted_words:list, pst_words:tuple, ngt_words:tuple, ntr_words:tuple) -> list:
    classified_vector = []

    for cw_dict in words_counted:
        temp_list = [0,0,0]
        for word in pst_words:
            temp_list[0] += cw_dict.get(word,0)
        for word in ngt_words:
            temp_list[1] += cw_dict.get(word,0)
        for word in ntr_words:
            temp_list[2] += cw_dict.get(word,0)
        classified_vector.append(temp_list)

    return np.array(classified_vector)


# %%
s_vectors = classified_vectors(counted_words, PST_WORDS, NGT_WORDS, NTR_WORDS)
s_vectors

# array([[2, 2, 0],
#        [2, 1, 0],
#        [2, 0, 0],
#        [1, 0, 1]])


# %%
def avgs_vectors(vectors):
    avgs = []
    for i in vectors:
        avg_i = (np.ones(i.size) / i.size)[email protected]
        avgs.append(avg_i)
    return np.array(avgs)
    


# %%
avgs_w = avgs_vectors(w_vectors) 
avgs_s = avgs_vectors(s_vectors) 
avgs_w, avgs_s
# (array([0.28571429, 0.21428571, 0.14285714, 0.14285714]),
#  array([1.33333333, 1.        , 0.66666667, 0.66666667]))


# %%
def Pro_s(vectors):
    avgs = []
    for i in vectors:
        avg_i = i / np.sum(i)
        avgs.append(avg_i)
    return np.array(avgs)


# %%
P_s = Pro_s(s_vectors)
P_s
P_s_T=P_s.T
print(P_s)
# [[0.5        0.5        0.        ]
#  [0.66666667 0.33333333 0.        ]
#  [1.         0.         0.        ]
#  [0.5        0.         0.5       ]]


# %%
def score(s_vectors):
    scores = []
    for s in s_vectors:
        score = np.array((1, 0, -1)).dot(s)
        scores.append(score)
    return np.array(scores)


# %%
scores = score(s_vectors)
scores
#array([2, 2, 2, 0])


# %%
# Tweet más positivo
TWEETS[np.argmax(scores)]

# 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!'


# %%
# Tweet más negativo
TWEETS[np.argmin(scores)]
# 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'


# %%
# Calidad promedio
np.mean(scores)
"1.5"


# %%
#Interpretación de avg(s) y score(s)

#avg(s) te permite identificar la cantidad de palabras encontradas que se pudieron clasificar, un bajo promedio siginifica que no se encontraron palabras por lo que el modelo es menos preciso y un mayor promedio indica mayor precisión.

#score(s) te permite saber si un tweet contiene más palabras, positivas,negativas o neutras dependiendo su valor. Mayor score indica más palabar positivas, menor score palabras negativas y valor cercano a 0 significa que las palabras estan balanceadas.


# %%
#Relacion de la calidad con socre(s) y avg(s)

# A mayor calidad, tendremos más datos para confirmar que tanto el score como el avg son correctos, con poca calidad los datos del score y avg son poco representativos.


# %%
result = {"Tweet":TWEETS, "Calidad(w)":avgs_w, "Calidad(s)":avgs_s, "P+":P_s_T[0],"Pn":P_s_T[2],
"P-":P_s_T[1], "Score":scores}


# %%
import pandas as pd 
df = pd.DataFrame(result)


# %%
df
# Tweet	Calidad(w)	Calidad(s)	P+	Pn	P-	Score
# 0	Gran mexicano y excelente en su área, su muert...	0.285714	1.333333	0.500000	0.0	0.500000	2
# 1	Vaya señora que bueno que se asesora por algui...	0.214286	1.000000	0.666667	0.0	0.333333	2
# 2	Se me ocurre y sin ver todos los videos de Pla...	0.142857	0.666667	1.000000	0.0	0.000000	2
# 3	Soy docente universitario, estoy intentando pr...	0.142857	0.666667	0.500000	0.5	0.000000	0


# %%




import numpy as np

def formatearTweet(tweet):
  var = tweet
  var = var.replace("!","").replace(",","").replace("(","").replace(")","").replace(".","").split(" ")
  return var

def vector_words(tweet, words):
  vector_word = [tweet.count(i)
  for i in words]
  return np.array(vector_word)

def vector_emotional_words(tweet, positivo, neutro, negativo):
  positive = vector_words(tweet, positivo).sum()
  neutral = vector_words(tweet, neutro).sum()
  negative = vector_words(tweet, negativo).sum()
  return np.array([positive, neutral, negative])

def promedio(tweet, words):
  w = vector_words(tweet, words)
  avg = (np.ones(w.size) / w.size).T.dot(w)
  return avg

tweet1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
tweet2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
tweet3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
formatotweet1 = formatearTweet(tweet1)
formatotweet2 = formatearTweet(tweet2)
formatotweet3 = formatearTweet(tweet3)
formatotweet4 = formatearTweet(tweet4)

positive_words = ['excelente','gran','quiero','positivo','bien','positivo','bueno','inteligente']
neutral_words = ['pérdida','aprender','estudio','platzi','informéis']
negative_words = ['muerte','luto','ignorante']
words = positive_words+neutral_words+negative_words

palabras_tweet1 = vector_words(formatotweet1, words)
palabras_tweet2 = vector_words(formatotweet2, words)
palabras_tweet3 = vector_words(formatotweet3, words)
palabras_tweet4 = vector_words(formatotweet4, words)

vector_emocional1 = vector_emotional_words(formatotweet1, positive_words, neutral_words, negative_words)
vector_emocional2 = vector_emotional_words(formatotweet2, positive_words, neutral_words, negative_words)
vector_emocional3 = vector_emotional_words(formatotweet3, positive_words, neutral_words, negative_words)
vector_emocional4 = vector_emotional_words(formatotweet4, positive_words, neutral_words, negative_words)


promedio_positivo1 = promedio(formatotweet1, positive_words)
promedio_neutral1 = promedio(formatotweet1, neutral_words)
promedio_negativo1 = promedio(formatotweet1, negative_words)
promedio1 = np.array([promedio_positivo1, promedio_neutral1, promedio_negativo1])
promedio1


promedio_positivo2 = promedio(formatotweet2, positive_words)
promedio_neutral2 = promedio(formatotweet2, neutral_words)
promedio_negativo2 = promedio(formatotweet2, negative_words)
promedio2 = np.array([promedio_positivo2, promedio_neutral2, promedio_negativo2])
promedio2

promedio_positivo3 = promedio(formatotweet3, positive_words)
promedio_neutral3 = promedio(formatotweet3, neutral_words)
promedio_negativo3 = promedio(formatotweet3, negative_words)
promedio3 = np.array([promedio_positivo3, promedio_neutral3, promedio_negativo3])
promedio3

promedio_positivo4 = promedio(formatotweet4, positive_words)
promedio_neutral4 = promedio(formatotweet4, neutral_words)
promedio_negativo4 = promedio(formatotweet4, negative_words)
promedio4 = np.array([promedio_positivo4, promedio_neutral4, promedio_negativo4])
promedio4

respuestas:

  1. tweet 3
  2. tweet 1
  3. 0.1875
  4. la calidad de cada tweet en las palabras corresponde solo a una tercera parte de las emociones que se buscaban y por el promedio de emociones se puede ver que entre una décima y una tercera parte es de emociones positivas y solo es dos aparecen emociones negativas con un 66% y 33% respectivamente
  5. la relación entre la calidad y el promedio es cuantas palabras aparecer y el porcentaje de esas palabras con las emociones que representan.

Comparto mi version del Proyecto me costo un par de horas pero fue bueno para practicar 🤠. Añadí mas palabras para las comparaciones además vi que es mejor tener todas los caracteres en minúsculas, sin tildes o algún tipo de acento.

import numpy as np
import re
from unicodedata import normalize
import pandas as pd
p_positivas = ["excelente","gran","positivo","quiero","bueno","inteligente"]
p_neutras = ["aprender","estudio","platzi","ocurre","saludo","asesora"]
p_negativas = ["muerte","luto","ignorante","perdida"]

palabras=p_positivas+p_neutras+p_negativas

def clean_twit(twit):   
    twit = re.sub(
    	r"([^n\u0300-\u036f]|n(?!\u0303(?![\u0300-\u036f])))[\u0300-\u036f]+", r"\1", 
    	normalize( "NFD", twit), 0, re.I
    )
    return twit.replace("!","").replace(",","").lower().split(" ")

def calc_w(twit_limpio):
    w=np.zeros(len(palabras))
    for palabra in twit_limpio:
        for pal in palabras:
            if palabra==pal:
               w[palabras.index(pal)]+=1   
    return w
    
def calc_s(twit_limpio):
    positiva =0
    negativa=0
    neutra=0
    for palabra in twit_limpio:
        for posi in p_positivas:
            if palabra==posi:
                positiva+=1
        for nega in p_negativas:
            if palabra== nega:
                negativa+=1
        for neu in p_neutras:
            if palabra==neu:
                neutra+=1
    s=[positiva,neutra, negativa]
    return np.array(s)

def avg_w(twit_limpio):
    w=calc_w(twit_limpio)
    calidad = (np.ones(len(palabras))/len(palabras))
    return  np.dot(w,calidad)

def avg_s(twit_limpio):
    w=calc_w(twit_limpio)
    c_posi = (np.ones(len(p_positivas))/len(p_positivas))
    c_neu =  (np.ones(len(p_neutras))/len(p_neutras))
    c_nega = (np.ones(len(p_negativas))/len(p_negativas))
    s0=np.dot( c_posi, w[:len(p_positivas)]  ) 
    s1=np.dot( c_neu, w[len(p_positivas):len(p_neutras)+len(p_positivas)] )
    s2=np.dot (c_nega, w[len(p_neutras)+len(p_positivas):] )
    return np.array([s0,s1,s2])

def score(twit_limpio):
    s= calc_s(twit_limpio)
    aux =  np.array([1,0,-1])
    return np.dot(aux,s.transpose())


def run(twetts):
    resut=[]
    for i in twetts:
        twet=clean_twit(i)
        aux=[f't{twetts.index(i)+1}',avg_w(twet),avg_s(twet)[0],avg_s(twet)[1],avg_s(twet)[2],score(twet)]
        resut.append(aux)
    df = pd.DataFrame(resut, columns=["Tweet","Calidad","Calidad Positiva","Calidad Neutra","Calidad Negativa","Score"])
    print(df)

if __name__=="__main__":
    t1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
    t2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt"
    t3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
    t4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
    t5 = "Cómo easter egg dejo mi propio mensaje que malo fue tener una perdida economica al menos platzi me ayuda"
    twetts=[t1,t2,t3,t4,t5]
    run(twetts)
    

Pd añadí un twit propio 😄

Ignoré las palabras neutras porque me pareció difícil definirlas

import numpy as np

def eval_sent(tweet):
    tweet = tweet.replace('!',' ').replace('.','').replace(',','').replace('(','').replace(')','').split(' ')
    tweet = [tweet[i] for i in range(len(tweet)) if tweet[i] != '']
    w = [0,0,0,0,0,0,0,0,0]
    for word in range(len(tweet)):
        if tweet[word] == 'muerte':
            w[0] += 1
        elif tweet[word] == 'perdida':
            w[1] += 1
        elif tweet[word] == 'luto':
            w[2] += 1
        elif tweet[word] == 'ignorante':
            w[3] += 1
        elif tweet[word] == 'gran':
            w[4] += 1
        elif tweet[word] == 'positivo':
            w[5] += 1
        elif tweet[word] == 'bueno':
            w[6] += 1
        elif tweet[word] == 'inteligente':
            w[7] += 1
        elif tweet[word] == 'excelente':
            w[8] += 1
    s = [0,0]
    s[0] = sum(w[0:4])
    s[1] = sum(w[4:9])
    s = np.array(s)
    quality = np.average(w)
    avg_sent = np.average(s)
    weights = np.array([-1,1])
    score = [email protected]
    return quality, avg_sent, score


if __name__ == '__main__':
    a1 = 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!'
    a2 = 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.'
    a3 = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo'
    a4 = 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'

    print(f'Análisis de sentimientos (Qual of results, qual of feelings, feeling score):\nTweet 1: {eval_sent(a1)}\nTweet 2: {eval_sent(a2)}\nTweet 3: {eval_sent(a3)}\nTweet 4: {eval_sent(a4)}')```

Del segundo al cuarto tweet devuelve 1 como el valor máximo, el primer tuit salió como el más negativo con -1.
El promedio de los tuits fue 0,9125 aproximadamente.
Se puede interpretar el avg s como la calidad de coincidencia de la palabras en las listas y las que se encuentran en el tweet y el score s como el sentimiento del tweet. A medida que el avg s es más alto significa que el tweet posee las palabras de nuestro modelo y es más confiable el score s al determinar el sentimiento del tweet.

def feeling(tweet):
    vector_w = []
    positivas, neutras, negativas = 0, 0, 0
    tweet = tweet.replace(',','').replace('.','').replace('!','').replace('(','').replace(')','').lower().split(" ")
    
    palabras = ['gran','excelente','enorme','muerte','perdida','bueno','bien','inteligente','ignorante','platzi']
    palabras_positivas = ['excelente','bueno','bien','inteligente']
    palabras_neutras = ['gran','enorme','platzi']
    palabras_negativas = ['muerte', 'perdida','ignorante']
    
    for palabra in palabras:
        if palabra in tweet:
            vector_w.append(tweet.count(palabra))
        if palabra not in tweet:
            vector_w.append(0)
            
    for palabra in tweet:
        if palabra in palabras_positivas:
            positivas += 1
        elif palabra in palabras_neutras:
            neutras += 1
        elif palabra in palabras_negativas:
            negativas += 1
        
    vector_s = np.array([positivas, neutras, negativas])
    ponderacion = np.array([1,0,-1])
    score = np.dot(vector_s, ponderacion)
    avg_s = sum(vector_s) / len(vector_s)
    avg_w = sum(vector_w) / len(vector_w)
    
    string = f'vector w={vector_w}, vector s={vector_s}, score = {score}, avg_s = {avg_s}, avg_w = {avg_w}'
    
    return string```

Mi interpretación de la pregunta es:
avg(s) es el promedio de las emociones recaudadas en los tweet, lo que nos puede decir de una manera más globalizada cual es la emoción del tweet, de este modo podemos diferenciar un tweet de odio con uno de disgusto.
En cambio el score(s) Nos dice si un tweet es positivo o negativo. Al no tomar en cuenta las palabras neutras no medimos que tanto lo sea. Es decir que esto nos serviría para casos como clasificar si es un tweet positivo o negativo.

Aquí mi código (Acepto cualquier sugerencia para mejorar):

<import numpy as np
import collections

lista = ['gran','excelente','bueno','inteligente','muerte','perdida','luto','ignorante','nacional','videos','quiero','platzi','modo','de']


def reemplazo(tweet):
    return tweet.replace("!","").replace(",","").replace("(","").replace(")","").lower().split(" ")


def vector_s(tweet):
    positivas = [tweet.count(i) for i in lista[0:4]]
    negativas = [tweet.count(i) for i in lista[4:8]]
    neutras = [tweet.count(i) for i in lista [8:]]
    vector_s = [sum(positivas), sum(neutras), sum(negativas)]

    return vector_s

def vect_score(s):
    return np.dot(np.array([1, 0, -1]),s)


def vector_w(tweet):
    vector_w = [tweet.count(i) for i in lista]
    return vector_w

def promedio_vect(w):
    return round((sum(w)/len(lista)),4)



def analisis_sentimientos(tweet1,tweet2,tweet3,tweet4):
    tweet1 = reemplazo(tweet1)
    tweet2 = reemplazo(tweet2)
    tweet3 = reemplazo(tweet3)
    tweet4 = reemplazo(tweet4)

    vector_w1 = vector_w(tweet1)
    vector_w2 = vector_w(tweet2)
    vector_w3 = vector_w(tweet3)
    vector_w4 = vector_w(tweet4)

    vector_s1 = vector_s(tweet1)
    vector_s2 = vector_s(tweet2)
    vector_s3 = vector_s(tweet3)
    vector_s4 = vector_s(tweet4)

    promedio1 = promedio_vect(vector_w1)
    promedio2 = promedio_vect(vector_w2)
    promedio3 = promedio_vect(vector_w3)
    promedio4 = promedio_vect(vector_w4)

    score1 = vect_score(vector_s1)
    score2 = vect_score(vector_s2)
    score3 = vect_score(vector_s3)
    score4 = vect_score(vector_s4)

    calidad_media = round((promedio1 + promedio2 + promedio3 + promedio4)/4,4)

    
    tweet_positivo = max(score1,score2,score3,score4)

    if tweet_positivo == score1:
        respuesta="Tweet 1"
    elif tweet_positivo == score2:
        respuesta="Tweet 2"
    elif tweet_positivo == score3:
        respuesta="Tweet 3"
    else:
        respuesta="Tweet 4"


    tweet_negativo = min(score1,score2,score3,score4)

    if tweet_negativo == score1:
        respuesta2="Tweet 1"
    elif tweet_negativo == score2:
        respuesta2="Tweet 2"
    elif tweet_negativo == score3:
        respuesta2="Tweet 3"
    else:
        respuesta2="Tweet 4"
 

    print(f""" 
El tweet más positivo es el {respuesta} y el más negativo es el {respuesta2}. 
Por otra parte la insertidumbre de los 4 tweets es de {calidad_media}.
Cada tweet tiene una insertidumbre de:
    1: {promedio1}
    2: {promedio2}
    3: {promedio3}
    4: {promedio4}
:) """)
  
if __name__ == '__main__':
    tweet1 = 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!! '
    
    tweet2=  'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt. '
    
    tweet3 = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo '
    
    tweet4 = 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio! bueno la sigo remando con sus funciones pero sé que saldrá algo!'
    
    analisis_sentimientos(tweet1,tweet2,tweet3,tweet4)
>

import numpy as np

t1="Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
t2="Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
t3="Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
t4="Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"

scoreSenti = np.array([1,-1,0])

def tweet2words(x):
  w = x.replace(".","").replace(",","").replace("(","").replace(")","").replace("!"," ").lower().split(" ")
  w = [string for string in w if string != ""]
  return w

w1=tweet2words(t1)
w2=tweet2words(t2)
w3=tweet2words(t3)
w4=tweet2words(t4)

posi = ["gran", "excelente", "nacional", "mexicano", "bueno", "inteligente", "platzi", "empiezo", "entiendo", "bien", "quiero", "saludo", "docente", "universitario", "gratuita", "plazti"]
nega = ["muerte", "perdida", "luto", "no", "ignorante", "intentando", "remando"]

senti = posi+nega
todas = w1+w2+w3+w4

neu = []
for palabra in todas:
  if palabra in senti:
    next;
  else:
    neu.append(palabra)


def conteoPalabras(x,y):
  z=[]
  for i in x:
    z.append(y.count(i))
  return np.array(z)

def sentim(x):
  return np.array([sum(conteoPalabras(posi,x)), sum(conteoPalabras(nega,x)), sum(conteoPalabras(neu,x))])

def calidad(x):
  return sum(len(x)*conteoPalabras(posi+nega,x).T)

def score(x):
  return [email protected](x)

calidad(w1)
score(w1)

calidad(w2)
score(w2)

calidad(w3)
score(w3)

calidad(w4)
score(w4)

positive = ['excelente','bueno', 'inteligente', 'saludo','bien','gran','nacional','saludo','gratuita','mexicano']
negative = ['ignorante','muerte','luto','perdida']
neutral = ['platzi','video','enorme','plataforma', 'señora', 'estudio','ver','empiezo','que']

def compare(word_lst,tweet_lst):
  lst = []
  for i in word_lst:
    k = 0
    for j in tweet_lst:
      if i == j.lower():
        k += 1
    lst.append(k)
  return lst   


def feelings_detector(pos,neg,neutral,tweet):

  tweet = tweet.replace("!","").replace(",","").replace("(","").replace(")","").split(" ")
  #print(tweet)
  words = pos+neg+neutral
  w = compare(words, tweet)
  w_avarage = (np.ones(len(w)))/len(w)@w
  #print(w)
  print('avg(w):',w_avarage)
  pos_count = np.array(compare(pos, tweet))
  #print(pos_count)
  neg_count = np.array(compare(neg, tweet))
  #print(neg_count)
  neutral_count = np.array(compare(neutral,tweet))
  #print(neutral_count)
  s = np.array([np.ones(len(pos_count))[email protected]_count,np.ones(len(neutral_count))[email protected]_count,np.ones(len(neg_count))[email protected]_count])
  #print(s)
  s_avarage = (np.ones(len(s)))/len(s)@s
  print('avg(s):',s_avarage)
  score_s = np.array([1,0,-1])[email protected]
  print('score(s):',score_s)
  print('-----' * 10)
  return w_avarage, score_s



tweet1= "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
tweet2= "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
tweet3= "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet4= "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
tweets = [tweet1,tweet2,tweet3,tweet4]
mean = []
for tweet in tweets: 
  a,b = feelings_detector(positive,negative,neutral, tweet)
  mean.append(a)

mean = np.array(mean)
quality = np.ones(len(mean))/len(mean)@mean
print('calidad promedio:', quality)
<h3>avg(w): 0.34782608695652173
avg(s): 2.6666666666666665
score(s): 1.0</h3> <h3>avg(w): 0.2608695652173913
avg(s): 1.9999999999999998
score(s): 1.0</h3> <h3>avg(w): 0.30434782608695654
avg(s): 2.333333333333333
score(s): 2.0</h3> <h3>avg(w): 0.21739130434782608
avg(s): 1.6666666666666665
score(s): 2.0</h3>

calidad promedio: 0.28260869565217395

1.- los tweets 4 y 3 fueron los mas positivos
2.- los tweets 1 y 2 fueron los mas negativos
3.- calidad promedio: 0.28260869565217395
4.- el avg(s) nos indica el promedio de palabras asociadas a sentimientos (positivos,negativos, neutrales) por tweet
y el score(s) nos indica si el tweet es positivo o negativo, dependiendo del valor numerico que este tenga.
5.- mientras mayor sea el promedio de palabras asociadas a sentimientos (avg(s)) mayor va a ser la calidad, ya que a mayor avg(s) => un aumento en avg(w), lo que implica que la calidad aumente, por otra parte un score(s) que diste mucho del cero, implica un aumento en avg(s)

Concuerdo que el problema planteado es bastante confuso, aquí dejo mi versión :`).

PALABRAS =['muerte','pérdida','luto','excelente','gran','positivo','bueno','inteligente','ignorante','platzi','aprender','estudio','bien','queiro', "área"]
PALABRAS_POSITIVAS = ["excelente","gran","quiero","positivo",'bien','positivo','bueno','inteligente']
PALABRAS_NEUTRAS = ["pérdida",'aprender','estudio','platzi', "área"]
PALABRAS_NEGATIVAS = ["muerte","luto",'ignorante']

TWEETS = [
    "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!",
    "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.",
    "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir"+
    "quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo",
    "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue"+
    "una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
]


def calidad(publicacion):
    score = np.array([1, 0, -1])
    positivo, neutro, negativo = 0, 0, 0
    
    for palabra in publicacion:
        if palabra in PALABRAS_POSITIVAS:
            positivo += 1
        elif palabra in PALABRAS_NEGATIVAS:
            negativo += 1
        elif palabra in PALABRAS_NEUTRAS:
            neutro += 1
    s = np.array([positivo, neutro, negativo])
    puntaje_s = np.array([positivo, neutro*0, negativo*-1]) # No use esta variable, me pareció mas pertinente mostrar la cantidad de palabras de cada uno de los tres tipos.
    
    helper = np.ones(len(s)) / len(PALABRAS)
    promedio_s = s * helper
    
    return s, promedio_s
    

def cantidad(publicacion):
    palabras_dict = dict()
    for palabra in PALABRAS:
        palabras_dict[palabra] = 0
    
    for i in range(len(PALABRAS)):
        if PALABRAS[i] in publicacion:
            palabras_dict[PALABRAS[i]] += 1
    
    cantidad_w = []
    
    for j in palabras_dict.values():
        cantidad_w.append(j)
    
    promedio_w = np.array(cantidad_w).dot(np.ones(len(PALABRAS))/len(PALABRAS))
    
    
    return promedio_w


def analisis_tweets():
    data_tweet = []
    helper = []
    for publicacion in TWEETS:
        raw_publicacion = publicacion
        publicacion = publicacion.lower().replace("!", "").replace(",", "").split(" ")
        promedio_w = cantidad(publicacion)
        puntaje_s, promedio_s = calidad(publicacion)
        
        helper = [raw_publicacion, promedio_w, puntaje_s[0], promedio_s[0], puntaje_s[1], promedio_s[1], puntaje_s[2], promedio_s[2]]
        
        data_tweet.append(helper)
    
    return pd.DataFrame(data_tweet, columns=["Tweet", "W promedio", "C. positivo", "% positivo", "C.neutro", "% neutro", "C. negativo", "% negativo"])

data_f = analisis_tweets()
data_f
    

Mis resultados:
W1 = [1 0 1 0 0 0 0 0 0 0 0 2 1 1 1 0], Suma1 = [2 3 2],Average1 = 0.4375,Score1 = 0
W2 = [0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1], Suma2 = [2 1 0], Average2 = 0.1875, Score2 = 2
W3 = [0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0], Suma3 = [0 0 2], Average3 = 0.125, Score3 = -2
W4 = [0 0 0 0 0 1 0 0 1 0 1 3 0 0 0 0], Suma4 = [1 0 5], Average4 = 0.375, Score4 = -4

Haciendo un resumen de lo visto hasta ahora:

Los vectores

Se usan para representar información, además de que organizarlos de esta manera es mucho más facil operar los datos, nosotros podemos considerar como tratar los valores de un vector.

Ejemplo, aca consideramos que primero ibamos a contar la cantidad de palabras positivas y la cantidad de palabras negativas.

Hay otro vector que convierte esa cantidad en positivas o en negativas, ese vector es [1, 0, -1], por que nosotros decidimos representar la cantidad de palabras negativas con un numero negativo.

Las operaciones de los vectores son uan generalización de operar datos por separado, por eso es una buena practica manejar nuestros datos como vector, por que ahorraremos demasiado tiempo.

Algunas operaciones son:

  • suma
  • resta
  • multiplicacion por un escalar
  • producto interno o punto
  • division
import numpy as np

p_positiva = ["gran", "excelente", "bueno", "inteligente","bien", "platzi", "gratuita"]
p_negativa = ["muerte", "enorme", "luto","ignorante"]
p_neutra = ["enorme", "perdida", "video", "entiendo","platzi", "docente", "sé", "funciones"]
palabras=p_positiva+p_negativa+p_neutra
tweet_1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
tweet_2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
tweet_3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet_4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
tweets=[tweet_1,tweet_2,tweet_3,tweet_4]
def vector_w(texto):
    return [texto.count(i) for i in palabras]
def vector_s(lista):
    a=sum(lista[:len(p_positiva)])
    b=sum(lista[len(p_positiva):len(p_positiva)+len(p_negativa)])
    c=sum(lista[len(p_positiva)+len(p_negativa):])
    return [a,b,c]

promedios=[]
promedios_score=[]
score=[]
for i in tweets:
    w=vector_w(i)
    s=vector_s(w)
    promedios.append(sum(w)/len(palabras))
    promedios_score.append(sum(s)/len(s))
    score.append(np.dot([1,0,-1],s))
    
print("Tweets\t\tavg(w)\t\tavg(s)\t\tscore(s)")
for m,(n,p,q) in enumerate(zip(promedios,promedios_score,score)):
    print(f"Tweet{m+1}\t\t{n:.4f}\t\t{p:.4f}\t\t  {q: }")
import numpy as pd

twitts = ['Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!',
          'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.',
          'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo',
          'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'
          ]

positivas = ['excelente', 'bueno', 'inteligente', 'quiero', 'saludo', 'gratuita']
neutras = ['gran', 'enorme', 'perdida', 'ver', 'platzi', 'soy', 'didáctico']
negativas = ['muerte', 'luto', 'ignorante']
palabras = positivas + neutras + negativas
s_vector = []
w_vector = []
vector_score =  np.array([1,0,-1])
vector_calidad = (np.ones(len(palabras))/len(palabras))
scores = []
calidad = []

for i in twitts:
  w = []
  palabras_positivas = 0
  palabras_neutras = 0
  palabras_negativas = 0
  i = i.replace("!","").replace("y", "").replace(",","").lower().split(" ")
  for k in palabras:
    w.append(i.count(k))
  for j in i:
    for s in positivas:
      if j == s:
        palabras_positivas += 1
      continue#print(i.count(s))
    for s in neutras:
      if (s == j):
        palabras_neutras += 1
    for s in negativas:
      if (s == j):
        palabras_negativas +=1
    
  s_vector.append([palabras_positivas, palabras_neutras, palabras_negativas])
  w_vector.append(w)

for s in s_vector:
  scores.append(np.dot(s, vector_score))

for w in w_vector:
  calidad.append(np.dot(w, vector_calidad))

print("1. El tuit más positivo fue: ", max(scores))
print("2. El tuit más negativo fue: ", min(scores))
print("3. La calidad promedio es: ", sum(calidad)/len(calidad))
print("4. El score ofrece el puntaje del estado de ánimo, que tantas palabras se utilizaron en el vector")
print("5. La calidad es la cantidad de palabras que se utilizaron para calcular el score, es decir, entre mejor sea la calidad más fiable es el resultado del análisis de sentimientos")```
import numpy as np

cadenas=[]
cadenas.append("Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional didáctico didáctico descargue descargue luto!!!")
cadenas.append("Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.")
cadenas.append("Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo")
cadenas.append("Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!")

positiveWords=["Gran", "excelente" ,"nacional", "bueno" ,"inteligente" ,"asesora" ,"Plazti" ,"Entiendo" ,"asesorarme" ,"bien", "universitario", "docente", "didáctico"]
neutralWords=["mexicano", "área", "señora" ,"alguien", "preparar", "descargue"]
negativeWords=["muerte", "perdida", "luto", "ignorante"]

wordsList = positiveWords +  neutralWords + negativeWords

wVector=[]
sVector=[]

def countWords(cadena):
  temporalS=cadena.replace("!"," ").replace("."," ").replace(","," ").split(" ")
  w=[]
  s=[]
  for i in range(len(wordsList)):
    w.append(cadena.count(wordsList[i]))
  s.append(sum(w[0:len(positiveWords)]))
  s.append(sum(w[len(positiveWords):(len(wordsList)-len(negativeWords))]))
  s.append(sum(w[(len(positiveWords)+len(neutralWords)):len(wordsList)]))

  return w,s


peso=np.array([1,0,-1])

for z in range(len(cadenas)):
      w1,s1=countWords(cadenas[z])
      print(f"Para la cadena {z}, el  avg(s) es {sum(w1)/len(w1)} y el score(s) es {[email protected]}")

Dejo aquí mi código y mis respuestas, que dependen mucho de que palabras se tomen en cuenta

  1. Empate entre el tweet 3 y 4
  2. Según el código , el 1. Según yo, el 2
  3. 0.26
  4. Se que son cantidades diferentes, pero no entiendo cuál es la diferencia teórica entre avg(w) y avg(s). score(s) indica que tan positivo o negativo es un texto
  5. A mayor calidad, mayor confianza en el análisis

Lo hice de esta forma:

def sentimientos(x):
  l = []
  j = []
  k = []
  
  for word in x:
    if word in positivas:
      word = 1
      l.append(word)
      
    if word in negativas:
      word = 1
      j.append(word)
      

    if word in neutro:
      word = 1
      k.append(word)
      

  return np.array([np.sum(l) , np.sum(j) , np.sum(k)])      
  

Inspirado en el código de JassielMG

import numpy as np
import pandas as pd
pd.options.display.max_columns = None

def feeling(Tweet):
  tweet = Tweet.replace("!","").replace(","," ").replace("."," ").lower().split(" ")

  palabras_positivas =["excelente","gran","quiero","positivo",'bien','bueno','inteligente']
  palabras_neutras = ["pérdida",'aprender','estudio','platzi']
  palabras_negativas = ["muerte","luto",'ignorante']

  palabras =palabras_positivas+palabras_neutras+palabras_negativas

  cant_por_pal = []
  positivas = 0
  neutras = 0
  negativas = 0
  
  for i in palabras:
    #CANTIDAD POR CADA PALABRA EN UN TWEET
    cant_por_pal.append(tweet.count(i))
    #CONTAR SI LA PALABRA ESTA EN EL TWEET Y ES DE UN TIPO
    if i in tweet and i in palabras_positivas:
      positivas += 1
    elif i in tweet and i in palabras_neutras:
      neutras += 1
    elif i in tweet and i in palabras_negativas:
      negativas += 1

  cant_por_cat = np.array([positivas,neutras,negativas])
  score_por_cat = np.array([1,0,-1])
  cant_por_pal = np.array(cant_por_pal)
  #ONES(COLUMNAS)/ONES((FILAS,COLUMNAS)):RETORNA MATRIZ DE UNOS DE ESE TAMAÑO. CREA LA MATRIZ 1/N
  inversa_n = (1/cant_por_pal.size)*np.ones(cant_por_pal.size)
  avg = np.dot(inversa_n, cant_por_pal)
  score_total = np.dot(score_por_cat, cant_por_cat)
  return Tweet, avg, score_total

tweet1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
tweet2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt"
tweet3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
tweets = [tweet1,tweet2,tweet3,tweet4]
resultados = []

for j in tweets:
  resultados.append(feeling(j))
  
df = pd.DataFrame(resultados, columns=["Tweet","Calidad (avg)","Score"])
print(df,end='\n\n')
calidades=df['Calidad (avg)'].values[0:]
print(f'calidad promedio: {calidades.mean()}')
'''
                                               Tweet  					Calidad (avg)  	Score
0  Gran mexicano y excelente en su área, su muert...       	0.285714      	0
1  Vaya señora que bueno que se asesora por algui...      	0.214286      	1
2  Se me ocurre y sin ver todos los videos de Pla...       	0.142857      	2
3  Soy docente universitario, estoy intentando pr...      		0.142857      	1

calidad promedio: 0.1964285714285714
'''

RETO. Demoro un poco la verdad.

import numpy as np
import math as mate

class tweets:

    def __init__(self):
        
        self.positivos = ['excelente', 'gran','positivo','enorme','nacional','bueno','inteligente','platzi','empiezo','quiero','vamos','bien','universitario','preparar','didactico','gratuita']
        self.neutrales = ['entiendo', 'plazti', 'alguien', 'asesora', 'asesorarme', 'clases', 'conocerme', 'debería', 'decir', 'descargue', 'didáctico', 'docente', 'dónde', 'empiezo', 'enorme', 'funciones', 'grabación', 'gratuita', 'informéis', 'llama', 'llamo', 'mexicano', 'nacional', 'noticiero', 'ocurre', 'plataforma', 'preparar', 'remando', 'saludo', 'señora', 'tendría', 'todos', 'transmisión', 'universitario', 'ver', 'videos', 'vídeo', 'área']
        self.negativos = ['muerte', 'luto', 'ignorante','perdida','ignorante','remando']
        
    def dividir_en_palabras(self,string):

        self.string = string
        self.tweet_palabras = self.string.lower()
        self.tweet_palabras = self.tweet_palabras.replace("!","").replace(","," ").replace('.','').replace('(','').replace(')','').split(" ")
        self.tweet_palabras = np.asarray(self.tweet_palabras)
          

    def s_vector(self):

        s_vec = [0,0,0]
        lista = self.tweet_palabras

        for palabras in lista:
            if palabras in self.positivos:
                s_vec[0] += 1
                continue
            elif palabras in self.neutrales:
                s_vec[1] += 1
                continue
            elif palabras in self.negativos:
                s_vec[2] += 1
                continue
        
        return s_vec

    def w_vector(self):

        tweet = self.tweet_palabras
        palabras = self.positivos + self.neutrales + self.negativos
        w_vec = []
        for i in palabras:
            if i in tweet:
                w_vec.append(palabras.count(i))
            else: 
                w_vec.append(0)

        return w_vec

    def resultados(self, w_vec, s_vec):

        avg_w = (np.ones(len(w_vec)).reshape(-1,1)/len(w_vec)).T.dot(w_vec)
        score_s = np.array([1, 0, -1]).dot(s_vec)
        
        return float(avg_w), float(score_s)

    def respuestas(self, tweet_1, tweet_2, tweet_3, tweet_4):

        lista = [tweet_1, tweet_2, tweet_3, tweet_4]
        i = 0
        s_vectores = []
        w_vectores = []
        avg_w = []
        score_s = []

        for tweet in lista:
            self.dividir_en_palabras(tweet)
            s_vectores += self.s_vector()
            w_vectores += self.w_vector()
            a, b = self.resultados(self.w_vector(), self.s_vector())
            avg_w.append(a)
            score_s.append(b)
            i += 1

        s_vectores_arreglo = np.array(s_vectores)
        s_vectores_arreglo = s_vectores_arreglo.reshape(4,3)
        s_positivos = s_vectores_arreglo[:,0]
        s_negativos = s_vectores_arreglo[:,2]
        mas_positivo = int(np.asfarray(np.where(s_positivos == np.amax(s_positivos))))
        mas_negativo = int(np.asfarray(np.where(s_negativos == np.amax(s_negativos))))
        promedio = np.sum(w_vectores)/len(w_vectores)
        
        print("------RESPUESTAS --------")
        print(f'1.- ¿Que Tweet es mas positivo? ------------')
        print(f'El tweet mas positivo es: El Tweet N°{mas_positivo + 1}')
        print(f'2.- ¿Que Tweet es mas negativo? -----------')
        print(f'El tweet mas negativo es: El Tweet N°{mas_negativo + 1}')
        print(f'3.- ¿Cual es tu calidad promedio? -----------')
        print(f'La calidad de los Tweets es: {promedio}')
        print(f'4.- ¿Como interpretas avg(s) y score(s) ---------')
        j=0
        for i in avg_w:
            print(f'El Avg(w) del tweet N°{j + 1} es {i}')
        j=0
        for i in score_s:
            print(f'El Score(s) del tweet N°{j + 1} es {i}')

        print(f'El avg(w) es simplemente el promedio de palabras encontradas positivas, negativas y neutras entre la cantidad total')
        print(f'El score(s) lo entiendo como la valorizacion de cada tweet dandole valor 1 a palabras positivos, 0 a las neutras y -1 a negativos y definiendo asi si es mas positiva, mas neutra o mas negativa')
        print(f'5.- ¿Como relacionas la calidad con score(w) y avg(s)? -----------')
        print(f'la calidad solo se puede relacionar con el Avg(w)')      



if __name__ == '__main__':

    tweet_1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
    tweet_2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
    tweet_3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
    tweet_4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
       
    var = tweets()
    a = var.respuestas(tweet_1, tweet_2, tweet_3, tweet_4)
λ py proyecto_analisis2.py
------RESPUESTAS --------
1.- ¿Que Tweet es mas positivo? ------------
El tweet mas positivo es: El Tweet N°4
2.- ¿Que Tweet es mas negativo? -----------
El tweet mas negativo es: El Tweet N°1
3.- ¿Cual es tu calidad promedio? -----------
La calidad de los Tweets es: 0.3125
4.- ¿Como interpretas avg(s) y score(s) ---------
El Avg(w) del tweet N°1 es 0.26666666666666666
El Avg(w) del tweet N°1 es 0.15
El Avg(w) del tweet N°1 es 0.33333333333333337
El Avg(w) del tweet N°1 es 0.5
El Score(s) del tweet N°1 es 1.0
El Score(s) del tweet N°1 es 1.0
El Score(s) del tweet N°1 es 4.0
El Score(s) del tweet N°1 es 5.0
El avg(w) es simplemente el promedio de palabras encontradas positivas, negativas y neutras entre la cantidad total
El score(s) lo entiendo como la valorizacion de cada tweet dandole valor 1 a palabras positivos, 0 a las neutras y -1 a negativos y definiendo asi si es mas positiva, mas neutra o mas negativa
5.- ¿Como relacionas la calidad con score(w) y avg(s)? -----------
la calidad solo se puede relacionar con el Avg(w)

import numpy as np   

def feeling(tweet):
    tweet = tweet.replace("!","").replace(",","").split(" ")
    
    pala_pos = ['excelente','gran','quiero','positivo','bien','positivo','bueno','inteligente']
    pala_neu = ['pérdida','aprender','estudio','platzi']
    pala_neg = ['muerte','luto','ignorante']
    palabras = pala_pos + pala_neu + pala_neg
    
    w = []
    s = [0,0,0]
    for i in palabras:
        w.append(tweet.count(i))
        if i in tweet and i in pala_pos:
            s[0] += 1
        elif i in tweet and i in pala_neu:
            s[1] += 1
        elif i in tweet and i in pala_neg:
            s[2] += 1
    s = np.array(s)
    w = np.array(w)
    avg = ((np.ones(w.size))/w.size).dot(w)
    score = np.array([1,0,-1]).dot(s)
    print('Calidad promedio', avg)
    print('score', score)
a1 = 'Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!'
a2 = 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.'
a3 = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo'
a4 ='Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'

tweets = [a1,a2,a3,a4]
for i in tweets:
    print(i,"resultados")
    feeling(i)
import numpy as np

tweet_1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
tweet_2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt"
tweet_3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
tweet_4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"

def evaluar(tweet):

  print(tweet)

  caracteres_especiales = {"á":"a", "é":"e", "í":"i", "ó":"o","ú":"u","(":"",")":"","!":"",",":"",".":""}
  for k,v in caracteres_especiales.items():
    tweet = tweet.replace(k,caracteres_especiales[k])

  #print(tweet)
  tweet = tweet.lower().split(" ")


  positivas = ["excelente","gran","bueno","inteligente","bien","saludo","didactico","enorme"]
  neutras = ["nacional","noticiero","asesorarme","funciones","gratuita","asesora"]
  negativas= ["perdida","luto","muerte","ignorante"]

  n_positivas = 0
  n_neutras = 0
  n_negativas = 0

  total_palabras = positivas + neutras + negativas

  w = []
  for p in total_palabras:
     w.append(tweet.count(p))

  for p in tweet:
    if p in positivas:
      n_positivas += 1
    elif p in negativas:
      n_negativas += 1
    elif p in neutras:
      n_neutras += 1

  s = [n_positivas, n_neutras, n_negativas]

  vec =[1/len(w)]*len(w)

  w = np.array(w)
  s = np.array(s)
  vec = np.array(vec)

  avg = [email protected]
  score = np.array([1,0,-1])@s

  print(f"Vector  w: {w} = {sum(w)}")
  print(f"Vector  s: {s} = {sum(s)}")
  #print(f"{vec} = {sum(vec)}")
  print(f"Promedio: {avg}")
  print(f"Score: {score}")
  print("")

evaluar(tweet_1)
evaluar(tweet_2)
evaluar(tweet_3)
evaluar(tweet_4)

El average es cuanta confiabilidad tiene el análisis, pues si nos acercamos a 1 es porque tenemos todas las palabras seleccionadas, y si es cero es que no tenemos ninguna, el score califica la intención del tweet, aunque si el avg es bajo hay más incertidumbre

import numpy as np
import pandas as pd

def feelings_analysis(tweet):

    symbols = [';', '-', '*', '!', '.', ',', '?', '¿', '¡', '(', ')']
    tweet = tweet.replace(symbols,"").lower().split(" ")

    positive_words =['excelente','gran','positivo','bien','bueno','inteligente']
    neutral_words = ['aprender','estudio','platzi', 'asesora', 'asesorarme']
    negative_words = ['muerte','luto','ignorante', 'pérdida']

    words = positive_words + neutral_words + negative_words

    w = []
    positive_word = 0
    neutral_word = 0
    negative_word = 0

    for word in words:
        w.append(int(word in tweet))
        if word in tweet and word in positive_words:
            positive_word += 1
        elif word in tweet and word in neutral_words:
            neutral_word += 1
        elif word in tweet and word in negative_words:
            negative_word += 1

    s = np.array([[positive_word], [neutral_word], [negative_word]])
    w = np.array(w)

    print(s)

    avg = (np.ones(w.size)/w.size).T.dot(w)
    score = np.dot(np.array([-1, 0, 1]), s)

    print(score)
    return avg, score


def main():

    tweets = ['Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!', 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.', 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo', 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!']
    results = []

    for tweet in tweets:
        avg, score = feelings_analysis(tweet)
        print(avg, score)
        results.append([f'tweet {tweets.index(tweet)}', avg, score])

    df = pd.DataFrame(results, columns=["Tweet","avg","score"])
    print(df)


if __name__ == "__main__":

    main()```

Ahí va mi código, creo que quedó un poco largo pero quedó con clase y objetos

import numpy as np

palabras = ['muerte', 'pérdida', 'luto', 'excelente', 'gran', 'positivo']
palabras_positivas = ['excelente', 'gran', 'positivo']
palabras_negativas = ['pérdida']
palabras_neutras = ['muerte', 'luto']

tw_1 = 'Gran mexicano y excelente en su área, su muerte es una enorme pérdida y debería ser luto nacional!!!'
tw_2 = 'Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.'
tw_3 = 'Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. '
'Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo'
tw_4 = 'Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), '
'descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!'

class Tweet:

    def __init__(self, tweet):

        self.tweet = tweet
        self.contenido_tweet = self.tweet.replace("!","").replace(",","").lower().split(" ")
        self.palabras = palabras
        self.palabras_positivas = palabras_positivas
        self.palabras_negativas = palabras_negativas
        self.palabras_neutras = palabras_neutras
    
    def contenido_vector(self):

        w = [0 for i in range(len(palabras))]

        for _, palabra_tweet in enumerate(self.contenido_tweet):
            for j , palabra_palabras in enumerate(palabras):
                if palabra_tweet == palabra_palabras:
                    w[j] += 1
        
        return w

    def positividad(self):

        s = [0 for i in range(3)]
        for palabra in self.contenido_tweet:
            if palabra in palabras_positivas:
                s[0] += 1
            elif palabra in palabras_negativas:
                s[1] += 1
            elif palabra in palabras_neutras:
                s[2] += 1

        return s

    def promedio(self):

        n = len(self.contenido_tweet)
        w = self.contenido_vector()
        W = 0
        for i in w:
            W += w[i]
        
        avg = W / n

        return avg

    def score(self):
        s = self.positividad()
        score = np.dot([1,0,-1], s)

        return score

if __name__ == '__main__':
    
    tweet_procesado_1 = Tweet(tw_1)
    tweet_procesado_2 = Tweet(tw_2)
    tweet_procesado_3 = Tweet(tw_3)
    tweet_procesado_4 = Tweet(tw_4)

    print(tweet_procesado_1.positividad())
    print(tweet_procesado_1.promedio())
    print(tweet_procesado_1.score())

este es mi codigo

import numpy as np
a = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
a = a.lower().replace("!","").replace(",","").split(" ")

b = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
b = b.lower().replace(".","").split(" ")

c = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien. Un saludo"
c = c.lower().replace(".","").replace(",","").split(" ")

d = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"
d = d.lower().replace("!","").replace(",","").replace("(","").replace(")","").split(" ")

def evaluar(t):
  #positivas ws_0:4,negativas ws_4:6,neutrales ws_6:11
  ws = ['gran','excelente','inteligente','bueno','bien','ignorante','muerte','ver','enorme','decir','preparar','remando']
  w = [0 for x in range(12)]
  for i,word in enumerate(ws):
    for word_t in t:
      if word == word_t:
        w[i] += 1
  w = np.array(w)
  avg = np.array([1/len(w) for x in w])
  s = [0,0,0]
  for i,num in enumerate(w):
    if i >= 4 :
      s[0] += num
    elif i <4 and i >=6:
      s[2] += num
    else:
      s[1] += num
  score = np.array([1,0,-1])[email protected](s)
  print(score)
  print(avg[email protected])```
#ANALIZADOR DE SENTIMIENTO DE TWEETS
#FUNCIONAMIENTO BASICO
#Analiza en cada tweet la presencia de palabras de sentimiento (se las pasamos nosotros) y con ello identifica cuan de positivo o negativo es el contenido


#importamos la libreria para calculos con vectores
import numpy as np
#importamos la libreria para representacion grafica
import pandas as pd

#simbolos que queremos eliminar del texto
symbols = ['*', '!', '.', ',', '?', '¿', '¡', '(', ')']

#tweets que analizaremos
tweet_1 = "Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!"
tweet_2 = "Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt."
tweet_3 = "Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien.Un saludo"
tweet_4 = "Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!"

#arrays de palabras de sentimiento
positive_words = ["excelente", "gran", "quiero", "positivo", 'bien', 'positivo', 'bueno', 'inteligente']
negative_words = ["muerte", "luto", 'ignorante']
neutral_words = ["pérdida", 'aprender', 'estudio', 'platzi', 'informéis']

palabras = positive_words + neutral_words + negative_words


#Funcion para formatear el texto
def format(text):
  #symbols
  for symbol in symbols:
    text = text.replace(symbol," ")
    text = text.replace("  "," ")
  text = text.split(" ")
  return text

#funcion para contar el numero total de palabras de sentimiento
#devuelve un vector 's' de tres valores (positivo, neutro, negativo)
def feel_count(text,palabras): 
  positive = 0
  neutral = 0
  negative = 0

  format(text)

  for word in palabras:
    if word in text and word in positive_words:
      positive += 1
    if word in text and word in neutral_words:
      neutral += 1
    if word in text and word in negative_words:
      negative += 1
  s = np.array([positive, neutral, negative])
  return s


#Funcion para calcular la media de cada sentimiento
#devuelve un vector con la media de palabras presentes en cada indicador de sentimiento
def avg(s):
  s0 = s[0]/ len(positive_words)
  s1 = s[1]/ len(neutral_words)
  s2 = s[2]/ len(negative_words)
  return np.array([s0,s1,s2])


#Funcion para generar una nota de sentimiento
def score(s, pond=[1,0,-1]):
  return np.dot(pond,s)


tweets = [tweet_1,tweet_2,tweet_3,tweet_4]


#funcion para analizar todos los tweets
#devulve una tabla con los valores
def analyze(tweets):
  results = []
  for tweet in tweets:
    s = feel_count(tweet,palabras)
    avg_t = avg(s)
    score_t = score(s)
    result = tweet, score_t, avg_t[0], avg_t[1], avg_t[2]
    results.append(result)
  df = pd.DataFrame(results, columns=["tweet","Nota","+",":","-"])
  return df


if __name__ == "__main__":
    analyze(tweets)```