Data Science and Cognitive Computing Courses

Quiero compartir la siguiente página que permite hacer cursos de machine learning, Apache Spark, SQL, Python, R, Data science, Reactive, Scala, Big Data, etc...

Y todos de forma gratuita!

Dejo link: https://cognitiveclass.ai

Procesamiento de lenguaje natural con NLTK

NLTK es una plataforma líder para construir programas en Python para trabajar con datos de lenguaje natural.

Proporciona interfaces fáciles de usar a más de 50 recursos corporales y léxicos como WordNet, junto con un conjunto de bibliotecas de procesamiento de texto para clasificación, tokenización, derivación, etiquetado, análisis y razonamiento semántico, wrappers para bibliotecas de PNL.

NLTK es adecuado para lingüistas, ingenieros, estudiantes, educadores, investigadores y usuarios de la industria por igual. NLTK está disponible para Windows, Mac OS X y Linux. Lo mejor de todo es que NLTK es un proyecto gratuito, de código abierto, impulsado por la comunidad.

NLTK ha sido llamado "una herramienta maravillosa para enseñar y trabajar en lingüística computacional usando Python" y "una biblioteca increíble para jugar con el lenguaje natural".

Veamos unos ejemplos de lo que podemos hacer con nltk:

Tokenizar y etiquetar un texto:

>>> import nltk
>>> sentence = """At eight o'clock on Thursday morning
... Arthur didn't feel very good."""
>>> tokens = nltk.word_tokenize(sentence)
>>> tokens
['At', 'eight', "o'clock", 'on', 'Thursday', 'morning',
'Arthur', 'did', "n't", 'feel', 'very', 'good', '.']
>>> tagged = nltk.pos_tag(tokens)
>>> tagged[0:6]
[('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'), ('on', 'IN'),
('Thursday', 'NNP'), ('morning', 'NN')]

Identificar entidades:

>>> entities = nltk.chunk.ne_chunk(tagged)

>>> entities

Tree('S', [('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'),

           ('on', 'IN'), ('Thursday', 'NNP'), ('morning', 'NN'),

       Tree('PERSON', [('Arthur', 'NNP')]),

           ('did', 'VBD'), ("n't", 'RB'), ('feel', 'VB'),

           ('very', 'RB'), ('good', 'JJ'), ('.', '.')])

Mostrar un árbol de análisis sintáctico:

>>> from nltk.corpus import treebank

>>> t = treebank.parsed_sents('wsj_0001.mrg')[0]

>>> t.draw()

Como estoy usando nltk 3, debo usar python 3. Otra cosa importante tienen que tener instalado python3-tk.

Ojo que si quieren probar estos ejemplos deben hacer :

>>> nltk.download()

Y ahí tienen que bajar los paquetes. 

Tenemos un libro gratuito y online: http://www.nltk.org/book/

Dejo link:
https://www.nltk.org/

5 Cursos de Spring Gratuitos

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con Spring :

• Spring Framework And Dependency Injection For Beginners
• Introducing Spring Boot
• Spring Fundamentals
• Introduction to Spring MVC 4
• Spring & Hibernate for Beginner 

Un ejemplo utilizando Apache Spark Streaming

Lo que vamos a hacer es un proceso que escuche lo que escribimos con "nc" en el puerto 9999. Y luego vamos a contar, es decir vamos a contar las palabras.

Iniciamos spark-shell :

./spark-shell

Luego debemos importar todos los objetos para hacer streaming:

import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._

//Ahora hacemos el contexto de streaming, utilizando el contexto de mi aplicación. A la vez //especificamos el periodo de tiempo que se debe procesar los datos:

val ssc = new StreamingContext(sc, Seconds(10))

// Creamos el DStream para localhost:9999
val lines = ssc.socketTextStream("localhost", 9999)

// indicamos las tareas a realizar con los datos.
val words = lines.flatMap(_.split(" "))
val pairs = words.map(word => (word, 1))

val wordCounts = pairs.reduceByKey(_ + _)

// Imprima los primeros elementos de cada RDD generado en este DStream para la consola

wordCounts.print()

ssc.start()             // comenzamos
ssc.awaitTermination()  // Espere a que termine el cálculo

Y listo, ahora si vamos a otra consola y escribimos :

nc -lk 9999

Este comando va a escribir lo escribimos en el puerto 9999 y nuestra aplicación va a leerlo y contarlo.

Y eso es todo!!!

5 Cursos de Angular Gratuitos

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con Angular :

• Learn Angular 5 from Scratch y Learn Angular 4 from Scratch
• Getting Started with Angular 2+
• Angular: Getting Started
• Angular Fundamentals
• AngularJS Authentication: Secure Your App with Auth0

Eclipse Foundation libero Eclipse Photon IDE

La Fundación Eclipse ha lanzado la última versión de Eclipse IDE. Eclipse Photon ofrece soporte para Java 10 y Java EE 8, mejoras para herramientas de desarrollo de PHP, mejoras de UI y más.

Java 10 es totalmente compatible con Eclipse Java Development Tools (JDT) y permite a los desarrolladores utilizar la inferencia de tipos variables  (JEP 286).

Eclipse Photon también ha agregado una función para convertir un proyecto de Java no modular a un módulo creando un module.info.java. Los desarrolladores también pueden crear un módulo pegando un fragmento de código que represente module-info.java directamente en una carpeta de origen para crear un archivo module-info.java.

El editor de Java se ha mejorado en Eclipse Photon de varias maneras. La coloración de sintaxis de Java se ha mejorado al usar el tema oscuro al reducir el uso de estilo en negrita y cambiar algunos colores que estaban demasiado cerca el uno del otro. Además, ahora es posible escapar de caracteres que no sean ASCII cuando se pegue en un literal de cadena.

Las herramientas de desarrollo de PHP han recibido una serie de mejoras, como soporte de validación para variables no utilizadas / no asignadas, validación para escalares en break / continue, validación para operaciones estáticas para PHP 7 o superior. Además, PHP Explorer ha sido reemplazado por el Explorador de proyectos. Una lista completa de características de PHP está disponible en la sección de PHP en la página Eclipse Photon New y Noteworthy.

Según la Fundación Eclipse, este lanzamiento incluye 85 proyectos con más de 73 millones de líneas de código, con la contribución de 620 desarrolladores, 246 de los cuales son Eclipse committers.

Sin más dejo link:
https://www.eclipse.org/org/press-release/20180627_new-photon-release-of-eclipse-ide-ships-with-full-rust-support.php

Ha descargar!!

5 cursos de Java Gratuitos

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con Java :

• Java Tutorial for Complete Beginners
• Complete Java Masterclass
• Java - The Beginners Series
• Java Fundamentals: The Java Language
• Java Fundamentals - Part 1 and 2

5 cursos gratuitos de Git

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con GIT :

• Git Started with GitHub
• The Ultimate GIT 5-day Challenge
• Getting Started With Git: Key Concepts for Beginners
• Command Line Essentials: Git Bash for Windows
• Short and Sweet: Get Started with Git and GitHub Right Now

La imagen es solo para entendidos ;)

¿Qué hay de nuevo en MongoDB 4.0?

MongoDB 4.0 es un hito importante en la evolución de MongoDB. Esta versión es rápida, flexible y presenta una gran escalabilidad de su diseño de sistemas distribuidos; y a la vez, da la libertad de correr en cualquier lugar, MongoDB 4.0 le permite estandarizar sus aplicaciones en una única y moderna plataforma de datos.

Cortandola con la venta de mongodb podemos nombrar las siguientes mejoras :

• Transacciones ACID multi-documento
• Gráficos MongoDB para una visualización de datos rápida y fácil
• Arrastrar y soltar la construcción de tuberías de agregación
• Integración de Kubernetes y Red Hat OpenShift
• El nuevo MongoDB Mobile

Para discutir estos temas me invitaron a un webinar: 

Register Now

Ojo, Este webinar es mañana 25!

Dejo links: 

https://www.mongodb.com/mongodb-4.0

https://docs.mongodb.com/manual/release-notes/4.0/

¡Oracle Database 18c ahora está disponible para descargar!

Hoy, Oracle lanzó oficialmente Oracle Database 18c para Linux x86-64.

Como recordarán, originalmente lanzamos 18c en Oracle Public Cloud y Oracle Engineered Systems en febrero.

18c es la primera versión de la base de datos que sigue el nuevo modelo de publicación anual. En realidad Oracle Database 18c es "Oracle Database 12c Release 2 12.2.0.2", el nombre simplemente ha sido cambiado para reflejar el año en que se lanzó el producto.

Sin más dejo el link de descarga:
http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html

y el de la documentación :
https://docs.oracle.com/en/database/oracle/oracle-database/18/index.html

Apache NiFi For Dummies

Hortonworks nos regala el libro Apache NiFi for Dummies!!

Y como somos Dummies, nos viene bien :P

Empecemos desde el principio, que es Apache NiFi?

Apache NiFi es una plataforma de procesamiento de eventos y logística de datos integrada. Proporciona una plataforma integral que puede recopilar, seleccionar, analizar y actuar sobre los datos en tiempo real, en nuestros propios servers o en la nube.

En este libro aprenderemos sobre:

• Fundamentos de NiFi
• Casos de uso NiFi
• y cómo comenzar, depurar y administrar sus propios flujos de datos.

Dejo link: https://hortonworks.com/ebook/ni-fi-dummies/

Oracle vs NoSql vs NewSql

Me llego este mail y lo quiero compartir con ustedes:

The cornerstone of any IT system is the database technology being used. And in today’s world of 24x7, real-time connectivity, it’s critical to leverage a technology that meets all of your demands, without sacrificing other areas like performance, availability, scalability or consistency. In this eBook, author John Ryan dives into the pros and cons of various database technologies and explores some key considerations to think about when choosing a database for your real-time requirements. Gain insights into topics, including 5 modern demands of a translytical database ACID vs eventual consistency The OLTP database reimagined 4 applications that need NewSQL technology And more Download EBook VoltDB  |  209 Burlington Road, Suite 203, Bedford, MA 01730   |   T: 978.528.4660 © 2018 VoltDB, Inc.

¿Por qué Python es tan lento?

Python está en auge en popularidad. Se usa en DevOps, Data Science, Desarrollo web y Seguridad.

Sin embargo, no gana ninguna medalla por velocidad.

En comparación con otros lenguajes como Java, C #, Go, JavaScript, C ++, Python es uno de los más lentos. Esto incluye compiladores JIT (C #, Java) y AOT (C, C ++), así como lenguajes interpretados como JavaScript.

Ojo! Cuando decimos "Python", estamos hablando de la implementación de referencia del lenguaje.

Podemos nombrar las siguientes teorías de porque python no es tan rapido:

• Es el GIL (Global Interpreter Lock)
• Es porque se interpreta y no se compila
• Es porque es un lenguaje de tipado dinámico

Estan son las razones más escuchadas pero ¿Cuál es la que tiene mayor impacto?

Es el GIL (Global Interpreter Lock)

Las computadoras modernas vienen con CPU que tienen múltiples núcleos y, a veces, múltiples procesadores. Para utilizar toda esta potencia de procesamiento adicional, el sistema operativo define una estructura de bajo nivel llamada subproceso, donde un proceso (por ejemplo, el navegador Chrome) puede engendrar varios subprocesos y tener instrucciones para el sistema interno. De esta forma, si un proceso requiere una gran cantidad de CPU, esa carga se puede compartir entre los núcleos y esto hace que la mayoría de las aplicaciones.

Un concepto muy importante en este mundo es el de bloqueos. A diferencia de un proceso de subproceso único, debe asegurarse de que al cambiar variables en la memoria, varios subprocesos no intenten acceder  o cambiar la misma dirección de memoria al mismo tiempo.

Cuando CPython crea variables, asigna la memoria y luego cuenta cuántas referencias existen a esa variable, este es un concepto conocido como recuento de referencias. Si el número de referencias es 0, entonces libera esa porción de memoria del sistema. Esta es la razón por la cual la creación de una variable "temporal" dentro de, digamos, el alcance de un bucle for, no explota el consumo de memoria de su aplicación.

El desafío se convierte entonces cuando las variables se comparten en varios hilos, cómo CPython bloquea el recuento de referencias. Hay un "bloqueo de intérprete global" que controla cuidadosamente la ejecución de la secuencia. El intérprete solo puede ejecutar una operación a la vez, independientemente de la cantidad de subprocesos que tenga.

Si tiene una única aplicación de intérprete de subproceso único. No hará ninguna diferencia a la velocidad. Eliminar el GIL no tendría ningún impacto en el rendimiento de tu código.

Si desea implementar la concurrencia dentro de un único intérprete (proceso de Python) mediante el uso de subprocesos, y sus subprocesos son intensivos en IO (por ejemplo, IO de red o IO de disco), verá las consecuencias de la contención de GIL.

Si tiene una aplicación web (por ejemplo, Django) y está utilizando WSGI, entonces cada solicitud a su aplicación web es un intérprete independiente de Python, por lo que solo hay 1 bloqueo por solicitud. Debido a que el intérprete de Python tarda en iniciarse, algunas implementaciones de WSGI tienen un "Modo Daemon" que mantiene los procesos de Python sobre la marcha.

Es porque se interpreta y no se compila

Si decidis ejecutar un script en python, CPython iniciaría una larga secuencia de lecturas, análisis, compilación, interpretación y ejecución de ese código.

Un punto importante en ese proceso es la creación de un archivo .pyc, en la etapa de compilación, la secuencia de bytecode se escribe en un archivo dentro de __pycache __ / en Python 3 o en el mismo directorio en Python 2. Esto no solo se aplica al script, todo el código importado, incluidos los módulos de terceros.

Entonces, la mayoría de las veces (a menos que escriba código que solo ejecuta una vez), Python está interpretando bytecode y ejecutándolo localmente. Compare eso con Java o  .NET :
Java se compila en un "lenguaje intermedio" y la máquina virtual de Java lee el bytecode y lo compila en código de máquina. .NET CIL es el mismo, el .NET Common-Language-Runtime, CLR, utiliza compilación justo a tiempo para el código de la máquina.

Entonces, ¿por qué Python es mucho más lento que Java y C # en los benchmarks si todos usan una máquina virtual y algún tipo de Bytecode? En primer lugar, .NET y Java son JIT-Compiled.

La compilación JIT o Just-in-time requiere un lenguaje intermedio para permitir que el código se divida en fragmentos (o marcos). Los compiladores de anticipación (AOT) están diseñados para garantizar que la CPU pueda entender cada línea del código antes de que tenga lugar cualquier interacción.

El JIT en sí mismo no hace que la ejecución sea más rápida, porque todavía está ejecutando las mismas secuencias de código de bytes. Sin embargo, JIT permite realizar optimizaciones en tiempo de ejecución. Un buen optimizador de JIT verá qué partes de la aplicación se están ejecutando mucho, llame a estos "puntos calientes". Luego hará optimizaciones para esos bits de código, reemplazándolos con versiones más eficientes.

Esto significa que cuando la aplicación hace lo mismo una y otra vez, puede ser significativamente más rápido. Además, tenga en cuenta que Java y C# son lenguajes fuertemente tipados, por lo que el optimizador puede hacer muchas más suposiciones sobre el código.

PyPy tiene un JIT y es significativamente más rápido que CPython. 

Hay desventajas para los JIT, uno de ellos es el tiempo de inicio. PyPy es 2-3 veces más lento que CPython. La máquina virtual de Java es notoriamente lenta para arrancar. El .NET CLR soluciona esto comenzando en el arranque del sistema operativo, pero los desarrolladores del CLR también desarrollan el sistema operativo en el que se ejecuta el CLR.

Si tiene un único proceso de Python en ejecución durante mucho tiempo, con un código que puede optimizarse porque contiene "puntos calientes", entonces un JIT tiene mucho sentido.

Sin embargo, CPython es una implementación de propósito general. Entonces, si estuviera desarrollando aplicaciones de línea de comandos usando Python, tener que esperar que se inicie un JIT cada vez que se llamaba a la CLI sería terriblemente lento.

CPython tiene que tratar de servir tantos casos de uso como sea posible. Hubo la posibilidad de conectar un JIT en CPython, pero este proyecto se ha estancado en gran medida.

Es porque es un lenguaje de tipado dinámico

En un lenguaje "Estáticamente tipado", debe especificar el tipo de una variable cuando se declara. Esos incluirían C, C ++, Java, C #, Go.

En un lenguaje de tipado dinámico, todavía existe el concepto de tipos, pero el tipo de variable es dinámico. Por ejemplo: 

a = 1

a = "foo"

En este ejemplo, Python crea una segunda variable a de tipo de string y desasigna la memoria creada para la primera instancia.

No tener que declarar el tipo no es lo que hace que Python sea lento, el diseño del lenguaje Python le permite hacer casi cualquier cosa dinámica. Puede reemplazar los métodos en objetos en tiempo de ejecución, puede aplicar parche a las llamadas de bajo nivel del sistema operativo a un valor declarado en tiempo de ejecución. Casi todo es posible.

Es este diseño lo que hace que sea increíblemente difícil optimizar Python. Entonces, ¿la escritura dinámica de Python lo hace lento?

Comparar y convertir tipos es costoso, cada vez que se lee una variable, se escribe o se hace referencia a ella, se comprueba el tipo. Es difícil optimizar un lenguaje que es tan dinámico. La razón por la que muchas alternativas a Python son mucho más rápidas es que hacen concesiones a la flexibilidad en nombre del rendimiento. Observar a Cython, que combina C-Static Types y Python para optimizar el código donde se conocen los tipos, puede proporcionar una mejora de rendimiento.

Conclusión

Python es principalmente lento debido a su naturaleza dinámica y versatilidad. Se puede utilizar como una herramienta para todo tipo de problemas, donde las alternativas más optimizadas y más rápidas están probablemente disponibles.

Sin embargo, hay formas de optimizar sus aplicaciones de Python aprovechando la sincronización, entendiendo las herramientas de creación de perfiles y considerando el uso de múltiples intérpretes.

• Para aplicaciones donde el tiempo de inicio no es importante y el código podría beneficiar un JIT, considere PyPy.
• Para partes de su código donde el rendimiento es crítico y tiene más variables de tipo estático, considere usar Cython.

Dejo links:
https://pypy.org/
http://cython.org/
https://www.python.org/

Apache lanzo Groovy 2.5 y el preview de Groovy 3.0

La Apache Foundation lanzó recientemente la versión 2.5 de Groovy, con nuevas características que incluyen:

• Mejoras en las transformaciones de AST
• Nuevo soporte de macros
• Otras mejoras...

Groovy 2.5 requiere JDK 7 y se ejecuta en JDK 9+ .

A pesar des crecimiento de otros lenguajes de JVM como Kotlin, Groovy todavía está experimentando un gran crecimiento. Los números de descarga de Groovy aún lo convierten en el segundo lenguaje más popular en JVM después de Java y los números siguen aumentando. Para el primer trimestre de este año, hubo 90 millones de descargas, el doble de descargas que el primer trimestre del año pasado. Como puede ver, todavía hay mucho interés en Groovy.

Groovy también ha ganado 30 nuevos committers en los últimos 12 meses.

Como se muestra en el siguiente diagrama, se mejoraron algunas de las transformaciones AST existentes para lograr consistencia entre las transformaciones y se agregaron 11 nuevas transformaciones para la versión 2.5. Se agregó una transformación adicional para Groovy 3.0, pero podrían aparecer más antes de la versión GA.

La metaprogramación en tiempo de compilación en Groovy permite la generación de código en tiempo de compilación. Esas transformaciones se denominan transformaciones AST. Las transformaciones de AST le permiten enganchar en el proceso de compilación, modificar el AST y continuar el proceso de compilación para generar bytecode regular. En comparación con la metaprogramación de tiempo de ejecución, esto tiene la ventaja de hacer que los cambios sean visibles en el archivo de clase mismo (es decir, en el bytecode). Hacerlo visible en bytecode es importante, por ejemplo, si desea que las transformaciones formen parte del contrato de clase (implementando interfaces, ampliando clases abstractas, ...) o incluso si necesita que su clase sea invocable desde Java (u otros lenguajes JVM) ) Por ejemplo, una transformación AST puede agregar métodos a una clase. Si lo haces con metaprogramación en tiempo de ejecución, el nuevo método solo sería visible desde Groovy. Si haces lo mismo con la metaprogramación en tiempo de compilación, el método también sería visible desde Java. Por último, pero no menos importante, el rendimiento probablemente sería mejor con la metaprogramación en tiempo de compilación (porque no se requiere una fase de inicialización).

Groovy 3.0.0-alpha-3 ha estado disponible desde finales de junio con versiones beta programadas para finales de este año y release candidates previstos para principios de 2019.

Dejo links:
https://objectcomputing.com/resources/events/webinars/groovy-update-webinar/recording

https://speakerdeck.com/paulk/groovy-roadmap

Apache Spark MLlib parte 4

Continuamos!!!

Vamos a ver un ejemplo utilizando el algoritmo Kmeans que es uno de los algoritmos más fáciles de clasificación.

K-means es un método de agrupamiento, que tiene como objetivo la partición de un conjunto de n observaciones en k grupos en el que cada observación pertenece al grupo cuyo valor medio es más cercano.

Si bien se puede indicar que es una técnica utilizada por minería de datos más que para Maching learning, vamos a empezar de a poco.

Empecemos viendo los datos, los cuales supongamos ya hemos limpiado :

0 1:0.0 2:0.0 3:0.0
1 1:0.1 2:0.1 3:0.1
2 1:0.2 2:0.2 3:0.2
3 1:9.0 2:9.0 3:9.0
4 1:9.1 2:9.1 3:9.1
5 1:9.2 2:9.2 3:9.2

Como se puede ver son 4 columnas, de la cuales la primera es un id (identificador) y las demás están compuestas por un indice y un dato, por ejemplo 1:0.0 (el indice es 1 y el dato 0.0 el cual es continuo)

Esto se encuentra en el archivo sample_kmeans_data.txt

Empecemos tomando los datos y llevándolos a un RDD :

//creamos la aplicación de spark si utilizamos spark-shell esto no es necesario.
val spark = SparkSession.builder.appName("KMeansExample") .getOrCreate()

//Leemos el archivo con el formato libsvm
val dataset = spark.read.format("libsvm").load("path/sample_kmeans_data.txt")

//Probamos que se leyeron los datos, si estamos en spark-shell
dataset.show()
+-----+--------------------+
|label|            features|
+-----+--------------------+
|  0.0|           (3,[],[])|
|  1.0|(3,[0,1,2],[0.1,0...|
|  2.0|(3,[0,1,2],[0.2,0...|
|  3.0|(3,[0,1,2],[9.0,9...|
|  4.0|(3,[0,1,2],[9.1,9...|
|  5.0|(3,[0,1,2],[9.2,9...|
+-----+--------------------+

// Entrenamos nuestro modelo

import org.apache.spark.ml.clustering.KMeans

val kmeans = new KMeans().setK(2).setSeed(1L)
val model = kmeans.fit(dataset)

// Evaluamos la agrupación mediante el cómputo dentro de la suma establecida de errores cuadrados.
val WSSSE = model.computeCost(dataset)
println(s"Within Set Sum of Squared Errors = $WSSSE")

// Mostramos el resultado
println("Cluster Centers: ")
model.clusterCenters.foreach(println)
[0.1,0.1,0.1]
[9.1,9.1,9.1]

Para los que como yo no entendieron que paso el ultimo momento... Reiteramos!

Dado un conjunto de observaciones (x1, x2, …, xn), donde cada observación es un vector real de d dimensiones, k-means construye una partición de las observaciones en k conjuntos (k ≤ n) a fin de minimizar la suma de los cuadrados dentro de cada grupo (WCSS): S = {S1, S2, …, Sk}

Si vemos la Wikipedia : 

Paso de asignación: Asigna cada observación al grupo con la media más cercana (es decir, la partición de las observaciones de acuerdo con el diagrama de Voronoi generado por los centroides).

${\displaystyle S_{i}^{(t)}={\big \{}x_{p}:{\big \|}x_{p}-m_{i}^{(t)}{\big \|}\leq {\big \|}x_{p}-m_{j}^{(t)}{\big \|}\ \forall \ 1\leq j\leq k{\big \}}}$

Donde cada ${\displaystyle x_{p}}$ va exactamente dentro de un ${\displaystyle S_{i}^{(t)}}$, incluso aunque pudiera ir en dos de ellos.

Paso de actualización: Calcular los nuevos centroides como el centroide de las observaciones en el grupo.

${\displaystyle \mathbf {m} _{i}^{(t+1)}={\frac {1}{|S_{i}^{(t)}|}}\sum _{\mathbf {x} _{j}\in S_{i}^{(t)}}\mathbf {x} _{j}}$

El algoritmo se considera que ha convergido cuando las asignaciones ya no cambian.

Grafícado : 

• Demostración del algoritmos estándar
• 

  1) k centroides iniciales (en este caso k=3) son generados aleatoriamente dentro de un conjunto de datos (mostrados en color).
 
• 

  2) k grupos son generados asociándole el punto con la media más cercana. La partición aquí representa el diagrama de Voronoi generado por los centroides.
 
• 

  3) EL centroide de cada uno de los k grupos se recalcula.
 
• 

  4) Pasos 2 y 3 se repiten hasta que se logre la convergencia.

Si hablamos en criollo el algoritmo trata de hacer grupos y calcular su centro, y va moviendo el centro según los datos hasta que estos centros no cambian y ahí finaliza.