Con la suposición subrayada de que tiene un conocimiento muy básico o inexistente en ML / AI pero que es bueno con la programación específicamente con Python, entonces las cosas más simples pueden ser
- Analizador de sentimientos: aquí clasificará los sentimientos de un texto, ya sea utilizando tweets de Twitter, comentarios de Facebook o sus chats de WhatsApp.
- Paquetes y cosas que necesitará:
- Python (obviamente por programarlo)
- tweepy (paquete de python utilizado para obtener datos de twitter)
- paquete de Facebook Python (para obtener material de Facebook si está trabajando en comentarios de Facebook)
- Redis (tipo de base de datos de caché, útil en este tipo de cosas)
¿Suena como un proyecto cliché? hazlo genial usando el mismo analizador para tus chats de WhatsApp
- Necesitará un web scapper además de lo anterior. (Hermoso paquete de sopa estará en rescate aquí)
- crea una pequeña interfaz gráfica de tortuga usando python y únela con el web scrapper y será como una cosa suave.
Bien, ¿qué pasa si te proporciono un código para motivarte y hacerlo? suena bien ?
Nota: No hay comentarios en el código, solo descúbrelo por tu cuenta, en el proceso ahorrarás tiempo yendo aquí y allá específicamente entenderás las cosas principales
solicitudes de importación
importar al azar
importar nltk
de nltk.corpus importar palabras vacías, wordnet
importar re
english_stops = set (stopwords.words (‘english’))
def feature_extractor (documento):
características = {}
ls = []
para document_words en el documento:
para i, word in enumerate (document_words):
if ((word.lower () no en inglés_stops
y word.isalpha ())
o word.lower () == ‘no’):
syn = wordnet.synsets (word.lower ())
v = ‘no’
n = ‘no’
r = ‘no’
a = ‘no’
identidad = ‘desconocido’
si len (syn) es 0:
identidad = ‘desconocido’
Hacer continuación
más:
identidad = ‘conocido’
word = word.lower ()
características [‘contiene (% s) con identidad% s’% (word.lower (), identity)] = True
características de retorno
def pre_train_processor (enviado):
rd = re.sub (r ‘(^ @ | @) [^] +’, r “”, enviado)
rd = re.sub (r ‘(^ http | http) [^] +’, r “”, rd)
rd = re.sub (r ‘(\.) * \ 1’, r “.”, rd)
rep = re.findall (r ‘(\ w). * \ 1. * \ 1’, rd)
para ch en rep:
rd = re.sub (r ” + ch + ch + ch + r ‘+’, r ” + ch + ch, rd)
oraciones = nltk.sent_tokenize (rd)
oraciones = [nltk.word_tokenize (enviado) para enviado en oraciones]
devolver oraciones
def train_classifier ():
# resultado = {}
# result [‘data’] = escribe tu código para obtener los datos en los que quieres entrenar al clasificador
print len (resultado [‘datos’]. claves ())
cuenta = 0
para la clave en el resultado [‘datos’]. claves ():
cuenta + = 1
recuento de impresiones
# ingrese su propia lógica basada en datos aquí
# #
# tratar:
# para revisión en reslt:
# if review.get (‘reviewContent’) y len (review [‘reviewContent’]. strip ())> 10:
# final_resp.append ({‘rating’: review [‘totalRating’], ‘text’: review [‘reviewContent’]})
# excepto Excepción, e:
# print str (e)
# #
# para x en final_resp:
# data = feature_extractor (pre_train_processor (x [‘text’]))
# if x [‘rating’]> 3:
# tag = ‘bueno’
# elif x [‘rating’] == 3:
# tag = ‘moderado’
# más:
# tag = ‘malo’
# featuresets.append ((datos, etiqueta))
imprime “longitud del conjunto de datos:” + str (len (featureets))
feat_len = int (0.8 * len (featureets))
train_set, test_set = featuresets [: feat_len], featuresets [feat_len:]
clasificador = nltk.NaiveBayesClassifier.train (train_set)
print nltk.classify.accuracy (clasificador, test_set)
clasificador de retorno
def check_pos_hotels (clasificador, datos):
oraciones = pre_train_processor (datos)
feat = feature_extractor (oraciones)
res = {}
res [‘features’] = feat
res [‘tag’] = classifier.classify (feat)
volver res
2. Motor de recomendación de películas: ahora usa cualquier conjunto de datos de películas y recomienda a tus amigos según la elección que hagan
Nota: es un motor de recomendación basado en elementos, google acerca de la diferencia entre el elemento basado en el usuario lo obtendrá
Nuevamente para su motivación aquí va el código, esta vez con comentarios.
” ‘
Motor de recomendación de películas basado en la correlación entre las películas según la calificación del usuario
” ‘
” ‘
incluir paquetes importantes
” ‘
importar pandas como pd
# obtener los valores de csv
r_cols = [‘user_id’, ‘movie_id’, ‘rating’]
ratings = pd.read_csv (‘/ Users / saurabhpandey / Desktop / DataScience / ml-100k / u.data’, sep = ‘\ t’, names = r_cols, usecols = range (3))
m_cols = [‘movie_id’, ‘title’]
películas = pd.read_csv (‘/ Users / saurabhpandey / Desktop / DataScience / ml-100k / u.item’, sep = ‘|’, names = m_cols, usecols = range (2))
# hacer una tabla de fusión para valores apropiados
ratings = pd.merge (películas, clasificaciones)
user_ratings = ratings.pivot_table (index = [‘user_id’], columnas = [‘título’], valores = ‘calificación’)
# obtener la matriz de correlación
corrMatrix = user_ratings.corr (método = ‘pearson’, min_periods = 100)
# obtener mis propios comentarios
myRatings = user_ratings.loc [0] .dropna ()
# crea un objeto Serie, en lugar de una lista (son eficientes)
simCandidates = pd.Series ()
para i en rango (0, len (myRatings.index)):
# print “Agregando sims para” + myRatings.index [i] + “…”
# Recupere películas similares a esta que califiqué
sims = corrMatrix [myRatings.index [i]]. dropna ()
# Ahora escala su similitud según la calificación de esta película
sims = sims.map (lambda x: x * myRatings [i] if myRatings [i]> = 3 más x * myRatings [i] – myRatings [i])
# Agregue el puntaje a la lista de candidatos de similitud
simCandidates = simCandidates.append (sims)
# ordenar los valores según los valores de correlación
simCandidates.sort_values (inplace = True, ascendente = False)
# agruparlos por los nombres de la película, sumarlos (valores de correlación)
simCandidates = simCandidates.groupby (simCandidates.index) .sum ()
# ordenar la nueva lista
simCandidates.sort_values (inplace = True, ascendente = False)
# suelte la lista de nuestros propios nombres
filterSims = simCandidates.drop (myRatings.index)
# valores de impresión similares
imprimir filterSims.head (10)
Si alguien necesita el conjunto de datos, hágamelo saber, lo tengo.
3. Asistente virtual: L ike siri, cortona y demás. Tengo uno y él es Nemo.
Nuevamente, le estoy proporcionando el código porque a nivel del suelo necesita ayuda, necesitará una buena comprensión para ejecutar todas estas cosas, por lo que de ninguna manera no lo alimentaré con cuchara. No se ejecutará simplemente copiando, copiando y pegando.
Nota: La primera versión que hice, más estúpida pero funcionará.
importar discurso_reconocimiento como sr
importar os
r = sr.Recognizer ()
def sleep_computer ():
print (“aquí”)
os.system (“osascript -e ‘decirle a la aplicación \” Finder \ “que duerma'”)
mientras cierto:
con sr.Microphone () como fuente:
audio = r.listen (fuente)
tratar:
x = r.recognize_google (audio)
imprimir (x)
si “Nemo” en str (x):
os.system (“¡di SÍ MAESTRO!”)
si ‘apaga’ en str (x) o “apaga” en str (x):
os.system (“di OKAY MASTER !! APAGANDO”)
print (“aquí en”)
sleep_computer ()
excepto:
print (“error”)
Hacer continuación
PD: Hay muchas partes diferentes en este asistente, como leer mis correos electrónicos, si envío el cierre en cualquier correo, lo hace, enviándome sms en cada inicio de sesión y un correo electrónico con una imagen adjunta.
Avísame si necesitas más ideas.
Para obtener respuestas en el campo de AI / ML, también puede seguirme en quora (totalmente opcional: P)
¡¡Prestigio!!:)
