<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[LCC-Unison - Medium]]></title>
        <description><![CDATA[This place is designed for students of the Computer Science degree from the University of Sonora to share the work they have done. - Medium]]></description>
        <link>https://medium.com/lcc-unison?source=rss----5cd0f12fe579---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>LCC-Unison - Medium</title>
            <link>https://medium.com/lcc-unison?source=rss----5cd0f12fe579---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 09:10:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/lcc-unison" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Sistema de recomendador de trabajos]]></title>
            <link>https://medium.com/lcc-unison/sistema-de-recomendador-de-trabajos-c43b325e1?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/c43b325e1</guid>
            <category><![CDATA[pandas-tutorial]]></category>
            <category><![CDATA[recommender-systems]]></category>
            <category><![CDATA[clean-data]]></category>
            <category><![CDATA[cloud-services]]></category>
            <category><![CDATA[cosine-similarity]]></category>
            <dc:creator><![CDATA[Jesus M]]></dc:creator>
            <pubDate>Thu, 08 Dec 2022 03:24:00 GMT</pubDate>
            <atom:updated>2022-12-08T03:21:00.623Z</atom:updated>
            <content:encoded><![CDATA[<p>Una de las aplicaciónes que ha aportado el Machine Learning son los sistemas recomendadores. Debido al grado de efectividad que tienen podemos verlos cada día en una multitud de servicios que se consumen día a día. Netflix recomendando peliculas y series; Spotify con los artistas y canciones, o amazon recomendado nuevos artículos para comprar. Estos son uno de muchos ejemplos que se pueden utilizar para desarollar un sistema recomendador.</p><p>Antes del Machine Learning, lo más común era usar “rankings” ó listas con lo más votado, ó más popular de entre todos los productos. Entonces a todos los usuarios se les recomendaba lo mismo. Es una técnica que aún se usa y en muchos casos funciona bien, por ejemplo, en librerías ponen apartados con los libros más vendidos, best sellers.</p><h3>Métodos de sistema de recomendación</h3><p>Estos son algunos métodos de sistema de recomendación que existen.</p><p><strong>Collaborative</strong>: Es el más novedoso, pues utiliza la información de “masas” para identificar perfiles similares y aprender de los datos para recomendar productos de manera individual.</p><p><strong>Content-based</strong>: A partir de productos visitados por el usuario, se intenta predecir qué busca el usuario y ofrecer productos similares. Un ejemplo clásico es Amazón, en la que guiado por nuestras interacciones nos ofrece productos similares hasta que el algoritmo detecta nuestro cambio de “necesidad”. Este tipo de métodos de recomendación necesita recolectar información de tu perfil debido a que las recomendaciones se basan en características particulares de tu información como tu género, donde vives, cuantos años tienes.</p><p>Un ejemplo de un sistema recomendador basado en contenido es cuando ingresas una lista de géneros de peliculas que son de tu agrado cuando ingresas a Netflix por primera vez. O en nuestro sistema recomendador, que te recomienda puestos de trabajo según las skills que seleccionaste, como Python, R, Javascript, etc…</p><h3><strong>Elaboración de un sistema recomendador basado en contenido</strong></h3><p>Existen varias formas de construir un sistema de recomendación basado en contenido.</p><p>En nuestro caso, vamos a útilizar la <strong>similaridad de coseno</strong> utilizando librerías scikit learn y numpy para el procesamiento matricial.</p><h3>Obtenemos los datos</h3><p>Obtenemos el archivo csv de la página <a href="https://www.kaggle.com/datasets/lukebarousse/data-analyst-job-postings-google-search">https://www.kaggle.com/code/rayjohnsoncomedy/job-skills/data.</a></p><p>El archivo tiene muchas columnas innecesarias, entonces, para mejorar los tiempos de lectura solamente se dejaron las columnas “description” y “description_tokens”, que serían el nombre del trabajo y las skills respectivamente.</p><pre>import pandas as pd #cargar los datos<br>jobs = pd.read_csv(&#39;https://raw.githubusercontent.com/Jesusmaing/jobsRecommender/master/jobskills.csv&#39;,encoding=&#39;utf-8&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/852/1*o4DkElLnVm3aQwGi5N-_qA.png" /></figure><p>En este caso, el como podemos observar, dentro de cada trabajo y cada skills, viene separado por una coma, por lo que haremos limpieza de datos para pasar cada string con comas a una lista de strings.</p><pre>#Separamos en una lista de valores los trabajos<br>jobs[&#39;job&#39;] = jobs[&#39;job&#39;].str.split(&#39;,&#39;)<br>#Separamos en una lista de valores los skills<br>jobs[&#39;skills&#39;] = jobs[&#39;skills&#39;].str.split(&#39;,&#39;)</pre><p>Ahora, el set de datos luce de esta manera</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/825/1*DunKfPPf7IRMGo6x3XB0jg.png" /></figure><p>Despues de tener una lista de strings, es más fácil proceder con la limpieza de datos. Lo que se busca con esto es borrar listas vacías (que los trabajos no tengan skills), borrar duplicados y cualquier palabra innecesaria para el sistema recomendador.</p><pre>#Limpiamos los datos, pasamos a minúsculas, quitamos espacios al inicio y final y quitamos duplicados if skill is list and not float<br><br>#Pasamos todas las skills a minusculas y borramos espacios al final y al frente<br>#[ Python ]=&gt; [python]<br>jobs[&#39;skills&#39;] = jobs[&#39;skills&#39;].apply(lambda x: [i.lower().strip() for i in x] if type(x) is list else x)<br><br>#Borramos todas las listas nulas<br>jobs.dropna()<br><br>#Borramos todos aquellos valores que están vacías o que no son una lista de valores.<br>jobs = jobs[jobs[&#39;skills&#39;].map(lambda d: len(d) &gt; 0 if type(d) is list else False)]<br><br>#Debido a que todos los datos ahora se encuentran en minusculas, sin espacios<br>#y contienen información, aumenta la probabilidad de que haya valores repetidos<br>#por ende, borraremos todas aquellas skills que estén repetidas para reducir la cantidad de datos<br>jobs[&#39;skills&#39;] = jobs[&#39;skills&#39;].apply(lambda x: list(dict.fromkeys(x) ) if type(x) is list else x)</pre><p>Para observar como la distribución de nuestros datos, podemos utilizar una librería para procesamiento de lenguaje natural</p><pre><br>import nltk  as nltk#libreria de procesamiento de lenguaje natural<br>vocabulary1 = nltk.FreqDist() <br><br>#Este ciclo itera por el dataframe de skills<br>#Va añadiendo cada skill a una lista de frecuencias para obtener la cantidad de repetidos<br>for skill in jobs[&#39;skills&#39;]:<br>    if type(skill) is list:<br>        # delete empty skills<br>        if len(skill) &gt; 0:<br>            vocabulary1.update(skill)</pre><p>Una vez teniendo una lista de distribución de frecuencias, podemos observar que tanto se repite una skill dentro de todo el dataset de trabajos</p><pre>#Graficar la lista de frecuencias <br>fig , ax = plt.subplots(figsize=(40,32))<br>plt.barh([x[0] for x in vocabulary1.most_common(200)],[x[1] for x in vocabulary1.most_common(200)], label=&#39;skills&#39;)<br>ax.spines[&#39;right&#39;].set_visible(False)<br>ax.spines[&#39;top&#39;].set_visible(False)<br>ax.set_title(&#39;# Skills&#39;)<br>plt.title(&#39;Skills más comunes&#39;)<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OIuALU9-VEA1VsFPEjkcCA.png" /></figure><p>Como se puede observar en la gráfica, actualmente la skills más requerida en el mundo laboral de IT, es Java, luego siguen requiriendo desarolladores, programadores de base de datos en sql, etc…</p><h3><strong>Similaridad de coseno</strong></h3><p>El algoritmo de similitud de coseno se encarga de conocer el ángulo entre dos vectores n-dimensionales en un espacio n-dimensional. Esto significa que el resultado que obtendremos es el producto escalar de los dos vectores dividido por el producto de las longitudes o magnitudes de los dos vectores.</p><figure><img alt="Formula de similaridad de coseno" src="https://cdn-images-1.medium.com/max/429/1*hv7Snxrv738WaMPf1xvW6w.png" /></figure><p>Como dato interesante, el término de similitud de coseno proviene del término &lt;&lt;coseno de dirección&gt;&gt;.</p><h3>Casos de uso de la similitud de coseno</h3><p>Este importante cálculo se realiza en espacios positivos de alta dimensión. Esto es de gran utilidad en la recuperación de información valiosa y minería de textos. Para utilizarlo de forma eficiente a cada término se le asigna una dimensión diferente y al documento se le caracteriza por vectores. En cada uno de los vectores se asigna un valor para que corresponda con la dimensión en igual cantidad de veces. Así podemos detectar cuantas veces aparece un termino o un valor en un documento, ya que ejecutando el algoritmo obtenemos un conteo preciso de la información que buscamos. También puede ser utilizado para medir la cohesión de los grupos entre datos.</p><p>¿Cómo funciona la similitud de coseno?</p><ul><li>Es un valor que está limitado por un rago restringido de 0 y 1.</li><li>La medida de similitud mide el coseno del ángulo entre los dos vectores distintios de cero A y B</li><li>A medida que la medida de similitud del coseno se acerca a 1, el ángulo entre los dos vectores y B es más pequeño.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/488/0*g3HfHL_oj1D8u0Qq.png" /></figure><p>En el gráfico anterior, la similitud entre estos dos items es el angulo de Θ</p><p>Debido a que el algoritmo de similitud de coseno debe de calcularse mediante vectores númericos, y en el recomendador tenemos un vector de palabras, por ende, se necesita vectorizar y normalizar estos datos para obtener un vector númerico</p><p>Para ello, utilizaremos una librería de sklearn TfidfVectorizer, que se encarga de transformar texto en vector de caracteristicas.</p><pre>#Creamos una instancia para vectorizar los skills<br>vectorizer = TfidfVectorizer()<br># Pasamos la lista de Strings a un solo string con espacios para transformar los datos<br>tfidf_skills = vectorizer.fit_transform(jobs[&#39;skills&#39;].apply(lambda x: &#39; &#39;.join(x) if type(x) is list else x))</pre><p>Teniendo este vector normalizado, se puede utilizar la similaridad de coseno, para ello, se realizó una función que recibirá como parámetro una lista de Strings y hará todos el trabajo para regresar 20 recomendaciones según las skills mandadas como parámetro.</p><pre>def recommender(listOfSkills):      <br>    skills = listOfSkills<br>    #to lower case and remove spaces<br>    skills = [i.lower().strip() for i in skills]<br>    #remove duplicates<br>    skills = list(dict.fromkeys(skills))<br>    #all list of single string<br>    skills = &#39; &#39;.join(skills)<br>    #vectorize the skills<br>    skills = vectorizer.transform([skills])<br>    <br>    #se calcula la similitud del coseno de la lista de skills dadas con el resto de las listas de skills<br>    #con eso se va a obtener un vector de similitud con cada uno de los trabajos de la lista de trabajos    <br>    similarity_list = cosine_similarity(skills,tfidf_skills)<br>    <br>    #sort the list of similarity in order desc and get the index<br>    #es una lista sorteada de distancias de menor a mayor, nosotros necesitamos la mayor similitud, por eso se hace sort descendentemente <br>    #para obtener los indices de la mayor similitud<br>    sorted_indexes = np.argsort(similarity_list[0])[::-1]<br>    <br>    #get 10 recommendations jobs<br>    return jobs[&#39;job&#39;].iloc[sorted_indexes].values[0:20]</pre><pre>print(recommender([&#39;Data Science&#39;, &#39;R&#39;, &#39;Javascript&#39;]))</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*rszj8PYLXBXYQI2Qp8kACg.png" /></figure><p>Esto sería todo dentro del sistema recomendador, funciona bien y regresa trabajos haciendo sentido a las skills envíadas como parámetro.</p><h3><strong>Convertir el código a API</strong></h3><p>El código funcionaba de manera local, sin embargo, la finalidad de este proyecto es utilizar los servicios de la nube. Primeramente se recurrió a los servicios de<strong> Google Cloud Platform, </strong>pero los tiempo de respuestas y el manejo de seguridad estaba complicando el desarollo del sistema, por lo que recurrimos como segunda opción a <strong>Heroku, </strong>el siguiente paso fue convertir el código a una función que esté escuchando peticiones HTTP, para ello, se utilizó la librería de Python conocida como <strong>Flask</strong></p><p>También, el vectorizador y el dataframe limpiado, se pasaron a un archivo .pkl para cargarlos y no tener que aplicar <strong>fit_transform </strong>cada vez que se hace una llamada a la función.</p><pre>import joblib<br>joblib.dump(vectorizer, &quot;./vectorizer.pkl&quot;)<br>joblib.dump(tfidf_skills, &quot;./tfidf_skills.pkl&quot;)</pre><p>Se construye el servidor en Flask</p><pre>from flask import Flask, jsonify<br>from flask_restful import Resource, Api<br>from flask_cors import CORS<br><br>import json<br>import pandas as pd #cargar los daots<br>import numpy as np #operaciones matriciales<br>import nltk  as nltk#libreria de procesamiento de lenguaje natural<br>from sklearn.feature_extraction.text import TfidfVectorizer<br>from sklearn.metrics.pairwise import cosine_similarity<br>from flask import Flask, request, jsonify, make_response<br>import joblib<br>app = Flask(__name__)<br>api = Api(app)<br>CORS(app)</pre><pre>def recommender(skills): <br>    jobs = pd.read_csv(&#39;https://raw.githubusercontent.com/Jesusmaing/jobsRecommender/master/jobsCleaned.csv&#39;,encoding=&#39;utf-8&#39;)<br>    vectorizer = joblib.load(&quot;./vectorizer.pkl&quot;)<br>    tfidf_skills = joblib.load(&quot;./tfidf_skills.pkl&quot;)<br>    #to lower case and remove spaces<br>    skills = [i.lower().strip() for i in skills]<br>    #remove duplicates<br>    skills = list(dict.fromkeys(skills))<br>    #all list of single string<br>    skills = &#39; &#39;.join(skills)<br>    #vectorize the skills<br>    skills = vectorizer.transform([skills]) <br>    #se calcula la similitud del coseno de la lista de skills dadas con el resto de las listas de skills<br>    #con eso se va a obtener un vector de similitud con cada uno de los trabajos de la lista de trabajos    <br>    similarity_list = cosine_similarity(skills, tfidf_skills)<br>    <br>    #sort the list of similarity in order desc and get the index<br>    #es una lista sorteada de distancias de menor a mayor, nosotros necesitamos la mayor similitud, por eso se hace sort descendentemente <br>    #para obtener los indices de la mayor similitud<br>    sorted_indexes = np.argsort(similarity_list[0])[::-1]<br>    return json.dumps(jobs[&#39;job&#39;].iloc[sorted_indexes].values[0:20].tolist())</pre><pre>class status (Resource):<br>    def get(self):<br>        try:<br>            return {&#39;data&#39;: &#39;Api is Running, please type /recommender?skills=skill1,skill2,skill3&#39;}<br>        except:<br>            return {&#39;data&#39;: &#39;An Error Occurred during fetching Api&#39;}<br><br>class Recommender(Resource):<br>    def get(self):<br>        skills = request.args.get(&#39;skills&#39;)<br>        return jsonify({&#39;data&#39;: recommender(skills.split(&#39;,&#39;))})<br><br>api.add_resource(status, &#39;/&#39;)<br>api.add_resource(Recommender, &#39;/recommender&#39;)<br><br>if __name__ == &#39;__main__&#39;:<br>    app.run()</pre><p>Para obtener recomendaciones se tiene que hacer una petición a la URL que te proporciona el servidor de Heroku, o en donde sea el caso que se esté hosteando la API</p><p><a href="https://sistema-recomendador.herokuapp.com/recommender?skills=Python">https://sistema-recomendador.herokuapp.com/recommender?skills=Python</a>,Javascript &lt;= Aquí irán todas las skills que deseés introducir, separadas por coma.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a76vKt2cWOafZGcvpcJyWg.png" /></figure><p>Con esto concluimos la parte del desarollo de la API, ahora es turno para realizar un cliente que consuma esta API; en este caso, se desarolló en Angular.</p><h3><strong>Desarollando un cliente que consuma una API</strong></h3><p>Cualquier framework de frontend puede consumir esta api, solo basta con tener una librería que permita hacer HTTP REQUEST, para el caso de Angular, que su motor es nodeJS (Javascript), se utilizó la librería fetch, la cual utiliza métodos asíncronos para devolvernos una respuesta de lado del servidor</p><pre>  recomend(){<br>    fetch(&#39;https://sistema-recomendador.herokuapp.com/recommender?skills=Python,R,Javascript&#39;,<br>    ).then(res=&gt;{<br>      res.json().then(resp=&gt;{<br>        console.group(&#39;Recomendacion&#39;)<br>        console.log(&quot;Datos de la recomendacion&quot;, JSON.parse(resp[&#39;data&#39;]))<br>        console.groupEnd()<br>      }).catch(err=&gt;{ console.log(err) });<br>    }) <br>    return;<br>  }</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/507/1*-spmrpdh5v6oapdClelmVw.png" /></figure><p>El cliente está hosteado mediante Firebase Hosting, ya que nos proporciona un host gratuito y un dominio también gratuito, y al ser un proyecto escolar nos vemos beneficiados en ello.</p><p>Github del sistema recomendador</p><p><a href="https://github.com/Jesusmaing/jobsRecommender">GitHub - Jesusmaing/jobsRecommender</a></p><p>Github del cliente en Angular</p><p><a href="https://github.com/Antonio832/recommender">GitHub - Antonio832/recommender</a></p><p>Página(s) del cliente</p><ul><li><a href="https://recommendersystem-8431c.web.app/">Recomender</a></li><li><a href="https://jesusmaing.github.io/JobRecommender/">sistemarecomendador</a></li></ul><p>Página de la API</p><p><a href="https://sistema-recomendador.herokuapp.com/recommender?skills=Python">https://sistema-recomendador.herokuapp.com/recommender?skills=Python</a></p><p>El proyecto fue desarollado por Jesus Martin Garcia Encinas y Antonio Medina Valenzuela como proyecto final de Tópicos de Inteligencia Artificial en Ciencias de la Computación, UNISON.</p><p>Referencias</p><ul><li><a href="https://www.oreilly.com/library/view/statistics-for-machine/9781788295758/eb9cd609-e44a-40a2-9c3a-f16fc4f5289a.xhtml">Statistics for Machine Learning</a></li><li><a href="https://www.grapheverywhere.com/algoritmo-de-similitud-de-coseno/#:~:text=La%20similitud%20del%20coseno%20es,(0%2C%20%CF%80%5D%20radianes.">Algoritmo de similitud de coseno - Algoritmos de grafos</a></li><li><a href="https://www.engati.com/glossary/cosine-similarity">Cosine similarity | Engati</a></li><li><a href="https://medium.com/analytics-vidhya/flask-restful-api-with-heroku-da1ecf3e04b">Flask-RESTful API With Heroku</a></li><li><a href="https://towardsdatascience.com/building-a-recipe-recommendation-api-using-scikit-learn-nltk-docker-flask-and-heroku-bfc6c4bdd2d4">Building a Recipe Recommendation API using Scikit-Learn, NLTK, Docker, Flask, and Heroku</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q3TSg3-8Qb8O87FVXeAMeQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mpmerWalTnY5j2GPUVcXKQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WwgUjhlr9AxbSjn8IGTJsw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k7XqdHIYO0YJlLEguw9a3g.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I3MJVT_kB08DR_NgrZpoSw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c43b325e1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/sistema-de-recomendador-de-trabajos-c43b325e1">Sistema de recomendador de trabajos</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Recomendador de Canciones de Spotify usando KNN ( K-Nearest Neighbors)]]></title>
            <link>https://medium.com/lcc-unison/recomendador-de-canciones-de-spotify-usando-knn-k-nearest-neighbors-738c54453f46?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/738c54453f46</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <dc:creator><![CDATA[Jesus Pesqueira]]></dc:creator>
            <pubDate>Mon, 05 Dec 2022 18:57:36 GMT</pubDate>
            <atom:updated>2022-12-05T18:57:36.871Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*IwAmcXg1RtHlm1sZvjfbiQ.jpeg" /></figure><p>Jesus Ernesto Pesqueira Vasquez, Universidad de Sonora, Licenciatura en ciencias de la computación, Hermosillo, Sonora</p><h3>Introducción</h3><p>A quien no le gusta escuchar musica en estos tiempos, especialmente ahora que existen muchas plataformas donde escucharlas y lo mejor de todo es que estas apps cuentan con un motor de recomendacion que te lanzan canciones de acuerdo a tus preferencias y de manera regular. En este articulo hablaremos un poco sobre <strong>Machine Learning </strong>en particular el algoritmo <strong>KNN</strong>, ademas de las herramientas utilizadas para la elaboracion de la app y una aplicacion en la que tu tambien podras experimentar con el motor de recomedacion que se ha desarrollado.</p><h3>Antes que nada</h3><p>Antes de entrar a detalle, tenemos que saber un poco sobre que es un sistema de recomendación y tener una nocion de como funcionan estos.</p><p>Practicamente son algoritmos que intentas “predecir” los productos, canciones, etc que el usuario querra en particular.</p><p>Lo que tratan de lograr estos sistemas es ofrecer una mayor y mejor experiencia al usuario al estar recabando informacion acerca sus gustos y estar lanzadole resultados mas perzonalizado de acuerdo a sus busquedas ya sean productos, videos o canciones.</p><p>El sistema recomendador basa sus recomendaciones de las siguentes maneras:</p><ul><li><strong>Popularity</strong>: Aconseja por la “popularidad” de los productos. Por ejemplo, “los más vendidos” globalmente, se ofrecerán a todos los usuarios por igual sin aprovechar la personalización. Es fácil de implementar y en algunos casos es efectiva.</li><li><strong>Content-based</strong>: A partir de productos visitados por el usuario, se intenta “adivinar” qué busca el usuario y ofrecer mercancías similares.</li><li><strong>Colaborative</strong>: Es el más novedoso, pues utiliza la información de “masas” para identificar perfiles similares y aprender de los datos para recomendar productos de manera individual.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/950/1*-Uj5KMXCbW4DGq1f_9T2hA.png" /></figure><p>Mas a detalle sobre sistemas recomendaciones pueden consultar esta fuente <a href="https://www.aprendemachinelearning.com/sistemas-de-recomendacion/">https://www.aprendemachinelearning.com/sistemas-de-recomendacion/</a></p><h3><strong>Herramientas utilizadas para el desarrollo del sistema recomendador</strong></h3><p><strong>Streamlit</strong> : Es un framework de Python de código abierto que permite de manera sencilla e integrada desarrollar aplicaciones gracias a la interacción con otras librerías para su empleo en campos de la teledetección, ciencia de datos, etc.</p><p><strong>Lenguaje utilizado:</strong> Python para el desarrollo de la app web y aplicaciones de modelos de machine learning</p><p><strong>Kaggle:</strong> Utilizamos la libreta de jupyter que nos ofrece esta plataforma para el preprocesamiento del dataset utilizado ademas de proporcionarnos el dataset</p><p><strong>Algoritmo KNN (K-Nearest Neighbors): </strong>Es un clasificador de aprendizaje supervisado no paramétrico, que utiliza la proximidad para hacer clasificaciones o predicciones sobre la agrupación de un punto de datos individual.</p><blockquote>Para mas detalles acerca del algoritmo KNN puede visitar la siguiente fuente <a href="https://www.ibm.com/mx-es/topics/knn">https://www.ibm.com/mx-es/topics/knn</a></blockquote><h3>Desarrollo del sistema</h3><blockquote>La libreta para el preprocesamiento, el dataset y el codigo de la app se encuentran en el siguiente repositorio <a href="https://github.com/StarVeteran/Spotify-Recommender">https://github.com/StarVeteran/Spotify-Recommender</a> aqui pueden checar el codigo si lo desean.</blockquote><p>El primer paso para el desarrollo de sistema recomendador es encontrar un dataset adecuado para esta situacion y kaggle nos ofrece justo eso. Sacamos el dataset llamado <strong>Spotify and Genius Track Dataset </strong>de kaggle que contiene justo lo que necesitamos para nuestro sistema recomendador</p><p><a href="https://www.kaggle.com/datasets/saurabhshahane/spotgen-music-dataset">https://www.kaggle.com/datasets/saurabhshahane/spotgen-music-dataset</a></p><p>Para poder utilizar este dataset es necesario utlilizar una libreta de jupyter y cargar el dataset en kaggle para hacer un preprocesamiento para sacarle un mayor provecho.</p><blockquote>La libreta se encuentra en el repositorio de github</blockquote><p>Una vez que obtengamos el dataset preprocesador es hora de empezar a utilizarlos, primero que nada lo que ocuparemos es tener instalado los siguientes requerimientos para poder hacer funcionar la aplicacion que se encuentran en un archivo requirements.txt que se encuentra en el proyecto.</p><pre>streamlit==1.0.0<br>pandas==1.3.3<br>plotly==5.3.1<br>scikit-learn==0.23.2</pre><p>Una vez instalados los requerimientos podremos utilizar la app y analizar el codigo que contiene.</p><p>Empezamos con lo principal que se encuentra en app.py y estas son las librerias necesarias que utlizaremos.</p><pre>import streamlit as st<br>st.set_page_config(page_title=&quot;Song Recommendation&quot;, layout=&quot;wide&quot;)<br><br>import pandas as pd<br>from sklearn.neighbors import NearestNeighbors<br>import plotly.express as px<br>import streamlit.components.v1 as components</pre><p>Cargaremos el dataset para su uso</p><pre>@st.cache(allow_output_mutation=True)<br>def load_data():<br>    df = pd.read_csv(&quot;data/filtered_track_df.csv&quot;)<br>    df[&#39;genres&#39;] = df.genres.apply(lambda x: [i[1:-1] for i in str(x)[1:-1].split(&quot;, &quot;)])<br>    exploded_track_df = df.explode(&quot;genres&quot;)<br>    return exploded_track_df<br><br>genre_names = [&#39;Dance Pop&#39;, &#39;Electronic&#39;, &#39;Electropop&#39;, &#39;Hip Hop&#39;, &#39;Jazz&#39;, &#39;K-pop&#39;, &#39;Latin&#39;, &#39;Pop&#39;, &#39;Pop Rap&#39;, &#39;R&amp;B&#39;, &#39;Rock&#39;]<br>audio_feats = [&quot;acousticness&quot;, &quot;danceability&quot;, &quot;energy&quot;, &quot;instrumentalness&quot;, &quot;valence&quot;, &quot;tempo&quot;]<br><br>exploded_track_df = load_data()</pre><p>Una vez que se cargan los datos, podemos comenzar a construir un modelo de aprendizaje automático para recomendar canciones, hay muchas formas de implementar diferentes modelos, pero una simple es usar un modelo de k-vecino más cercano para obtener las mejores canciones que están más cerca del conjunto de parámetros seleccionados por el usuario. Estos parámetros incluyen el género de interés, el rango de años de lanzamiento (comienzo y final del año) y un conjunto de características de audio (acústica, bailabilidad, energía, instrumentación, valencia y tempo).</p><pre>def n_neighbors_uri_audio(genre, start_year, end_year, test_feat):<br>    genre = genre.lower()<br>    genre_data = exploded_track_df[(exploded_track_df[&quot;genres&quot;]==genre) &amp; (exploded_track_df[&quot;release_year&quot;]&gt;=start_year) &amp; (exploded_track_df[&quot;release_year&quot;]&lt;=end_year)]<br>    genre_data = genre_data.sort_values(by=&#39;popularity&#39;, ascending=False)[:500]<br><br>    neigh = NearestNeighbors()<br>    neigh.fit(genre_data[audio_feats].to_numpy())<br><br>    n_neighbors = neigh.kneighbors([test_feat], n_neighbors=len(genre_data), return_distance=False)[0]<br><br>    uris = genre_data.iloc[n_neighbors][&quot;uri&quot;].tolist()<br>    audios = genre_data.iloc[n_neighbors][audio_feats].to_numpy()<br>    return uris, audios</pre><p>Se utiliza Sklearn para armar el modelo KNN y devolver los top-k resultados dado un punto de prueba. Se escribe una funcion llamada n_neighbors_uri_audio que devuelve los URIs de Spotify y las caracteristicas de audio de los valores del top neighbors en orden ascendente.</p><p>Ya lo unico que faltaria es implementar la vista de la app para hacer funcionar el modelo.</p><pre>title = &quot;Song Recommendation Engine&quot;<br>st.title(title)<br><br>st.write(&quot;First of all, welcome! This is the place where you can customize what you want to listen to based on genre and several key audio features. Try playing around with different settings and listen to the songs recommended by our system!&quot;)<br>st.markdown(&quot;##&quot;)<br><br>with st.container():<br>    col1, col2,col3,col4 = st.columns((2,0.5,0.5,0.5))<br>    with col3:<br>        st.markdown(&quot;***Choose your genre:***&quot;)<br>        genre = st.radio(<br>            &quot;&quot;,<br>            genre_names, index=genre_names.index(&quot;Pop&quot;))<br>    with col1:<br>        st.markdown(&quot;***Choose features to customize:***&quot;)<br>        start_year, end_year = st.slider(<br>            &#39;Select the year range&#39;,<br>            1990, 2019, (2015, 2019)<br>        )<br>        acousticness = st.slider(<br>            &#39;Acousticness&#39;,<br>            0.0, 1.0, 0.5)<br>        danceability = st.slider(<br>            &#39;Danceability&#39;,<br>            0.0, 1.0, 0.5)<br>        energy = st.slider(<br>            &#39;Energy&#39;,<br>            0.0, 1.0, 0.5)<br>        instrumentalness = st.slider(<br>            &#39;Instrumentalness&#39;,<br>            0.0, 1.0, 0.0)<br>        valence = st.slider(<br>            &#39;Valence&#39;,<br>            0.0, 1.0, 0.45)<br>        tempo = st.slider(<br>            &#39;Tempo&#39;,<br>            0.0, 244.0, 118.0)<br><br>tracks_per_page = 6<br>test_feat = [acousticness, danceability, energy, instrumentalness, valence, tempo]<br>uris, audios = n_neighbors_uri_audio(genre, start_year, end_year, test_feat)<br><br>tracks = []<br>for uri in uris:<br>    track = &quot;&quot;&quot;&lt;iframe src=&quot;https://open.spotify.com/embed/track/{}&quot; width=&quot;260&quot; height=&quot;380&quot; frameborder=&quot;0&quot; allowtransparency=&quot;true&quot; allow=&quot;encrypted-media&quot;&gt;&lt;/iframe&gt;&quot;&quot;&quot;.format(uri)<br>    tracks.append(track)<br><br>if &#39;previous_inputs&#39; not in st.session_state:<br>    st.session_state[&#39;previous_inputs&#39;] = [genre, start_year, end_year] + test_feat<br><br>current_inputs = [genre, start_year, end_year] + test_feat<br>if current_inputs != st.session_state[&#39;previous_inputs&#39;]:<br>    if &#39;start_track_i&#39; in st.session_state:<br>        st.session_state[&#39;start_track_i&#39;] = 0<br>    st.session_state[&#39;previous_inputs&#39;] = current_inputs<br><br>if &#39;start_track_i&#39; not in st.session_state:<br>    st.session_state[&#39;start_track_i&#39;] = 0<br><br>with st.container():<br>    col1, col2, col3 = st.columns([2,1,2])<br>    if st.button(&quot;Recommend More Songs&quot;):<br>        if st.session_state[&#39;start_track_i&#39;] &lt; len(tracks):<br>            st.session_state[&#39;start_track_i&#39;] += tracks_per_page<br><br>    current_tracks = tracks[st.session_state[&#39;start_track_i&#39;]: st.session_state[&#39;start_track_i&#39;] + tracks_per_page]<br>    current_audios = audios[st.session_state[&#39;start_track_i&#39;]: st.session_state[&#39;start_track_i&#39;] + tracks_per_page]<br>    if st.session_state[&#39;start_track_i&#39;] &lt; len(tracks):<br>        for i, (track, audio) in enumerate(zip(current_tracks, current_audios)):<br>            if i%2==0:<br>                with col1:<br>                    components.html(<br>                        track,<br>                        height=400,<br>                    )<br>                    with st.expander(&quot;See more details&quot;):<br>                        df = pd.DataFrame(dict(<br>                        r=audio[:5],<br>                        theta=audio_feats[:5]))<br>                        fig = px.line_polar(df, r=&#39;r&#39;, theta=&#39;theta&#39;, line_close=True)<br>                        fig.update_layout(height=400, width=340)<br>                        st.plotly_chart(fig)<br>        <br>            else:<br>                with col3:<br>                    components.html(<br>                        track,<br>                        height=400,<br>                    )<br>                    with st.expander(&quot;See more details&quot;):<br>                        df = pd.DataFrame(dict(<br>                            r=audio[:5],<br>                            theta=audio_feats[:5]))<br>                        fig = px.line_polar(df, r=&#39;r&#39;, theta=&#39;theta&#39;, line_close=True)<br>                        fig.update_layout(height=400, width=340)<br>                        st.plotly_chart(fig)<br><br>    else:<br>        st.write(&quot;No songs left to recommend&quot;)</pre><p>Por lo cual nos arroja lo siguiente</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*U8I6ixPpvDulmQ7Zv65Cxg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*09TBg6iCaN09B50mRAkxcA.png" /></figure><p>Ya lo que quedaria es simplemente probarlo ya sea localmente con el comando <strong>streamlit run app.py </strong>o puedes hacerlo aqui <a href="https://starveteran-spotify-recommender-app-h5m1oy.streamlit.app/">https://starveteran-spotify-recommender-app-h5m1oy.streamlit.app/</a></p><p>La aplicacion fue desplegada de igual manera en streamlit, desarrollada en python y el procesamiento de datos fue hecha en una libreta de kaggle.</p><p>De antemano muchas gracias por tomarte tu tiempo en leer este articulo c:</p><p>Si deseas leer otro de mis articulos puedes consultarlo aqui:</p><p><a href="https://medium.com/lcc-unison/entrenamiento-de-ms-pacman-de-atari-con-una-red-neuronal-c9bd55c7b691">https://medium.com/lcc-unison/entrenamiento-de-ms-pacman-de-atari-con-una-red-neuronal-c9bd55c7b691</a></p><h3>Aqui se encuentra el repositorio de github si deseas consultarlo</h3><p><a href="https://github.com/StarVeteran/Spotify-Recommender">GitHub - StarVeteran/Spotify-Recommender: Sistema recomendador de canciones de spotify</a></p><h3>Referencias</h3><ul><li><a href="https://www.ibm.com/mx-es/topics/knn">¿Qué es KNN? | IBM</a></li><li><a href="https://www.analyticsvidhya.com/blog/2020/08/recommendation-system-k-nearest-neighbors/">Recommendation System using K-Nearest Neighbors |Use Case in Python</a></li><li><a href="https://www.aprendemachinelearning.com/sistemas-de-recomendacion/">Sistemas de Recomendación</a></li></ul><p><a href="https://streamlit.io/">https://streamlit.io</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=738c54453f46" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/recomendador-de-canciones-de-spotify-usando-knn-k-nearest-neighbors-738c54453f46">Recomendador de Canciones de Spotify usando KNN ( K-Nearest Neighbors)</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LCC-Recognition]]></title>
            <link>https://medium.com/lcc-unison/lcc-recognition-7b2b77a8716f?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/7b2b77a8716f</guid>
            <dc:creator><![CDATA[Jesus M]]></dc:creator>
            <pubDate>Fri, 27 May 2022 17:53:48 GMT</pubDate>
            <atom:updated>2023-05-23T21:25:19.152Z</atom:updated>
            <content:encoded><![CDATA[<p>Como proyecto final de Reconocimiento de Patrones para la carrera de Lic. Ciencias de la Computación de la Universidad de Sonora; se decidió realizar un proyecto que pudiera reconocer a alumnos que cursan en dicha carrera… Para este problema; se tenían dos variables</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*9ouwwcwMZCNZfJQyp8kEVQ.gif" /></figure><p>¿Cómo reconocer a una persona?</p><p>¿Cómo reconocer que esta persona es de LCC?</p><p>De aquí partió el proyecto <strong>LCC-Recognition</strong>. Un proyecto que se basa en reconocimiento facial en donde se terminó utilizando redes convolucionales profundas, permitiendo reconocer a una persona, y además reconocer que esa persona es de LCC gracias a una base de datos donde la persona se va a registrar con 2 o 3 fotos.</p><p>Como se mencionó en el párrafo anterior; actualmente se está utilizando una red convolucional profunda, con un modelo pre entrenado llamado FaceNet; el modelo ha sido entrenado utilizando (inserte nombre de la base de datos).</p><p>Para realizar el proceso del proyecto, se sigue un procedimiento.</p><ol><li>Leer todos los píxeles de la cámara</li><li>Detectar una cara</li><li>Reconocer la persona de dicha cara</li><li>Etiquetar el rostro reconocida</li><li>Presentar información del alumno reconocido</li></ol><p>Primero para leer los píxeles, utilizamos la librería de OpenCV con la cual se abre la cámara del dispositivo, leemos cada frame (imagen) y se guarda esta imagen como una matriz para después trabajar con ella.</p><p>Para detectar una cara, procedemos a envíar como parámetro la matriz del frame. Esta matriz se enviará a un modelo que reconocerá si es un rostro o no. Lo que hará el modelo es reconocer si dentro de esta matriz se encuentra algún patrón que indique que hay una cara en ese frame. Esto retornará un array de ubicaciones, donde estarán los rostros detectados con su respectivas coordenadas dentro de la cámara.</p><p>Para indicarle al usuario que está siendo detectado, se dibuja un cuadro delimitador que encerrará la cara del usuario.</p><p>Después, para reconocer si es un rostro, se manda la región de la cámara, en donde hay una cara. Esto se hace, para mejorar el rendimiento y precisión de la predicción, debido a que si se manda toda la región completa, el tiempo de predicción será mayor en comparación a solo mandar la cara. Para reconocer de quién es el rostro detectado, pasa por un proceso de extracción de características, donde se obtienen patrones como la naríz, los ojos, la frente, la boca, todos los rasgos característicos de una persona y se pasa por un modelo de machine learning para comparar esas características con un modelo entrenado con una base de datos (dataset) de personas ya etiquetadas.</p><p>Ya que detecta de quién es la cara, se muestra la matrícula del alumno, en el cuadro delimitador del rostro. Se deberá mostrar su mano abierta a la cámara para dar autorización de presentar su información, después de esto se extraerá la misma de una base de datos con todos los alumnos de la licenciatura y se mostrará en pantalla.</p><p><strong>Primeras versiones</strong></p><p>Inicialmente para detectar una cara, utilizamos el primer algoritmo para detectar una cara propuesto por Paul Viola y Michael Jones . Este algoritmo realiza la extracción de características y las almacena en un vector que se guardará en un archivo de datos serializados (.yml). La manera en la que realiza esta extracción de características es de la siguiente forma:</p><ol><li>Transforma la imagen a escala de grises para que no trabaje con tantos datos.</li><li>Se crea una caja que va recorriendo por todo el frame.</li><li>Se detecta si hay rostros en la caja mediante haar-features.</li></ol><figure><img alt="Haar-Features" src="https://cdn-images-1.medium.com/max/644/0*TAJn5J5hypNY3psu" /></figure><p>Ya que tenemos solo la imagen del rostro, aplicamos data augmentation mediante el método de pirámide, así expandiendo por factor de 10 nuestro conjunto de datos. Esto ayudará al algoritmo, a tener mayor precisión en la fase de predicción. Cabe resaltar que cada imagen está previamente clasificada por una estructura de carpetas nombradas por la matrícula como ID del usuario.</p><p>Utilizaremos el algoritmo de LBPH (Local Binary Patterns Histogram) para detectar de quién es dicha cara. El algoritmo se encarga de crear una imagen intermedia el cual tiene las características del rostro más resaltadas. Después se separa esta nueva imagen de una cuadrícula; se crea un histograma para cada cuadro el cual es de tamaño de 256 por la intensidad de píxel, y se muestra la ocurrencia de cada intensidad en un histograma. Al final se concatenan todos estos histogramas y queda un histograma único que define las características del rostro.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/0*GYC5j2nKIYq6kSCP" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QDCzUWmvEFrbPS3x" /></figure><p>Con esto podemos pasar a reconocer los rostros, que en esencia es repetir los pasos anteriores:</p><ol><li>Abrimos la cámara del dispositivo.</li><li>Extraemos cada fotograma y se realizan los siguientes pasos hasta que se cierre el programa.</li><li>Aplicamos Viola-Jones para extraer la cara del fotograma.</li><li>Aplicamos LBPH para obtener el histograma del cara.</li><li>Comparamos el histograma obtenido con los que tenemos entrenados.</li><li>Se retorna el id del rostro con el histograma mejor parecido.</li></ol><p>Cuando realizamos esto, el proceso era relativamente rápido, el problema que empezamos a tener era de que la precisión de reconocimiento era muy baja, y aunque aplicamos más data augmentation y limpieza de datos, no pudimos hacer que nuestro modelo reconociera con más de 60% de precisión. Por lo tanto decidimos cambiar el modelo e intentar con redes convolucionales siamesas.</p><h3><strong>Redes siamesas</strong></h3><p>Las redes siamesas, a comparación de cualquier red convolucional convencional, no intenta clasificar imágenes en etiquetas o categorías específicas, sino encontrar la distancia entre dos imágenes. Por ejemplo, si dos imágenes tienen la misma etiqueta, entonces la distancia entre ellas debe ser menor, pero si no cuentan con una etiqueta similar,tendrán una distancia mayor entre ellas. El proceso de estas redes es el siguiente:</p><ol><li>Se extraen dos imágenes de los datos de muestra, las cuales cada una serán procesadas por una red.</li><li>Ambas redes que se aplicaran a la imagen tienen la misma estructura, por lo que se realizarán las mismas operaciones en ambas.</li><li>Las últimas capas son Fully Connected Layers, en donde la última es la característica producida por la red aplicada a la imagen. Esta representación se conoce como embedding.</li><li>Después la Red busca la distancia euclidiana entre los embeddings de ambas imágenes. Si las imágenes son de la misma persona, se espera que los embeddings sean similares, por lo tanto la distancia debería ser menor.</li><li>Se aplica la función Sigmoide al valor de la distancia para tenerlo en el rango 0–1</li><li>Se aplica una función de pérdida al resultado para penalizar a la red a actualizar sus pesos y biases.</li></ol><p>Aunque este modelo suena muy bien en teoría, la realidad es que no era realmente útil en un entorno de prueba real. El modelo aprendía muy lento, es decir, se necesitaban muchas fotos para poder hacer que éste reconociera rostros de manera correcta</p><p>Para entrenar una red siamesa, se necesitan aproximadamente 300 fotos por persona para llegar a una precisión considerable, a lo que se puede utilizar el data augmentation, sin embargo, es poco práctico para el estudiante tener que sentarse a tomar fotos, y también es muy poca variación de los datos el hecho de tomar una pequeña cantidad fotos y re-escalar esas mismas fotos.</p><p>Otro problema con este modelo es que se necesitaba mucho poder de cómputo. Esta fue la principal razón por la cual abandonamos este modelo, ya que se tiene pensado que pudiera ser utilizado en computadoras más accesibles (una computadora de oficina decente con cámara).</p><p>En la búsqueda de una solución para este problema, encontramos una integración unificada para el reconocimiento facial, este modelo se le conoce como <strong>FaceNet</strong>; un modelo que tiene un conjunto de datos de más de 140 mil imágenes ya previamente etiquetadas, ayudando así a solo necesitar 2 o 3 fotos del alumno que se desea reconocer con un 99.2% de precisión.</p><p>Pero… ¿Cómo funciona FaceNet?</p><h3><strong>FaceNet</strong></h3><p>Facenet es un sistema de reconocimiento facial desarrollado por investigadores de Google creado en 2015. El sistema está basado en el aprendizaje mediante “incrustaciones”(embeddings) eucladianos por imágenes usando una red profunda convolucional. Similar al modelo anterior el modelo toma los embeddings de imágenes guardadas y las compara con una grabación o una cámara en tiempo real, toma las distancias donde las distancias menores corresponden a la misma persona y distancias mayores corresponden a personas distintas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/615/0*ded0OeJlIsQIPB8i" /></figure><p>La estructura del modelo consiste en una capa de entrada de lotes y una red neuronal convolucional, seguido de una normalización L2 que da como resultado Face Embedding. Al finalizar se usa una triple función de pérdida que minimiza la distancia entre un “ancla” y un valor negativo de una identidad diferente.</p><p>La red neuronal cuenta con una arquitectura llamada “Inception ResNet v1” está compuesta por distintas capas complejas de la siguiente manera:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/214/0*7_BeTH_IRfog6JEq" /></figure><p>Toda está arquitectura se ve más a fondo en el artículo <a href="https://arxiv.org/pdf/1602.07261.pdf">“Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning”</a></p><p>FaceNet a grandes rasgos funciona de la siguiente manera.</p><ol><li>Aleatoriamente selecciona una imagen “ancla”</li><li>Aleatoriamente selecciona una imagen de la misma persona como el ancla de la imagen (en el caso positivo)</li><li>Aleatoriamente selecciona una imagen de una persona diferente a la del “ancla” (caso negativo)</li><li>Se ajustan los parámetros de la conexión de FaceNet así el caso positivo será más cercano al caso negativo.</li></ol><p>Utilizamos otro modelo llamado MTCNN para reconocer caras usando una webcam, esto nos permite usar solamente el recuadro de imagen donde se encuentra la cara de la persona a reconocer, en lugar de tomar toda la imagen en su totalidad.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*3gKT2OnlHd9mFS7DfRRuuQ.jpeg" /></figure><p>Para finalizar utilizamos otro modelo para hacer hand tracking llamado MediaPipe, con el cual analizamos si el gesto de la mano es una palma abierta, entonces desplegamos información de la persona que se reconoce.</p><p>El proceso de nuestro algoritmo funciona de la siguiente manera:</p><ol><li>Se ejecuta la webcam la cual nos da una imagen del entorno.</li><li>Con MTCNN reconocemos una cara</li><li>Se calculan los embeddings de las imágenes en nuestra base de datos y de la cara reconocida.</li><li>Tomamos la distancia más corta entre los embeddings y clasificamos a la persona reconocida.</li><li>Reconocemos las manos, si se encuentra la palma abierta se muestra información de la persona reconocida, un pulgar arriba significa feedback positivo y un pulgar abajo significa feedback negativo.</li></ol><p>En la práctica este método resulta más eficiente utilizando una computadora con menos potencia de cálculo, y utilizando un promedio entre 1–3 imagenes por cada persona reconocer con una precisión entre 93–96%</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*X0hRWdowJdB9ucMc-56nKw.png" /></figure><p>El proyecto fue desarollado por:</p><ul><li>JESUS MARTIN GARCIA ENCINAS,</li><li>MARCO ANTONIO GUERRERO VAZQUEZ,</li><li>SEBASTIAN RIVERA DE LA CRUZ,</li><li>JESUS ISRAEL URIAS PARAMO</li></ul><p><strong>Parte 2 Desarrolando una aplicación en Android:</strong></p><p>Una vez que teníamos un modelo eficiente y preciso de reconocimiento facial utilizando FaceNet, decidimos llevarlo al siguiente nivel creando una aplicación en Android. Esto facilitaría la interacción con el usuario final y además permitiría la portabilidad de nuestra solución.</p><ol><li><strong>Exportar el modelo de TensorFlow</strong>: Primero, tuvimos que exportar nuestro modelo de FaceNet entrenado como un modelo TensorFlow. TensorFlow proporciona herramientas para convertir modelos entrenados en un formato que se puede utilizar en dispositivos móviles, denominado TensorFlow Lite. Este formato es más ligero y está optimizado para su uso en dispositivos con recursos limitados, como teléfonos móviles. Utilizamos el convertidor de TensorFlow Lite para convertir nuestro modelo.</li><li><strong>Incorporar el modelo en la aplicación Android:</strong> Después de convertir el modelo, lo incorporamos en nuestra aplicación Android. Para hacer esto, colocamos el archivo del modelo TensorFlow Lite en el directorio de recursos de la aplicación y luego usamos la API de TensorFlow Lite para Android para cargar el modelo y utilizarlo para las predicciones.</li><li><strong>Implementar la interfaz de usuario</strong>: La interfaz de usuario de la aplicación se diseñó para ser intuitiva y fácil de usar. Incluye una pantalla de inicio, una pantalla de configuración para registrar nuevas caras en el sistema y una pantalla principal que muestra la vista de la cámara en tiempo real y los resultados del reconocimiento facial.</li><li><strong>Procesamiento de imágenes en tiempo real</strong>: Para procesar las imágenes de la cámara en tiempo real, implementamos una rutina que captura los frames de la cámara, los procesa con el modelo de FaceNet y luego muestra los resultados en la pantalla. Además, utilizamos la biblioteca OpenCV para Android para ayudar con algunas de las operaciones de procesamiento de imágenes.</li><li><strong>Transferencia de aprendizaje con VGG16</strong>: Para mejorar la precisión de nuestro modelo, decidimos implementar transferencia de aprendizaje utilizando la red pre-entrenada VGG16. La idea detrás del transferencia de aprendizaje es que se pueden reutilizar las características aprendidas por una red entrenada en un conjunto de datos grande y diverso (como ImageNet, en el que se entrenó VGG16) en un nuevo problema que puede no tener suficientes datos para entrenar una red desde cero. En nuestro caso, utilizamos las capas inferiores de VGG16 para extraer características de las imágenes faciales y luego añadimos algunas capas adicionales en la parte superior para adaptar la red a nuestro problema específico de reconocimiento facial.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/419/1*SEu7p2KQ_449-dIyxd4Iew.jpeg" /></figure><p>El desarrollo de la aplicación de Android fue un desafío considerable, pero valió la pena el esfuerzo. Ahora tenemos una solución portátil y fácil de usar para el reconocimiento facial que puede ser utilizada por cualquier persona registrada en nuestro modelo y que cuente con un smartphone. Creemos que este es un paso significativo en hacer que la tecnología de reconocimiento facial sea más accesible y útil para todos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b2b77a8716f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/lcc-recognition-7b2b77a8716f">LCC-Recognition</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PsicBot: Un chatbot de Telegram con machine learning]]></title>
            <link>https://medium.com/lcc-unison/psicbot-un-chatbot-de-telegram-con-machine-learning-8e88cfa97219?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/8e88cfa97219</guid>
            <dc:creator><![CDATA[Vesna Pivac]]></dc:creator>
            <pubDate>Wed, 25 May 2022 18:16:43 GMT</pubDate>
            <atom:updated>2021-12-09T04:32:17.616Z</atom:updated>
            <content:encoded><![CDATA[<p>Un chatbot es un programa de computadora que puede simular y procesar conversaciones humanas (ya sean escritas o habladas), lo que permite a los humanos interactuar con dispositivos digitales, al igual que comunicarse con personas reales.</p><p>Un chatbot puede ser tan simple como un programa simple, que responde a consultas simples con una sola línea de respuesta, o tan complejo como un asistente digital, que se puede aprender y desarrollar para proporcionar un nivel cada vez mayor de personalización al recopilar y procesar información.</p><p>Se desarrollará un chatbot llamado “PsicBot”, que responderá preguntas sobre la salud mental y sus enfermedades, y aprenderá a responder diferentes preguntas con la misma respuesta a través del aprendizaje automático.</p><p>Para crear nuestro bot, tenemos que hablar con el “BotFather” que controla todos los bots de Telegram. Una vez que inicie una conversación con él, tendrá la opción de crear su propio bot. Una vez creado, el token que necesitará será proporcionado para construirlo.</p><p>Crearemos una carpeta para el proyecto e instalaremos las librerías que necesitaremos utilizando las siguientes líneas de código en la cmd:</p><pre>pip install nltk<br>pip install tensorflow<br>pip install python-telegram-bot</pre><p>Crearemos un archivo llamado credenciales.py, en el que crearemos variables, a las que asignaremos el token y el nombre de nuestro bot:</p><pre>bot_token=&quot;&lt;token de tu bot&gt;&quot;<br>bot_user_bot=&quot;&lt;nombre de tu bot&gt;&quot;</pre><p>Crearemos un archivo llamado entrenador.py ​​el cual se encargará de entrenar a nuestro bot. Una vez creado y abierto, escribiremos todas las importaciones de las bibliotecas que usaremos:</p><pre>import nltk<br>import json<br>import pickle<br>import numpy as np<br>import rando<br>mnltk.download(&#39;punkt&#39;)<br>nltk.download(&#39;wordnet&#39;)<br>from nltk.stem import WordNetLemmatizer<br>lemmatizer = WordNetLemmatizer()<br>from tensorflow.keras.models import Sequential<br>from tensorflow.keras.layers import Dense, Dropout<br>from tensorflow.keras.optimizers import SGD</pre><p>Iniciaremos las variables que utilizaremos para guardar nuestros datos de lenguaje natural:</p><pre>palabras=[]<br>tags=[]<br>documentos=[]<br>ignorar=[&#39;?&#39;,&#39;!&#39;]<br>archivo=open(&#39;intents.json&#39;),encoding=&quot;utf8&quot;).read()<br>intentos=json.loads(archivo)</pre><p>Crearemos el archivo “intents.json” que contiene todas las intenciones que nuestros usuarios quieren decir, el cual deberá verse de la siguiente manera:</p><pre>{&quot;intents&quot;:[<br>{&quot;tag&quot;: &quot;saludos&quot;,<br>&quot;patterns&quot;:[&quot;Hola&quot;, &quot;que onda&quot;, &quot;como estas&quot;, &quot;Como Estas&quot;, &quot;alguien ahi?&quot;, &quot;buenos dias&quot;, &quot;buenas&quot;, &quot;\\.&quot;],<br>&quot;responses&quot;: [&quot;Hola, como estas?&quot;,&quot;Hola, como te encuentras hoy?&quot;],<br>&quot;context&quot;: [&quot;&quot;]}<br>]}</pre><p>Importamos nuestro archivo “intents.json” al archivo “entrenador.py” con el siguiente ciclo:</p><ul><li>Primero tokenizamos cada palabra de nuestras preguntas.</li><li>Después le agregamos nuestras palabras.</li><li>Agregamos a documentos la dupla de la palabra tokenizada y el nombre de la clase a la que pertenece.</li><li>Agregamos los tag a tags para categorizarlas.</li></ul><pre>for intento in intentos[&#39;intents&#39;]:<br>    for patrones in intento[&#39;patterns&#39;]:<br>         p = nltk.word_tokenize(patrones)<em><br>         </em>palabras.extend(p)<em><br>         </em>documentos.append((p, intento[&#39;tag&#39;]))<br>         if intento[&#39;tag&#39;] not in tags:<br>             tags.append(intento[&#39;tag&#39;])</pre><p>Después limpiamos las palabras, borrando los caracteres “!” y “?” y posteriormente los ordenamos de la siguiente manera:</p><pre>palabras = [lemmatizer.lemmatize(p.lower()) for p in palabras if p          <br>            not in ignorar]<br>palabras = sorted(list(set(palabras)))<br>tags = sorted(list(set(tags)))</pre><p>Volvemos nuestras variables ‘dummys’ para que las palabras vuelvan a su forma base y esto lo hacemos de la siguiente manera:</p><pre>pickle.dump(palabras, open(&#39;palabras.pkl&#39;, &#39;wb&#39;))<br>pickle.dump(tags, open(&#39;tags.pkl&#39;, &#39;wb&#39;))</pre><p>Después crearemos nuestros datos para entrenar nuestro bot, después los utilizaremos para entrenarlos. Una vez realizado este paso creamos nuestra red neuronal de tres capas, en donde la primera tiene 128 neuronas, la segunda 64 neuronas y la tercera 16 neuronas las cuales son el número de intenciones en nuestro archivo “intents.json”.</p><p>Ahora ya hecho nuestro modelo de entrenamiento para nuestro bot, creamos un archivo llamado app.py en cual contendrá la configuración de nuestro bot.</p><p>Importamos todas las librerías necesarias para que nuestro bot funcione de la manera correcta utilizando las siguientes líneas de código:</p><pre>import loggin<br>import telegram<br>import json<br>import random<br>import nltk<br>import pickle<br>import numpy as np<br>from telegram.ext import Updater, CommandHandler, MessageHandler, Filters<br>from credentials import bot_token<br>from tensorflow.keras.models import load_model<br>from nltk.stem import WordNetLemmatizer<br>lemmatizer = WordNetLemmatizer()</pre><p>Extraemos la información de nuestros archivos “intents.json”, “modelo.h5”, “palabras.pkl”, “tags.pkl” y configuraremos nuestro bot:</p><pre>modelo = load_model(&#39;modelo.h5&#39;)<br>intentos = json.loads(open(&#39;intents.json&#39;,encoding=&quot;utf8&quot;).read())<br>palabras = pickle.load(open(&#39;palabras.pkl&#39;, &#39;rb&#39;))<br>tags = pickle.load(open(&#39;tags.pkl&#39;, &#39;rb&#39;))</pre><pre>logging.basicConfig(format=&#39;%(asctime)s - %(name)s - %(levelname)s - <br>                    %(message)s&#39;, level=logging.INFO)<br>logger = logging.getLogger()<br>TOKEN = bot_token</pre><p>Una vez hecho lo anterior crearemos las siguientes funciones:</p><ul><li><em>limpiarTexto()</em> : Limpia el texto introducido por el usuario.</li><li><em>busqueda()</em> : Guarda todas las sentencias ya procesadas y limpias para después ser utilizadas para predecir la clase a la que pertenecen.</li><li><em>predecirTag() </em>: Predice la clase a la que pertenece la pregunta del usuario. Regresa una lista con todos las intenciones y la probabilidad de coincidir.</li><li><em>obtenerRespuesta()</em> : Toma la lista de intenciones y su probabilidad de coincidir y, verifica el archivo “intents.json” para generar la respuesta con la mayor probabilidad.</li><li><em>predecirRespuesta()</em> : Predice la clase del mensaje del usuario con la respuesta más probable.</li><li><em>responder()</em> : Recibe los mensajes del usuario y manda la respuesta que predecimos.</li></ul><p>Creamos un enlazador para poder comunicarnos con el bot, también se creará manejadores que serán los que llamaran a nuestra función <em>responder():</em></p><pre>updater=Updater(my_bot.token, use_context=True)<br>dp=updater.dispatcher<br>dp.add_handler(CommandHandler(&quot;start&quot;, start))<br>dp.add_handler(MessageHandler(Filters.text, responder))<br>updater.start_polling()</pre><p>Una vez realizado todo lo anterior solo queda correr el código para probar nuestro chatbot. Abrimos nuestra carpeta en nuestra cmd y utilizamos los siguientes comandos para entrenar nuestro bot y despues activarlo:</p><pre>python entrenador.py<br>python app.py</pre><p>Ahora podemos abrir nuestra app de Telegram y buscar el nombre de nuestro bot y empezar la conversación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CsDdF0dbgEwGvoncADVKZg.png" /></figure><p>Repositorio de Github:</p><p><a href="https://github.com/VesnaPivac/PsicBot">GitHub - VesnaPivac/PsicBot: Chatbot que informa sobre salud mental</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e88cfa97219" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/psicbot-un-chatbot-de-telegram-con-machine-learning-8e88cfa97219">PsicBot: Un chatbot de Telegram con machine learning</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Regresión Logística: Cómo predecir y clasificar tweets de bromas]]></title>
            <link>https://medium.com/lcc-unison/regresi%C3%B3n-log%C3%ADstica-c%C3%B3mo-predecir-y-clasificar-tweets-de-bromas-66eeeee29ae6?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/66eeeee29ae6</guid>
            <dc:creator><![CDATA[Vesna Pivac]]></dc:creator>
            <pubDate>Wed, 25 May 2022 18:16:25 GMT</pubDate>
            <atom:updated>2022-05-20T03:58:25.228Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*unZ4DGc0PqNDGsC5" /><figcaption>Photo by <a href="https://unsplash.com/@visuals?utm_source=medium&amp;utm_medium=referral">visuals</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>La regresión logística es un algoritmo de Machine Learning, utilizado para la clasificación de dos clases. Este algoritmo es un método para problemas de clasificación binaria.</p><p>Utilizaremos el algoritmo de regresión logística para clasificar bromas de forma binaria para saber si una broma es chistosa. Todo el procedimiento se realizó en el lenguaje de programación Python.</p><p>Empecemos por la base de datos y su procesamiento. Tenemos un archivo llamado <em>haha_2021_train.csv </em>que contiene 24,000 datos. Después de eliminar las columnas que no nos servirán para nuestro modelo contiene:</p><ul><li><em>text</em>: tweets</li><li><em>is_humor</em>: valor de sentimiento (1: Chistoso, 0: No chistoso).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/1*SIeVBDUI-hdugmlFuY--vg.png" /></figure><p>Para poder utilizar la regresión se necesita primero tratar los datos. Para esto explicare algunos conceptos básicos del procesamiento del lenguaje natural (PLN):</p><ul><li>Stopwords son palabras que carecen de un significado por sí solas. Suelen ser artículos, preposiciones, conjunciones, pronombres, etc.</li><li>La tokenización es una forma de separar un fragmento de texto en unidades más pequeñas llamadas tokens.</li><li>La Lematización es un proceso que elimina el afijo de una palabra para extraer la parte principal de la palabra.</li></ul><p>Una vez comprendido estos conceptos empezaremos por crear las funciones <em>LimpiarTexto</em>, <em>eliminar_stopwords</em>, <em>Tokenizacion </em>y <em>Stemming</em>.</p><p>Después creamos nuevas columnas en el dataframe que contiene:</p><ul><li><em>CleanText</em>: El texto de los tweets después de quitar los signos de puntuación y las stopwords con la función <em>LimpiarTexto</em>.</li></ul><pre>def LimpiarTexto(tweet):<br>   stopwords_english = stopwords.words(&#39;spanish&#39;)<br>   tweet = re.sub(r&#39;\$\w*&#39;, &#39;&#39;, tweet)<br>   tweet = re.sub(r&#39;^RT[\s]+&#39;, &#39;&#39;, tweet)<br>   tweet = re.sub(r&#39;https?:\/\/.*[\r\n]*&#39;, &#39;&#39;, tweet)<br>   tweet = re.sub(r&#39;#&#39;, &#39;&#39;, tweet)<br>   tweet = re.sub(r&#39;[^\w\s]&#39;,&#39;&#39;,tweet) <br>   tweet = tweet.lower() <br>   tweet = tweet.replace(&quot;ñ&quot;, &quot;#&quot;)<br>   tweet = unicodedata.normalize(&quot;NFKD&quot;, tweet)\<br>        .encode(&quot;ascii&quot;,&quot;ignore&quot;).decode(&quot;ascii&quot;)\<br>        .replace(&quot;#&quot;, &quot;ñ&quot;) #Quita acentos<br>   eliminar_stopwords(tweet, stopwords_english)</pre><pre>   return tweet</pre><pre>def eliminar_stopwords(texto, stopwords):<br>   return &#39; &#39;.join([word for word in texto.split(&#39; &#39;) if word not in    stopwords])</pre><ul><li><em>TokenizeText</em>: El texto de CleanText después de tokenizar cada palabra con la función <em>Tokenizacion</em>.</li></ul><pre>def Tokenizacion(tweet):<br>   tokenizer = TweetTokenizer(preserve_case=False, strip_handles=True, reduce_len=True)<br>   tweet_tokens = tokenizer.tokenize(tweet)<br>   return tweet_tokens</pre><ul><li><em>Text</em>: El texto en TokenizeText después de aplicarle la lematización con la función <em>Stemming</em>.</li></ul><pre>def Stemming(tweet):<br>   stemmer = SnowballStemmer(&quot;spanish&quot;)<br>   tweets_clean = []<br>   for word in tweet:<br>      stem_word = stemmer.stem(word)  <br>      tweets_clean.append(stem_word)<br>   return tweets_clean</pre><ul><li>Corpus: El texto en <em>TokenizeText </em>al convertirlo en dato de tipo string.</li></ul><pre>for i in range(len(df)):<br>   df[&quot;Corpus&quot;][i] = &quot;&quot;.join(df[&#39;TokenizeText&#39;][i])</pre><p>Una vez ya procesado nuestra base de datos guardamos los valores de <em>is_humor </em>en la variable <em>Y </em>y las strings de <em>Corpus </em>en la variable <em>X, </em>después lo separamos con la función de <em>train_test_split() </em>el cual nos generará cuatro variables donde se guardaron los datos: <em>train_x, test_x, train_y, test_y</em>. De estas nuevas variables le aplicamos a <em>train_y </em>y <em>test_y </em>el <em>LabelEncoder.</em></p><pre>from sklearn.model_selection import train_test_split<br>x = df[&#39;Corpus&#39;]<br>y = df[&#39;is_humor&#39;]<br>train_x, test_x, train_y, test_y = train_test_split(x, y, test_size = 0.3)</pre><p>Ahora convertimos nuestros datos en <em>Corpus </em>en una matriz TF-IDF con la función <em>TfidfVectorizer </em>de <em>sklearn</em>. Después convertimos nuestros datos en train_x, test_x en vectores Tf-IDF que nos crea <em>Train_X_Tfidf </em>y <em>Test_X_Tfidf</em>.</p><h4>Predicción</h4><p>Creamos el modelo con LogisticRegression y después lo entrenamos con nuestros datos en <em>Train_X_Tfidf </em>y<em> train_y. </em>Después evaluemos el modelo con nuestros datos de <em>Test_X_Tfidf </em>y <em>test_y</em>.</p><p>Esto nos generará la predicción del valor de humor de cada dato contenido en <em>Test_X_Tfidf</em>.</p><h4>Clasificación</h4><p>Creamos una variable en la que guardaremos un nuevo tweet o broma, este lo convertiremos en un vector de TF-IDF y lo usaremos en nuestro modelo de regresión logística.</p><pre>X = &#39;Van dos ciegos y le dice uno al otro: -Ojala lloviera... -Ojala yo tambien...&#39;</pre><pre>prediccion_X = Tfidf_vect.transform([X])<br>modelLogisticRegression.predict(prediccion_X)</pre><h4>Conclusión</h4><p>Al checar nuestro accuracy en nuestro modelo con ngramas de (1,2) con 100 features obtuvimos 72.4% en nuestro entrenamiento y lo mismo en la prueba lo que quiere decir que nuestro modelo de regresión logística no nos dice nada sobre su aprendizaje porque los datos son muy parecidos, podríamos mejorarlo al probarlo con con otros datos.</p><p>Repositorio de Github:</p><p><a href="https://github.com/VesnaPivac/PrediccionDeHumor-RegresionLogistica">VesnaPivac/PrediccionDeHumor-RegresionLogistica</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66eeeee29ae6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/regresi%C3%B3n-log%C3%ADstica-c%C3%B3mo-predecir-y-clasificar-tweets-de-bromas-66eeeee29ae6">Regresión Logística: Cómo predecir y clasificar tweets de bromas</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Applying Sobel Filter for Image Processing using Parallel Computing]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/lcc-unison/applying-sobel-filter-for-image-processing-using-parallel-computing-d1eae128b4e?source=rss----5cd0f12fe579---4"><img src="https://cdn-images-1.medium.com/max/619/1*8mnzrw0K5l_gfW6gNCBumg.png" width="619"></a></p><p class="medium-feed-snippet">Working with PPM and PGM images</p><p class="medium-feed-link"><a href="https://medium.com/lcc-unison/applying-sobel-filter-for-image-processing-using-parallel-computing-d1eae128b4e?source=rss----5cd0f12fe579---4">Continue reading on LCC-Unison »</a></p></div>]]></description>
            <link>https://medium.com/lcc-unison/applying-sobel-filter-for-image-processing-using-parallel-computing-d1eae128b4e?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/d1eae128b4e</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[sobel-filter]]></category>
            <category><![CDATA[image-processing]]></category>
            <dc:creator><![CDATA[Jose Alberto Leyva Contreras]]></dc:creator>
            <pubDate>Fri, 15 Apr 2022 19:02:07 GMT</pubDate>
            <atom:updated>2022-04-15T19:02:07.016Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Cómo instalar Hadoop en Windows Subsystem for Linux]]></title>
            <link>https://medium.com/lcc-unison/c%C3%B3mo-instalar-hadoop-en-windows-subsystem-for-linux-d1fde59fb69c?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/d1fde59fb69c</guid>
            <category><![CDATA[ubuntu]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[hadoop]]></category>
            <category><![CDATA[windows]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[LUIS ANGEL LOPEZ SANTOS]]></dc:creator>
            <pubDate>Fri, 11 Feb 2022 07:37:32 GMT</pubDate>
            <atom:updated>2022-02-11T07:33:02.132Z</atom:updated>
            <content:encoded><![CDATA[<p>La siguiente guía de instalación te permitirá instalar y configurar Hadoop 3.3.1 en Windows Subsystem for Linux o también llamado Subsistema de Windows para Linux.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uD-aCfkO32c2zCrpUwc-BQ.png" /></figure><p><strong>Contenido</strong></p><ul><li><a href="#4af7">Habilitar Windows Subsystem for Linux</a></li><li><a href="#5216">Instalar Ubuntu en Windows</a></li><li><a href="#3d9d">Instalar OpenJDK</a></li><li><a href="#8a6e">Configurar SSH</a><br>- <a href="#5de4">Instalar OpenSSH</a><br>- <a href="#17cf">Crear un nuevo usuario</a><br>- <a href="#3e8b">Habilitar la conexión SSH sin contraseña para el nuevo usuario</a></li><li><a href="#3426">Descargar e instalar Hadoop</a></li><li><a href="#dc24">Configuración de Hadoop en un solo nodo</a><br>- <a href="#d5e4">Configuración de las variables de entorno de Hadoop (bashrc)</a><br>- <a href="#1aab">Editar el archivo hadoop-env.sh</a><br>- <a href="#23e6">Editar el archivo core-site.xml</a><br>- <a href="#ecb8">Editar el archivo hdfs-site.xml</a><br>- <a href="#3fbd">Editar el archivo mapred-site.xml</a><br>- <a href="#25f9">Editar el archivo yarn-site.xml</a><br>- <a href="#6c03">Dar formato HDFS al NameNode</a></li><li><a href="#55c4">Iniciar cluster</a><br>- <a href="#173f">Accedemos a la interfaz de Hadoop en el navegador</a></li><li><a href="#bdd3">Probando Hadoop y MapReduce con WordCount</a><br>- <a href="#9023">Descargar script MapReduce</a><br>- <a href="#ba8a">Creación de directorios</a><br>- <a href="#6d9c">Ejecutar WordCount del script de MapReduce</a><br>- <a href="#788e">Resultados del WordCount</a></li><li><a href="#2ca8">Finalizar los procesos de Hadoop</a></li></ul><h3>Habilitar Windows Subsystem for Linux</h3><p>Para habilitar WSL en Windows 10, sigue los siguientes pasos:</p><ul><li>Abrir <strong>Configuración</strong></li><li>Ir a <strong>Aplicaciones</strong></li><li>Ir a <strong>Programas y Características</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZjrFAXHqBuLknKu_wQrc0Q.png" /></figure><ul><li>Ir a <strong>Activar o desactivar las características de Windows</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*AmK1kMZgeSoSmAs36ATlUA.png" /></figure><ul><li>Seleccionar la casilla de <strong>Subsistema de Windows para Linux</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/415/1*AvApvszOWx3DZRI96W_1OA.png" /></figure><ul><li><strong>Aceptar</strong> y <strong>Reiniciar ahora</strong></li></ul><h3>Instalar Ubuntu en Windows</h3><p>Una vez que WSL esté habilitado, puedes utilizar diferentes distribuciones de Linux en Windows. En este caso instalaremos Ubuntu.</p><p>Para instalar una distribución de Linux en Windows 10, sigue los siguientes pasos:</p><ul><li>Abrir <strong>Microsoft Store</strong></li><li>Buscar la distribución de Linux a instalar, en este caso <strong>Ubuntu</strong></li><li>Le damos en <strong>Obtener</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*HtyGIZoTM9HJTDpDGd8Ykw.png" /></figure><ul><li>Una vez instalado, le damos en <strong>Abrir</strong></li></ul><p>Si todo ha salido correctamente, nos pedirá un nombre de usuario y contraseña para usar en Linux. Este puede ser distinto al de Windows.</p><h3><strong>Instalar OpenJDK</strong></h3><p>Para utilizar Hadoop se requiere tener instalado Java Runtime Environment (JRE) y Java Development Kit (JDK).</p><p>Actualizaremos el sistema antes de iniciar una nueva instalación con el siguiente comando:</p><pre>sudo apt update</pre><p>La versión de Hadoop 3.3.1 soporta Java 8. El paquete de OpenJDK contiene tanto JRE como JDK.</p><p>Utilizamos el siguiente comando para instalar OpenJDK 8:</p><pre>sudo apt install openjdk-8-jdk -y</pre><p>Una vez terminado el proceso de instalación, verificamos la versión actual de Java:</p><pre>java -version; javac -version</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*HHVxlGu7NQTfqXvzg4gLwQ.png" /></figure><p>Obtendremos la versión de Java que está en uso. En esta caso, la versión 1.8.0_312.</p><h3>Configurar SSH</h3><p>Es recomendable utilizar un usuario distinto y sin privilegios root al usar Hadoop para mejorar la seguridad y administrar tu cluster de manera más eficiente. Aún así, puedes utilizar tu usuario root si lo deseas, solo nos saltamos el paso de crear un usuario nuevo. Para asegurar un buen funcionamiento de los servicios de Hadoop, el usuario debería poder establecer una conexión SSH sin contraseña con el localhost.</p><h4>Instalar OpenSSH</h4><p>Para instalar el cliente y servidor OpenSSH utilizaremos el siguiente comando:</p><pre>sudo apt install openssh-server openssh-client -y</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*nE2xNz2n33BsvplxnZ3wPA.png" /></figure><p>En mi caso, obtengo un mensaje diciendo que ya tengo instalada la última versión.</p><h4>Crear un nuevo usuario</h4><p>Utilizaremos el comando <strong>adduser </strong>para crear un nuevo usuario:</p><pre>sudo adduser hdoop</pre><p>En este ejemplo, el nombre de usuario es <strong>hdoop</strong>. Puedes utilizar cualquier nombre de usuario y contraseña que prefieras.</p><p>Antes de cambiar de usuario habilitemos OpenSSH:</p><pre>sudo service ssh start</pre><p>Ahora, iniciemos sesión con el usuario creado:</p><pre>su - hdoop</pre><p>Una vez que cambiemos de usuario, tenemos que habilitar la conexión SSH sin contraseña.</p><h4>Habilitar la conexión SSH sin contraseña para el nuevo usuario</h4><p>Generamos las claves SSH y definimos dónde se almacenarán:</p><pre>ssh-keygen -t rsa -P &#39;&#39; -f ~/.ssh/id_rsa</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*_wrYKVgcInk17eQBva_qIQ.png" /></figure><p>En mi caso, ya están creadas.</p><p>Utilizaremos el comando <strong>cat</strong> para guardar la llave pública en <strong>authorized_keys</strong>:</p><pre>cat ~/.ssh/id_rsa.pub &gt;&gt; ~/.ssh/authorized_keys</pre><p>Estableceremos los permisos para el usuario con el comando <strong>chmod</strong>:</p><pre>chmod 0600 ~/.ssh/authorized_keys</pre><p>Ahora verificamos que todo salió bien con el siguiente comando:</p><pre>ssh localhost</pre><p>Después de terminar estos pasos, el usuario nuevo debe ser capaz de establecer una conexión SSH al localhost sin problemas y sin necesidad de contraseña.</p><h3>Descargar e instalar Hadoop</h3><p>Vamos a <a href="https://hadoop.apache.org/releases.html">la página oficial de Apache Hadoop</a> y seleccionamos la versión que queremos instalar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FbvtOvDE9iaG-dgtoj_HQg.png" /></figure><p>Una vez que vayamos al enlace de la versión que queremos, nos encontraremos un enlace para descargar el paquete tar de Hadoop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fBh0HSEuJ8ZOZyxVgjPu5w.png" /></figure><p>Usaremos el enlace para descargar el paquete con el comando <strong>wget</strong>:</p><pre>wget <a href="https://dlcdn.apache.org/hadoop/common/hadoop-3.3.1/hadoop-3.3.1.tar.gz">https://dlcdn.apache.org/hadoop/common/hadoop-3.3.1/hadoop-3.3.1.tar.gz</a></pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*yZ0cMJMmzsoA7UwnEgmaBA.png" /></figure><p>Una vez finalizada la descarga, extraemos los archivos para iniciar la instalación:</p><pre>tar xzf hadoop-3.3.1.tar.gz</pre><p>Los archivos se guardarán en una carpeta llamada <strong>hadoop-3.3.1</strong>.</p><h3>Configuración de Hadoop en un solo nodo</h3><p>Usualmente, Hadoop se utiliza con múltiples nodos en un cluster con varios servidores de redes, sin embargo, para explorar los comandos básicos y probar aplicaciones podemos configurar Hadoop en un solo nodo. Así cada servicio de Hadoop se ejecutará en un solo proceso de Java.</p><p>A continuación editaremos los siguientes archivos de configuración:</p><ul><li>bashrc</li><li>hadoop-env.sh</li><li>core-site.xml</li><li>hdfs-site.xml</li><li>mapred-site-xml</li><li>yarn-site.xml</li></ul><h4>Configuración de las variables de entorno de Hadoop (bashrc)</h4><p>Editaremos el archivo de configuración <strong>.bashrc</strong> usando un editor de texto como <strong>nano</strong>:</p><pre>nano .bashrc</pre><p>Definimos las variables de entorno de Hadoop agregando lo siguiente al final del archivo de configuración:</p><pre>#Hadoop Related Options<br>export HADOOP_HOME=/home/hdoop/hadoop-3.3.1<br>export HADOOP_INSTALL=$HADOOP_HOME<br>export HADOOP_MAPRED_HOME=$HADOOP_HOME<br>export HADOOP_COMMON_HOME=$HADOOP_HOME<br>export HADOOP_HDFS_HOME=$HADOOP_HOME<br>export YARN_HOME=$HADOOP_HOME<br>export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native<br>export PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin<br>export HADOOP_OPTS&quot;-Djava.library.path=$HADOOP_HOME/lib/native&quot;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*v6X3kj8RjusCdInOEBotkA.png" /></figure><p>Una vez que agregamos las variables debemos guardar y salir del archivo.</p><p>Ahora aplicamos los cambios al entorno en ejecución con el siguiente comando:</p><pre>source ~/.bashrc</pre><h4>Editar el archivo hadoop-env.sh</h4><p>Para configurar YARN, HDFS, MapReduce entre otros ajustes de proyectos en Hadoop se usa el archivo <strong>hadoop-env.sh</strong>.</p><p>Para configurar un cluster de un solo nodo se debe definir que implementación de Java se va a usar.</p><p>Para encontrar dónde está localizado Java utilizamos el siguiente comando:</p><pre>which javac</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*_eY39mB3QjouJ2iwm4ts3Q.png" /></figure><p>Ahora, usamos el directorio que obtuvimos para localizar OpenJDK:</p><pre>readlink -f /usr/bin/javac</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*gY5XftYVPQS7g93T4IqaIg.png" /></figure><p>Ahora sabemos que OpenJDK está localizado en <strong>/usr/lib/jvm/java-8-openjdk-amd64</strong>, copiamos la dirección justo antes de <strong>/bin/javac</strong>.</p><p>Vamos a acceder al archivo <strong>hadoop-env.sh</strong> con la variable <strong>$HADOOP_HOME</strong> que recién creamos:</p><pre>nano $HADOOP_HOME/etc/hadoop/hadoop-env.sh</pre><p>Borramos el <strong>#</strong> de la variable <strong>$JAVA_HOME</strong> y agregamos el directorio completo a la instalación de OpenJDK:</p><pre>export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*siX8TVe5uqImSQkJMmoUEg.png" /></figure><h4>Editar el archivo core-site.xml</h4><p>Las propiedades de HDFS y el núcleo de Hadoop están definidas en <strong>core-site.xml</strong>.</p><p>Para configurar Hadoop en un solo nodo se debe especificar la url para tu NameNode y un directorio temporal que Hadoop usa para el proceso map-reduce.</p><p>Accedemos al archivo <strong>core-site.xml</strong>:</p><pre>nano $HADOOP_HOME/etc/hadoop/core-site.xml</pre><p>Agregamos la siguiente configuración para anular los valores por default del directorio temporal y remplazar el url de nuestro HDFS por defecto:</p><pre>&lt;configuration&gt;<br>&lt;property&gt;<br>  &lt;name&gt;hadoop.tmp.dir&lt;/name&gt;<br>  &lt;value&gt;/home/hdoop/tmpdata&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;property&gt;<br>  &lt;name&gt;fs.default.name&lt;/name&gt;<br>  &lt;value&gt;hdfs://127.0.0.1:9000&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;/configuration&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*wWIKDDguigjWbl3CFjLCEQ.png" /></figure><p>Recuerda que los valores deben concordar con los de tu sistema.</p><p>También debemos crear el directorio para los datos temporales si no existen:</p><pre>mkdir /home/hdoop/tmpdata</pre><h4>Editar el archivo hdfs-site.xml</h4><p>La ubicación de almacenamiento de metadatos del nodo, el archivo fsimage y el archivo de registro de edición son propiedades definidas en <strong>hdfs-site.xml</strong>.</p><p>Accedemos al archivo <strong>hdfs-site.xml</strong>:</p><pre>nano $HADOOP_HOME/etc/hadoop/hdfs-site.xml</pre><p>Agregamos la siguiente configuración de directorios al archivo según se encuentren localizados en nuestro sistema, además cambiamos el valor por default de <strong>dfs.replication</strong> a <strong>1</strong> para que concuerde con la configuración de un solo nodo:</p><pre>&lt;configuration&gt;<br>&lt;property&gt;<br>  &lt;name&gt;dfs.data.dir&lt;/name&gt;<br>  &lt;value&gt;/home/hdoop/dfsdata/namenode&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;property&gt;<br>  &lt;name&gt;dfs.data.dir&lt;/name&gt;<br>  &lt;value&gt;/home/hdoop/dfsdata/datanode&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;property&gt;<br>  &lt;name&gt;dfs.replication&lt;/name&gt;<br>  &lt;value&gt;1&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;/configuration&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*LoJYADSdofz18J0-hRHFlg.png" /></figure><p>Si es necesario, se crean los directorios definidos en <strong>dfs.data.dir</strong> utilizando el comando <strong>mkdir</strong>.</p><h4>Editar el archivo mapred-site.xml</h4><p>Usaremos el siguiente comando para acceder al archivo <strong>mapred-site.xml</strong> y definir los valores de MapReduce:</p><pre>nano $HADOOP_HOME/etc/hadoop/mapred-site.xml</pre><p>Agregamos la siguiente configuración para cambiar el nombre por default del framework MapReduce a <strong>yarn</strong>:</p><pre>&lt;configuration&gt;<br>&lt;property&gt;<br>  &lt;name&gt;mapreduce.framework.name&lt;/name&gt;<br>  &lt;value&gt;yarn&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;/configuration&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*QBlGnK0-81ZizTIsVJU7oQ.png" /></figure><h4>Editar el archivo yarn-site.xml</h4><p>La definición de ajustes relevantes a YARN se encuentra en <strong>yarn-site.xml</strong>. Contiene información para los Node Manager, Resource Manager, Containers y Application Master.</p><p>Accedemos al archivo <strong>yarn-site.xml</strong>:</p><pre>nano $HADOOP_HOME/etc/hadoop/yarn-site.xml</pre><p>Agregamos la siguiente configuración al archivo:</p><pre>&lt;configuration&gt;<br>&lt;property&gt;<br>  &lt;name&gt;yarn.nodemanager.aux-services&lt;/name&gt;<br>  &lt;value&gt;mapreduce_shuffle&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;property&gt;<br>  &lt;name&gt;yarn.nodemanager.aux-services.mapreduce.shuffle.class&lt;/name&gt;<br>  &lt;value&gt;org.apache.hadoop.mapred.ShuffleHandler&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;property&gt;<br>  &lt;name&gt;yarn.resourcemanager.hostname&lt;/name&gt;<br>  &lt;value&gt;127.0.0.1&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;property&gt;<br>  &lt;name&gt;yarn.acl.enable&lt;/name&gt;<br>  &lt;value&gt;0&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;property&gt;<br>  &lt;name&gt;yarn.nodemanager.env-whitelist&lt;/name&gt;   <br>  &lt;value&gt;JAVA_HOME,HADOOP_COMMON_HOME,HADOOP_HDFS_HOME,HADOOP_CONF_DIR,CLASSPATH_PERPEND_DISTCACHE,HADOOP_YARN_HOME,HADOOP_MAPRED_HOME&lt;/value&gt;<br>&lt;/property&gt;<br>&lt;/configuration&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*HuAt8AVRUymH4ElIBJTaSA.png" /></figure><h4>Dar formato HDFS al NameNode</h4><p>Antes de iniciar los servicios de Hadoop por primera vez, debemos darle formato al <strong>NameNode</strong>:</p><pre>hdfs namenode -format</pre><p>Una vez que aparezca la notificación <strong>SHUTDOWN_MSG: Shutting down NameNode…</strong> significa que el proceso de formato finalizó.</p><h3>Iniciar cluster</h3><p>Navegamos al directorio <strong>sbin </strong>de Hadoop para iniciar el NameNode y DataNode.</p><pre>cd /home/hdoop/hadoop-3.3.1/sbin</pre><pre>./start-dfs.sh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*vBjcmzy0FlM01MqTed9eyA.png" /></figure><p>Una vez que se ejecuten, iniciamos el Resource Manager y Node Managers:</p><pre>./start-yarn.sh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*C1mbTHM768jaeroFMsq7Kg.png" /></figure><p>Verificamos que todos los procesos se estén ejecutando con el siguiente comando:</p><pre>jps</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*UvKh5aC9rzdO8xKAw5sJjg.png" /></figure><h4>Accedemos a la interfaz de Hadoop en el navegador</h4><p>Con el navegador de tu preferencia navegamos a tu localhost. Por default, el puerto <strong>9870</strong> te da acceso a la interfaz del NameNode:</p><pre><a href="http://localhost:9870/">http://localhost:9870</a></pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1011/1*JX6lyKaw42zyzf_xg_nwZQ.png" /></figure><p>El puerto por default para acceder a los DataNodes es <strong>9864</strong>:</p><pre><a href="http://localhost:9864/">http://localhost:9864</a></pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*-t3XM9rouOrrqB__mzvOTw.png" /></figure><p>Para el siguiente ejemplo práctico, salimos de los archivos de hadoop a home con el siguiente comando:</p><pre>cd</pre><h3>Probando Hadoop y MapReduce con WordCount</h3><p>Ahora que hemos instalado Hadoop en un solo nodo, pobraremos su funcionalidad con un ejemplo práctico, contando la frecuencia de palabras en un texto.</p><h4>Descargar script MapReduce</h4><p>Para descargar el script que necesitamos vamos al <a href="https://repo1.maven.org/maven2/org/apache/hadoop/hadoop-mapreduce-examples/">repositorio de ejemplos de MapReduce</a> y buscamos nuestra versión de Hadoop.</p><p>Una vez dentro del directorio correspondiente a nuestra versión, guardamos el enlace del archivo <strong>hadoop-mapreduce-examples-x.x.x-sources.jar</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/902/1*-RXmyRljufoVbh7zUfTQYw.png" /></figure><p>Ahora lo descargamos utilizando comando <strong>wget</strong>:</p><pre>wget <a href="https://repo1.maven.org/maven2/org/apache/hadoop/hadoop-mapreduce-examples/3.3.1/hadoop-mapreduce-examples-3.3.1-sources.jar">https://repo1.maven.org/maven2/org/apache/hadoop/hadoop-mapreduce-examples/3.3.1/hadoop-mapreduce-examples-3.3.1-sources.jar</a></pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*v_w_1kNb6WMLcJJhn2x0-w.png" /></figure><p>También es necesario que tengas descargado o creado un texto con formato <strong>.txt</strong> para este ejemplo. En mi caso utilizaré un texto limpio de La Metamorfosis, novela de Franz Kafka obtenida de <a href="https://linguabooster.com/es/es/books/verwandlung-5">linguabooster.com</a>.</p><h4>Creación de directorios</h4><p>Para poder ejecutar comandos en nuestro sistema de archivos HDFS utilizaremos la siguiente estructura:</p><pre>hdfs dfs -&quot;comando&quot;</pre><p>Primero vamos a listar los directorios y archivos que se encuentran en la raíz de nuestro sistema de archivos utilizando:</p><pre>hdfs dfs -ls /</pre><p>Ahora, debemos crear un directorio con nuestro <strong>nombre de usuario</strong> para posteriormente almacenar la entrada y salida del script de mapreduce:</p><pre>hdfs dfs -mkdir -p /user/hdoop</pre><p>Para almacenar la entrada del script, creamos el directorio <strong>input</strong>:</p><pre>hdfs dfs -mkdir /user/hdoop/input</pre><p>Ahora copiaremos el texto que obtuvimos anteriormente a nuestro sistema de archivos en la carpeta <strong>input</strong> que acabamos de crear:</p><pre>hdfs dfs -put texto.txt /user/hdoop/input</pre><p>Podemos verificar que copiamos el archivo utilizando <strong>ls</strong> de la siguiente manera:</p><pre>hdfs dfs -ls /user/hdoop/input</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*oDm-vOPKQP-qRmr_iyMEMg.png" /></figure><h4>Ejecutar WordCount del script de MapReduce</h4><p>Llegó la hora de utilizar WordCount mejor conocido como el “Hola mundo” de Hadoop y MapReduce, ahora que tenemos todos los archivos y directorios listos, ejecutamos el script de la siguiente manera:</p><pre>hadoop jar hadoop-mapreduce-examples-3.3.1-sources.jar org.apache.hadoop.examples.WordCount input output</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*qmNLX1GLhFKNK7kH04zXdg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*sE_He36yO9_e30sC908-QA.png" /></figure><p>En unos instantes, el script termina de ejecutarse con los resultados obtenidos de cualquier archivo colocado en el directorio de entrada <strong>input</strong> para almacenarlos en el directorio de salida <strong>output</strong> que este mismo crea.</p><h4>Resultados del WordCount</h4><p>Ahora puedes imprimir en pantalla los resultados obtenidos mediante el script de MapReduce con el siguiente comando:</p><pre>hdfs dfs -cat /user/hdoop/output/*</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*0AcMjQk1EbQL7cB6jqFCQw.png" /></figure><p>Para obtener los resultados en un archivo .txt podemos ejecutar el siguiente comando:</p><pre>hdfs dfs -cat /user/hdoop/output/* &gt; /home/hdoop/resultados.txt</pre><h3>Finalizar los procesos de Hadoop</h3><p>Una vez que termines de utilizar Hadoop es importante finalizar los procesos para eliminar archivos temporales y evitar cualquier pérdida de datos.</p><p>Para esto vamos a la carpeta donde se encuentran los archivos de Hadoop:</p><pre>cd /home/hdoop/hadoop-3.3.1/sbin</pre><p>Y ahora finalizamos los procesos con los siguienes comandos:</p><pre>./stop-yarn.sh<br>./stop-dfs.sh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*v2f9J8ElBKGWWiLmI6V3lA.png" /></figure><p>Para cerciorarnos de que han finalizado correctamente, podemos utilizar el siguiente comando:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*m-Gk7SC0HTj1z08ScGI3BA.png" /></figure><p>Y así nos damos cuenta de que ya no se están ejecutando.</p><p>¡Ahora ya tienes configurado Hadoop en un solo nodo y lo has probado exitosamente! Es un excelente comienzo para seguir explorando comandos HDFS y ganar experiencia para diseñar un cluster con más nodos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WWb6MzfWB6_sAtnRLBmiTQ.png" /></figure><p>Te dejo una nube de palabras para ilustrar los resultados del WordCount realizado anteriormente. ¡Muchas gracias por leer!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d1fde59fb69c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/c%C3%B3mo-instalar-hadoop-en-windows-subsystem-for-linux-d1fde59fb69c">Cómo instalar Hadoop en Windows Subsystem for Linux</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Nobody can guarantee you anything in Formula 1 … but are we sure?]]></title>
            <link>https://medium.com/lcc-unison/nobody-can-guarantee-you-anything-in-formula-1-but-are-we-sure-3d48016ed342?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/3d48016ed342</guid>
            <dc:creator><![CDATA[Diana Ballesteros]]></dc:creator>
            <pubDate>Wed, 29 Dec 2021 04:57:46 GMT</pubDate>
            <atom:updated>2021-12-08T04:01:41.358Z</atom:updated>
            <content:encoded><![CDATA[<p>Predicting the podiums of the formula 1 silverstone race</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CBusC0_rd4m5oNJ-WvYEZw.jpeg" /></figure><p>They say that formula 1 cannot be predicted so why did I choose this topic to do a predictive analysis? As I mentioned, formula 1 cannot be predicted because so many things go wrong that we have no control over, but most of the time there is a pattern, both in the way the drivers drive, weather at a certain track, the ability of each team, etc.</p><p>Of all the circuits I have chosen this one in particular, because the first World Championship Grand Prix was held in 1950 at Silverstone, which means that we have a lot of data from that circuit.</p><p>What I did in this project was to try to predict the podium for each driver in the race.</p><p><strong>Let’s get started!</strong></p><p>First of all, for the realization of this project I used a dataset that I found in kaggle, which is in the repository I added at the end.</p><p>First, we import the libraries we will need later on</p><pre>import numpy as np<br>import pandas as pd<br>import seaborn as sns<br>import autokeras as ak<br>import tensorflow as tf<br>from matplotlib import pyplot as plt<br>from sklearn.preprocessing import StandardScaler<br>from wordcloud import WordCloud, STOPWORDS, ImageColorGenerator</pre><p>We read our data</p><pre>data = pd.read_csv(&#39;finalSpa.csv&#39;)<br>data = data.drop(&#39;Unnamed: 0&#39;, axis =1)</pre><p>Before I started training the model, I wanted to know what the dataset contained, and how the data was being handled.</p><p>So through code I was able to know how the dataset was conformed, here I will only put the results, the code can be seen in my repository (<br>I added link at the end).</p><p>The dataset was conformed by 14,566 lines that spanned from the year 1983 to 2020, and had 21 columns that some of them were the name of the circuit, the driver, the team, the starting position of the race, the final position, among other things. <br>I checked how many null data there were, and the result was zero, which did not complicate the project.<br>As an extra I implemented a word cloud with the names of the drivers that appeared in the dataset (not necessary but to make it look nice).</p><pre>wordcloud2 = WordCloud().generate(&#39; &#39;.join(data[&#39;driver&#39;]))<br>plt.imshow(wordcloud2)<br>plt.axis(&quot;off&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*cf6eLLbKisrrwPFyXo9w5A.png" /></figure><p>Out of pure curiosity I wanted to know how was the distribution of nationalities of drivers from 1983 to date, and we can see it below:</p><pre>sns.set_theme(style=&#39;whitegrid&#39;)<br>plt.figure(figsize=(15,10))</pre><pre>df_tmp = data.groupby(&#39;nationality&#39;,as_index=False)\<br>  .agg(count_drivers = pd.NamedAgg(column=&#39;driver&#39;,aggfunc=&#39;nunique&#39;))\<br>  .sort_values(&#39;count_drivers&#39;,ascending=False)</pre><pre>plt.figure(figsize=(15,15))</pre><pre>graph = sns.barplot(<br>    data=df_tmp,<br>    y =&#39;nationality&#39;,<br>    x=&#39;count_drivers&#39;,<br>    color=&#39;#25B5D9&#39;<br>     ).set_title(<br>    &#39;Formula 1 Driver Nationalities&#39;,<br>    size=14<br>    )</pre><pre>plt.xlabel(&#39;# of drivers&#39;)<br>plt.ylabel(&#39;Nationalities&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aewO_DCLnG-gb-9Z5ffDyw.png" /></figure><p>We could answer any more questions we have but that is not the main purpose of this project.</p><p><strong>Now it’s time to prepare our data for training!</strong></p><p>Before choosing which columns we want to train with, let’s pass all of them to a numerical value, so in the end we have freedom to choose between all the columns.</p><p>One of the columns is “nationality”, so we will give a numerical value to each unique value in this column.</p><pre>data.nationality.unique()</pre><pre>data[&quot;nationality&quot;].replace({&quot;Finnish&quot;: 1, &quot;French&quot;: 2, &quot;Brazilian&quot;: 3, &quot;British&quot;: 4, &quot;Italian&quot;: 5, &quot;American&quot;: 6,&quot;Austrian&quot;: 7, &quot;Colombian&quot;: 8, &quot;Venezuelan&quot;: 9, &quot;Swiss&quot;: 10, &quot;German&quot;: 11, &quot;Chilean&quot;: 12,&quot;Australian&quot;: 13, &quot;Belgian&quot;: 14, &quot;Swedish&quot;: 15, &quot;Dutch&quot;: 16, &quot;Canadian&quot;: 17,&quot;Japanese&quot;: 18, &quot;Spanish&quot;: 19, &quot;Argentine&quot;: 20, &quot;Portuguese&quot;: 21, &quot;Monegasque&quot;: 22, &quot;Danish&quot;: 23, &quot;Czech&quot;: 24, &quot;Malaysian&quot;: 25, &quot;Irish&quot;: 26, &quot;Hungarian&quot;: 27, &quot;Indian&quot;: 28, &quot;Polish&quot;: 29,&quot;Russian&quot;: 30, &quot;Mexican&quot;: 31, &quot;Indonesian&quot;: 32, &quot;New Zealander&quot;: 33, &quot;Thai&quot;: 34}, inplace=True)</pre><p>We will do the same as we did with the nationality column, with the constructor column and circuit_id</p><p>After having all our values in numerics, as our goal is to predict the silverstone race, we will filter only our data from previous years (from 1983 to 2019 because at the end we will predict the 2020 data) that are from the silverstone track.</p><pre>dataSilverstone=data[&#39;circuit_id&#39;]==9 <br>filtered_df = data[dataSilverstone]</pre><p>We give the number of 9, because when converting our columns to numerical, in the circuit_id column the silverstone circuit took the value of 9.</p><p><strong>Preparing the data</strong></p><pre>train = filtered_df</pre><p>As a first test, we will train our x without the columns of ‘driver’, ‘podium’, ‘round’, I will also remove “circuit_id” because as all the data are from the same circuit, it does not contribute anything to put it, and we will train our y with podium values.</p><pre>X_train = train.drop([&#39;driver&#39;, &#39;podium&#39;, &#39;round&#39;, &#39;circuit_id&#39;], axis = 1)</pre><pre>y_train = train.podium</pre><pre>scaler = StandardScaler()<br>X_train = pd.DataFrame(scaler.fit_transform(X_train), columns = X_train.columns)</pre><p><strong>Fitting a classification model using auto-keras</strong></p><pre>tf.keras.backend.set_floatx(&#39;float64&#39;)<br>clf = ak.StructuredDataClassifier(overwrite=True, max_trials=2) #max_trials is the number of models to test<br>clf.fit(X_train, y_train, epochs=400)</pre><p>The result gave us an accuracy: 0.8333, which is quite good.<br>But let’s see what happens if we remove more columns, now, let’s train our x without the ‘driver’, ‘podium’, ‘round’, “circuit_id” columns and now let’s see how it gives us the result if we also remove the constructor column.</p><pre>X_train = train.drop([&#39;driver&#39;, &#39;podium&#39;, &#39;round&#39;, &#39;circuit_id&#39;, &#39;constructor&#39;], axis = 1)</pre><p>This time the accuracy it gave us is 0.9832, quite high.<br>Let’s try another column combination and see what happens before choosing one to predict.</p><p>Now let’s try removing the columns with the driver’s information, such as the number of races won, his points, and age and see what happens.</p><pre>X_train = train.drop([&#39;driver&#39;, &#39;podium&#39;, &#39;round&#39;, &#39;circuit_id&#39;, &#39;constructor&#39;, &#39;driver_points&#39;, &#39;driver_wins&#39;, &#39;driver_standings_pos&#39;, &#39;driver_age&#39;], axis = 1)</pre><p>As a result we get an accuracy of 0.6176, which is quite low, so we know that it is not a good combination for removing.</p><p>There are a huge number of combinations, but for the purposes of this project let’s stick with the one that gave us an accuracy of 0.9832.</p><p><strong>Testing</strong></p><p>For prediction we will use the data from the silverston 2020 race (not in the training data).</p><pre>X_test = pd.read_csv(&#39;testSilverstone.csv&#39;)<br>X_test = X_test.drop(&#39;Unnamed: 0&#39;, axis =1)</pre><pre>drivers = X_test.driver<br>X_test = X_test.drop([&#39;driver&#39;, &#39;podium&#39;, &#39;round&#39;, &#39;circuit_id&#39;, &#39;constructor&#39;], axis = 1)<br>X_test = pd.DataFrame(scaler.transform(X_test), columns = X_test.columns)</pre><pre>z = clf2.predict(X_test)</pre><pre>res = pd.DataFrame({&#39;Driver&#39;: drivers})<br>res[&#39;pos&#39;] = z.astype(int)</pre><p>It predicts the following podium order</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/154/1*lJayYxLhXWCMZIgC-Z7eSA.jpeg" /></figure><p>If we compare with the exact actual results of the podium of the race:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bFsn-Rdz8jtl3iZFfHH_uw.png" /></figure><p>with our prediction, we can see that we only got right the first place, which tells us that verstapen or hamilton will win it, which is very low what we got right, but if we see it in general terms, the actual results the first 6 of the podium were Hamilton, Verstapen, Leclerc, Ricciardo, Norris and Ocon; and we can see that our prediction was that the first 6 places were going to be Hamilton, Verstapen, Ricciardo and Ocon.</p><p>Maybe by choosing other columns, different epochs, different max_trial values we can get closer to the true value of the podium, but even though it is little predicted, I really enjoyed doing this project and “experiment” of trying to predict formula 1:)!</p><p><a href="https://github.com/LauraDi/Formula1-predictive-Analysis">Link to repository</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d48016ed342" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/nobody-can-guarantee-you-anything-in-formula-1-but-are-we-sure-3d48016ed342">Nobody can guarantee you anything in Formula 1 … but are we sure?</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Calcula cuántos años durará tu matrimonio con IA | Un vistazo a los casos de divorcio mexicanos]]></title>
            <link>https://medium.com/lcc-unison/calcula-cu%C3%A1ntos-a%C3%B1os-durar%C3%A1-tu-matrimonio-con-ia-un-vistazo-a-los-casos-de-divorcio-mexicanos-da47754b399f?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/da47754b399f</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[divorce]]></category>
            <category><![CDATA[streamlit]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Guillermo Velazquez]]></dc:creator>
            <pubDate>Thu, 09 Dec 2021 09:57:26 GMT</pubDate>
            <atom:updated>2021-12-09T10:02:30.855Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CqwCW_RphCsmrfnTlOvIJQ.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@sammywilliams?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Sammy Williams</a> on <a href="https://unsplash.com/s/photos/divorces?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Sin más preámbulos, “calcula” <a href="https://share.streamlit.io/guillermovc/prueba_divorcios_pag/pagina.py">aquí </a>cuantos años durará tu matrimonio.</p><p>Consulta <a href="https://github.com/guillermovc/analisis_divorcios/edit/master/README.md">aquí </a>el repositorio de github con el código completo.</p><p>Visita los perfiles de linkedin de los colaboradores:<br>Creador: <a href="https://www.linkedin.com/in/guilllermo-velazquez-4333a0217/">Guillermo Velázquez</a><br>Colaborador: <a href="https://www.linkedin.com/in/martin-jose-vega-4181a2120/">Martín Vega</a></p><h3>Introducción</h3><p>Según <a href="http://datos.gob.mx/">datos.gob.mx</a>, entre el año 2000 y 2014, se registraron 4,923 casos de divorcio en la ciudad de Xalapa, Veracruz, México. Así como 39 distintas características en conjunto de los divorciados.</p><p>Resulta interesante tratar de tomar estos datos, para procesarlos y ver que nos pueden decir acerca de los rasgos más comunes de los matrimonios mexicanos que terminan en divorcio. Así como también, con ayuda de <em>Machine Learning, </em>crear un modelo predictivo que ayude a “calcular” la cantidad de años que un matrimonio durará.</p><h3>Limpieza de los datos</h3><p>Antes de comenzar a hacer cualquier tipo de análisis exploratorio, es necesario limpiar los datos. Así, evitaremos introducir algún tipo de sesgo o comportamiento extraño en las métricas y gráficos que creemos.</p><h4>Carguemos nuestros datos y conozcamos las columnas</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*JYd0OvJrlszoeZf6w32i2g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/268/1*7SMJsEgb02hNn_5gVw9tAw.png" /></figure><h4>Nacionalidad de los divorciados</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/1*z6rvYOinlRXBWzU477Sedw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/384/1*ChPy6bLB3HGNkVztf3q2wQ.png" /></figure><p>Como podemos observar, la gran mayoría de los divorcios involucran a mexicanos o mexicanas (exactamente un 99%). Por lo que podríamos prescindir de las muestras que presentan una nacionalidad distinta, ya que nos concentramos en la población mexicana y nos ayudará luego a reducir la dimensionalidad de nuestros datos ya que podremos asumir que no hay variación en este aspecto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/1*yDqAf39xqzAJs9hDJf9NZQ.png" /></figure><p>Algo muy similar pasa con otras columnas que hacen referencia a ubicaciones, como el lugar de nacimiento (que a su vez se divide en los ciudad y estado). Y para compensar esto, crearemos una nueva columna, que además de condensar los valores <em>lugar_residencia</em>, representará una nueva característica que puede ser de suma importancia en un matrimonio: ¿viven juntos?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/653/1*yZ0Fze522sefRBhPdeqAoA.png" /></figure><h4>Fechas de nacimiento de la pareja</h4><p>Al analizar la distribución de los meses, días y años de los divorciados, se observó que no existe alguno que predominara en los datos. Así que no tiene caso conservar estas columnas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/538/1*c1oMQW-PEmoHYHrdL1kJXw.png" /></figure><h4>Manejando los valores faltantes</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/545/1*8jm3VTbZC2P5FhzRMyP9lA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/863/1*ki56YhtK1T3se1MVRC9y-Q.png" /></figure><p>Podemos ver en el gráfico anterior, que hay columnas que presentan muchos valores faltantes. Algunos de estos, en realidad son convenciones de captura, por ejemplo, el número de hijos, que se dejó vacía cuando el matrimonio no tenia ningún hijo, en vez de capturarse un cero.</p><p>Por otro lado, algunas como <em>ingreso_mensual</em> no tuvieron una justificación lógica (el valor 0 se capturó explícitamente en muchas muestras), por lo que eran verdaderos valores faltantes y debemos manejarlos para mejorar la calidad de nuestros datos.</p><p>Hay ocasiones, como por ejemplo, en el caso de la duración del matrimonio, en el que se pueden imputar datos haciendo uso de otras columnas, en este caso, tomando las fechas de matrimonio y de divorcio para encontrar la duración del primero.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*qkHaf7cANbxbUwngzQ-TSw.png" /></figure><p>En el caso de la edad, podemos eliminar las muestras que contengan valores faltantes. En primera porque son relativamente pocas, y en segunda porque deseamos crear una nueva columna llamada <em>diferencia_edades</em>, que nos permitirá hacer algunos análisis interesantes.</p><h3>Análisis de los datos</h3><h4>Menos divorcios en enero</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*sXBQzoeIGNPT_zmE7BVBwA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/392/1*1D5OUsxd82k5hYiBDj5EXw.png" /></figure><h4>Nivel de educación y profesiones más predominantes</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*-0lwPeXdQnUI2wvN3Lhh_g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/1*XrGpecFkfLKMWUcOYfbGKg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*mTVhRB1RxAgE270RF4y-cQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*003xgPP6HgR4yYiNj8TUvw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*dAs5sbl7CAwjJzqAplyKDA.png" /></figure><h4>Distribución de edades</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FhdG1oW5hkOPCurY9c8M_g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oeY8LmcICO1IOByFdZAgFw.png" /></figure><p>Observando la distribución de edades en los casos de divorcio, notamos que la mayoría se concentran entre las edades 30 y 35.</p><h4>¿Influye la diferencia de edad en un divorcio?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v8afrAO7pcxDdQr1Xvp0eA.png" /></figure><p>Curiosamente, según los datos, hay un gran número de divorcios en parejas con menor diferencia de edad. Siendo la diferencia de edad de un año la que predomina más, con un 19%</p><h4>Número de hijos</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*CTVSX8tN4v9_5JYkQ3BVMA.png" /></figure><h4>¿Viven juntos?</h4><p>Es muy lógico pensar que en los casos de divorcio debe haber una inclinación a parejas que no vivan juntos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*GteAhtraLC3vZd7hHyWj5Q.png" /></figure><h3>Modelo predictivo</h3><p>Para el caso de este set de datos, más que intentar predecir variables, nos interesa analizar las características y los patrones que tienen las parejas que se divorcian. Pero para muestra de la calidad de los datos, intentaremos predecir la duración en años de un matrimonio que sabemos que se divorciará. Para ello utilizaremos un modelo ensemble, Random Forest Regressor, que utiliza varios árboles de decisión para hacer una predicción precisa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/442/1*6oz6hBA3IbY5xXl4Wpl-ZQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/369/1*r3cTgQf85yCKcQfN5Ixq4g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/410/1*Ydj66zDQpAHXIVOUr4cxGg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*4WB7PbT2pUTykllGeKPX3w.png" /></figure><p>Como vemos, nuestro modelo tiene un error absoluto de prácticamente 2 años, lo que es bastante bueno considerando las pocas características que tomamos en cuenta.</p><h3>Gracias por llegar hasta aquí!</h3><p>Recuerda que puedes encontrar el código completo en el repositorio de <a href="https://github.com/guillermovc/analisis_divorcios">GitHub</a>.</p><p>También puedes echarle un vistazo a mi página en Streamlit donde puedes probar el modelo con tus propios datos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*UeQn9ZcZD1YpfWrYzyPUpg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da47754b399f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/calcula-cu%C3%A1ntos-a%C3%B1os-durar%C3%A1-tu-matrimonio-con-ia-un-vistazo-a-los-casos-de-divorcio-mexicanos-da47754b399f">Calcula cuántos años durará tu matrimonio con IA | Un vistazo a los casos de divorcio mexicanos</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Amazon stock price prediction with machine learning]]></title>
            <link>https://medium.com/lcc-unison/amazon-stock-price-prediction-with-machine-learning-4dc57f1d5994?source=rss----5cd0f12fe579---4</link>
            <guid isPermaLink="false">https://medium.com/p/4dc57f1d5994</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[forecasting]]></category>
            <category><![CDATA[stocks]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[predictions]]></category>
            <dc:creator><![CDATA[Eliud Rodríguez]]></dc:creator>
            <pubDate>Thu, 09 Dec 2021 07:50:37 GMT</pubDate>
            <atom:updated>2021-12-09T07:48:44.382Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*5EY1_PaLBxNcDvLf5yMslg.png" /><figcaption><a href="https://stock.adobe.com/mx/images/forecast-graph-growth-progress-diagram-concept-hand-drawn-isolated-vector/228460264">© drawlab19 — Adobe Stock — 228460264</a></figcaption></figure><blockquote><em>Eliud Gilberto Rodríguez Martínez</em></blockquote><blockquote><em>Universidad de Sonora, Licenciatura, Hermosillo, Sonora,<br>México</em></blockquote><blockquote><em>eliud.giroma@gmail.com</em></blockquote><p><strong>Abstract.</strong> This project was made with the objective of forecasting Amazon stock prices for the Advanced Artificial Intelligence Topics class of professor Julio Waissman Vilanova. I took on the task of using different scikit-learn models, such as LinearRegression, SVR (Support vector regression), DecisionTreeRegressor and KNeighborsRegressor</p><p><strong>Keywords: </strong>Forecasting, scikit-learn, prediction, models, stock, price.</p><h3>Introduction.</h3><p>Predicting the stock market as you can imagine is an incredibly difficult task because its value depends on many variables which are active at the same time, this makes obtaining a good forecast very difficult even using machine learning techniques.</p><p>Personally, I had always been struck by trying to predict the stock market with different machine learning models and see what the accuracy of each of these is and which model gives me the best results.</p><p>Even though I wouldn’t recommend making your investments and financial decisions based on the results that you can obtain this way, it’s always fun to make this type of forecast to see how accurate and close to the real price the results of some machine learning models are when trying to predict the stock price “x” days in the future.</p><h3>Plan.</h3><p>The dataset that we’ll use will be obtained from Kaggle and it contains the prices of amazon stocks. You can find the data set <a href="https://www.kaggle.com/kannan1314/amazon-stock-price-all-time/version/2">here</a>.<br>Amazon is an American multinational technology company which focuses on e-commerce, cloud computing, digital streaming, and artificial intelligence.</p><p>This dataset contains Amazon stock prices from 1997 to October 27, 2021, in this work we will use the column “Close”, which contains the closing price, which refers to the last price at which it was trade a stock during a regular trading session.</p><p>This time, we’ll use 4 simple prediction models and we’ll try to predict the price of Amazon stocks 90 days into the future. And as conclusion, we’ll look at the results that were obtained and find out how accurate each of these models were.</p><p>These models are: LinearRegression, SVR (Support vector regression), DecisionTreeRegressor and KNeighborsRegressor from scikit-learn.</p><h3><strong>Code.</strong></h3><p>We import all the libraries that we’ll use, which will be numpy, pandas, matplotlib and the models with train_test_split from scikit-learn</p><pre>import numpy as np<br>import pandas as pd<br>import matplotlib.pyplot as plt<br>from sklearn.tree import DecisionTreeRegressor<br>from sklearn.linear_model import LinearRegression<br>from sklearn.svm import SVR<br>from sklearn.neighbors import KNeighborsRegressor<br>from sklearn.model_selection import train_test_split</pre><p>We read the dataset</p><pre>df = pd.read_csv(&#39;Amazon.csv&#39;)</pre><p>I’ll only take the last 5 years of the dataframe to make the predictions and leave only the “Close” column in the dataframe which contains the prices that will be used for the forecasting.</p><pre>df = df[df[&#39;Date&#39;] &gt; &#39;2016-10-27&#39;]<br>df = df[[&#39;Close&#39;]]</pre><p>To give us a better understanding on how the data is behaving, we plot the closing prices and we get the next graph:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9DGgURX6g9FEDCedJlbxwg.png" /></figure><p>Defining how many days into the future we want to predict, in this case we’ll predict 90 days into the future. We create new column prediction, convert X and Y into a numpy array and removing the last “days_to_predict” rows.</p><pre># Days to predict into the future<br>days_to_predict = 90<br># New Prediction column shifted &#39;x&#39; units/days up<br>df[&#39;Prediction&#39;] = df[[&#39;Close&#39;]].shift(-days_to_predict)</pre><pre># Convert X and Y into a numpy array and removing days_to_predict rows<br>X = np.array(df.drop([&#39;Prediction&#39;], 1))[:-days_to_predict]<br>y = np.array(df[&#39;Prediction&#39;])[:-days_to_predict]</pre><p>Then we split the training and testing data, 80% train data and 20% test data</p><pre># Splitting train and test data<br>x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)</pre><p>Creating DecisionTreeRegressor, LinearRegression, SVR, KNeighborsRegressor models</p><pre># Models<br>tree = DecisionTreeRegressor().fit(x_train, y_train)<br>lr = LinearRegression().fit(x_train, y_train)<br>svr = SVR(kernel =&#39;rbf&#39;, C=1e3).fit(x_train, y_train)<br>kneigh = KNeighborsRegressor(n_neighbors=2).fit(x_train, y_train)</pre><p>Getting rows from dataset except the last “x” days and converting data to a numpy array</p><pre># Getting rows from dataset except the last &quot;x&quot; days<br>future = df.drop([&#39;Prediction&#39;], 1)[:-days_to_predict]<br>future = future.tail(days_to_predict)<br># Converting data to numpy array<br>future = np.array(future)</pre><p>Obtaining models predictions.</p><pre># Getting predictions<br>tree_prediction = tree.predict(future)<br>lr_prediction = lr.predict(future)<br>svr_prediction = svr.predict(future)<br>kneigh_prediction = kneigh.predict(future)<br></pre><p>Finally, once we have our predictions, we can plot these predictions to see how accurate the predictions obtained are, the line in color orange is the “real” data and the color green is our prediction.</p><p>Decision tree regressor prediction:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sNTvGqka4VGf2kNo0MPpOg.png" /></figure><p>Linear regression prediction:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NBvW46L78pPLnAgOuw40mw.png" /></figure><p>SVR prediction:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pvo22kX8B2UlU0y2MUYDPA.png" /></figure><p>KNeighbor regressor prediction:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TE_Xv1tD6KCNkgm5WlztKw.png" /></figure><h3>Conclusion.</h3><p>By simply looking at the graphs we can easily see that the KNeighbor regressor model performed better than Decision tree regressor and this one performed better than the linear regression and SVR.</p><p>Just a final reminder that you shouldn’t make financial decisions and invest on stocks just based on these type of predictions since making accurate and safe predictions is hard and not really reliable.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4dc57f1d5994" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lcc-unison/amazon-stock-price-prediction-with-machine-learning-4dc57f1d5994">Amazon stock price prediction with machine learning</a> was originally published in <a href="https://medium.com/lcc-unison">LCC-Unison</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>