Programación funcional para el aprendizaje profundo

Autor: Joyce Xu

Tradutor: Paula Vidal

 

 

Hasta hace poco tiempo atras, el concepto de “programación funcional” y “aprendizaje automático” se atribuía a dos mundos claramente separados. El primero es un paradigma de programación que ha ganado popularidad, cuando el mundo ha recurrido a la simplicidad y la modularidad para producir aplicaciones escalables complejas; el segundo es una herramienta utilizada para instruir una computadora como un autocomplementado de garabatos y el otro para componer música. Por lo tanto, no existia diálogo entre estos dos elementos.

Pero al estudiarlos y profundizarlos con cuidado, uno se da cuenta de que su superposición es práctica y teórica. En primer lugar, el aprendizaje automático no es un elemento en sí mismo, sino que, para que se aproveche mejor, debe incorporarse en aplicaciones escalables complejas. En segundo lugar, el aprendizaje automático, y en particular el aprendizaje profundo, es funcional en su diseño:

  • Los modelos de aprendizaje profundo estan compuestos en series: la programación funcional implica la composición de cadenas de funciones de orden superior para operar en estructuras de datos simples. Las redes neuronales están diseñadas de la misma manera, unidas las funciones de transformación de una capa a otra, para operar en una matriz simple de datos de entrada. De hecho, todo el proceso de aprendizaje profundo puede verse como la optimización de un conjunto de funciones compuestas. Esto significa que los modelos en sí mismos son intrínsecamente funcionales

 

  • Los componentes del aprendizaje profundo son inmutables: cuando aplicamos las funciones a los datos de entrada, nuestros datos no cambian, sino que se produce un nuevo conjunto de valores. Además, cuando los pesos están actualizados, no necesitan ser “cambiados” sino reemplazados por un nuevo valor. En teoría, la actualización de ponderación se puede aplicar en cualquier orden (es decir, no dependen uno del otro) y, por lo tanto, no es necesario realizar un seguimiento secuencial del cambio relativo.

 

  • La programación funcional ayuda y facilita a la paralelización. Algo más importante, es que las funciones que son totalmente compuestos en serie y son fáciles de paralelizar. Esto implica una mayor velocidad y poder computacional. La programación funcional proporciona concurrencia y paralelismo a casi cero costos, lo que hace que sea más fácil trabajar en aprendizaje profundo con modelos grandes y distribuidos.

 

Existen diferentes teorías y perspectivas sobre la combinación de programación funcional y aprendizaje profundo, tanto desde un punto de vista matemático como práctico, pero a veces es más fácil verlo de una manera práctica. En este artículo vamos a presentar las ideas que subyacen a la programación funcional y cómo aplicarlas en un modelo de aprendizaje profundo Cortex para la clasificación de valores anómalos.

 

Las bases de Clojure

Antes de continuar con el tutorial de Cortex, vamos a presentar algunas nociones básicas sobre Clojure. Clojure es un lenguaje de programación funcional que es excelente para la concurrencia y el procesamiento de datos. Afortunadamente para nosotros, estos son extremadamente útiles en el aprendizaje automático. De hecho, la razón principal por la que utilizamos Clojure para el aprendizaje automático es que el trabajo de preparación de conjuntos de datos de practica (manipulación de datos, procesamiento, etc.) puede compensar fácilmente la implementación de los algoritmos, especialmente cuando existen bibliotecas sólidas como Cortex. Usar Clojure y .edn (en lugar de C ++ y protobuf) nos da una ventaja en términos de velocidad en los proyectos de aprendizaje automático.

Puede encontrar una introducción más detallada sobre este lenguaje lo puedes encontrar aquí.

Comencemos con lo básico: el código de Clojure se compone de un conjunto de términos . Estos están encerrados entre paréntesis y generalmente se tratan como funciones de llamada. (+ 2 3)          ; => 5
(if false 1 0)   ; => 0

Hay 4 estructuras de datos básicas: vectores, listas, hash-maps y sets. Las comas se consideran espacios en blanco, por lo que generalmente se omiten.

[1 2 3]            ; vector (ordered)
‘(1 2 3)           ; lists (ordered)
{:a 1 :b 2 :c 3}   ; hashmap or map (unrdered)
#{1 2 3}           ; set (unordered, unique values)

La comilla simple, que precede a la lista, es solo un instrumento para garantizar que no se detecte como un concepto.

Clojure también tiene muchas funciones integradas para trabajar en estas estructuras de datos. Parte del atractivo de Clojure radica en su diseño rico en características para muy pocos tipos de datos, lo que contrasta con la práctica común de tener pocas funciones especializadas para la mayor cantidad posible de estructuras de datos. Clojure, al ser un lenguaje de programación funcional, admite funciones de alto nivel, lo que significa que las funciones se pueden importar como argumentos en otras funciones.

 

(count [a b c])              ; => 3

(range 5)                    ; => (0 1 2 3 4)

(take 2 (drop 5 (range 10))) ; => (5 6)

(:b {:a 1 :b 2 :c 3})        ; use keyword as function => 2

(map inc [1 2 3])            ; map and increment => (2 3 4)

(filter even? (range 5))     ; filter collection based off predicate => (0 2 4)

(reduce + [1 2 3 4])         ; apply + to first two elements, then apply + to that result and the 3rd element, and so forth => 10

Por supuesto, podríamos escribir nuestras funciones en Clojure usando defn. La definición de las funciones de Clojure sigue la forma (defn fn-name [params*] expressions )y también devuelve el valor de la última expresión en el cuerpo.

(defn add2
[x]
(+ x 2))(add2 5)     ; => 7

Las expresiones “let” crean y asocian las variables dentro de los ámbitos léxicos, llamados ámbito léxico, de “let”. Esto se hace en la expresión (let [a 4] (…)), donde la variable “a” tiene un valor de 4 solo en los parentesis internos. Estas variables se llaman “locales”.

(defn square-and-add
[a b]
(let [a-squared (* a a)
b-squared (* b b)]
(+ a-squared b-squared)))

(square-and-add 3 4)       ; => 225

Finalmente, tenemos dos formas de crear funciones “anónimas”, que se pueden asignar a una función funcional local o una función de orden superior.

(fn [x] (* 5 x))          ; anonymous function#(* 5 %)                  ; equivalent anonymous function, where the % represents the function’s argument(map #(* 5 %) [1 2 3])    ; => (5 10 15)

Esto es todo con respecto a la información para tener una base. Ahora que hemos aprendido algunas nociones sobre Clojure, volvamos al aprendizaje automático.

 

Cortex

Cortex está escrito en Clojure, y actualmente es una de las bibliotecas de aprendizaje automático más grandes y de más rápido crecimiento, que utiliza un lenguaje de programación funcional. El resto del artículo se centrará en cómo construir un modelo de clasificación en Cortex, junto con los paradigmas de programación funcional y las técnicas de enriquecimiento de datos (aumento de datos) requeridas.

Data preprocessing

Tomamos un conjunto de datos de fraude de tarjetas de crédito proporcionado por este sitio. Estos conjuntos de datos son muy desequilibrados, debido al hecho de que los contenedores solo tienen 492 cajas de frondas positivas de un total de 248,807, en la práctica 0,172%. Esto creará problemas, pero por ahora, veamos los datos y veamos cómo funciona el modelo.

Para garantizar el anonimato de los datos personales, todas las características originales, excepto “time” y “amount”, ya se han transformado en componentes principales, o PCA (donde cada entrada representa una nueva variable que contiene la información más relevante de los datos sin procesar ). Una breve mirada a los datos nos muestra que la primera variable “time” tiene un contenido de información limitado, por lo que la dejamos de lado. A continuación vemos como se ve nuestro grupo de códigos:

 

(ns fraud-detection.core

(:require [clojure.java.io :as io]

[clojure.string :as string] [clojure.data.csv :as csv] [clojure.core.matrix :as mat] [clojure.core.matrix.stats :as matstats]

[cortex.nn.layers :as layers]

[cortex.nn.network :as network]

[cortex.nn.execute :as execute]

[cortex.optimize.adadelta :as adadelta]

[cortex.optimize.adam :as adam]

[cortex.metrics :as metrics]

[cortex.util :as util]

[cortex.experiment.util :as experiment-util]

[cortex.experiment.train :as experiment-train]))

(def orig-data-file “resources/creditcard.csv”)

(def log-file “training.log”)

(def network-file “trained-network.nippy”)

;; Read input csv and create a vector of maps {:data […] :label [..]},

;; where each map represents one training instance in the data

(defonce create-dataset

(memoize

(fn []

(let [credit-data (with-open [infile (io/reader orig-data-file)]

(rest (doall (csv/read-csv infile))))

data (mapv #(mapv read-string %) (map #(drop 1 %) (map drop-last credit-data))) ; drop label and time

labels (mapv #(util/idx->one-hot (read-string %) 2) (map last credit-data))

dataset (mapv (fn [d l] {:data d :label l}) data labels)]

dataset))))

 

Lo encuentran aqui : fraud-detection-data.cjl

Las redes neuronales Cortex utilizan datos de entrada en forma de mapas, donde cada mapa representa un solo dato con una etiqueta asociada (por ejemplo, si tengo una imagen de perro, la etiqueta será “perro”). Una clasificación, por ejemplo, puede aparecer como [{:data [12 10 38] :label “cat”} {:data [20 39 3] :label “dog“} … ]

En nuestra función para crear conjuntos de dataset ad hoc, vemos que en el archivo de formato de comma-separated value, todas las columnas distintas de la última forman nuestros “data” (o características), mientras que la última columna representa el label , o la etiqueta. Mientras tanto, transformamos los label one-hot vector  (por ejemplo [0 1 0 0]) en función de la clase de clasificación. Esto se debe a que la última capa soft max  en nuestra red neuronal produce un vector de probabilidad de clase, no la etiqueta en sí misma. Finalmente, creamos el mapa a partir de estas dos variables y lo guardamos como un dataset.

 

Descripción del modelo

Crear un modelo en Cortex es una operación bastante simple y directa. En primer lugar, debemos definir un mapa de parámetros más altos que se utilizarán más adelante durante el entrenamiento. Más tarde, para definir el modelo, simplemente unimos las capas:

(def params

{:test-ds-size      50000 ;; total = 284807, test-ds ~= 17.5%

:optimizer         (adam/adam)   ;; alternately, (adadelta/adadelta)

:batch-size        100

:epoch-count       50

:epoch-size        200000})

(def network-description

[(layers/input (count (:data (first (create-dataset)))) 1 1 :id :data) ;width, height, channels, args

(layers/linear->relu 20) ; num-output & args

(layers/dropout 0.9)

(layers/linear->relu 10)

(layers/linear 2)

(layers/softmax :id :label)])

Donde network-description es un vector de capas de redes neuronales. Nuestro modelo consiste en:

  • Una capa con input
  • Una capa totalmente conectada (y lineal) con la función de activación  ReLu
  • Un layer drop out
  • Otro extraño completamente conectado con ReLu
  • Una capa con output de 2 dimesiones pasa a través de la función softmax

 

En la primera y la última capa, debemos especificar un : id. esto se refiere a una clave en el mapa de datos en la cual nuestra red deberia observar. Recuerde que el mapa resulta como {: data […]: label […]}). Para nuestra capa de input, pasamos: identificación de datos para que el modelo tome datos de entrenamiento en los próximos pasos. En la capa final, sin embargo, proporcionamos: label como : id, de modo que podamos usar el label real para calcular nuestro error.

Entrenamiento y evaluación

A partir de aquí se vuelve más complejo. La función de entrenamiento no es realmente tan complicada: Cortex da funciones preconstruidas para un entrenamiento de alto nivel, por lo que todo lo que tenemos que hacer es establecer nuestros parámetros (la red, el dataset de entrenamiento y verificación, etc.). La única advertencia que le damos es que el sistema espera un conjunto de dataset “infinitos” para el entrenamiento. sin embargo, Cortex presenta una función llamada infinite-class-balanced-dataset que nos ayuda a transformarla.

(defn train

“Trains network for :epoch-count number of epochs”

[]

(let [network (network/linear-network network-description)

[train-orig test-ds] (get-train-test-dataset)

train-ds (experiment-util/infinite-class-balanced-dataset train-orig

:class-key :label

:epoch-size (:epoch-size params))]

(experiment-train/train-n network train-ds test-ds

:batch-size (:batch-size params)

:epoch-count (:epoch-count params)

:optimizer (:optimizer params)

:test-fn f1-test-fn)))

Entonces llegamos a la parte compleja: f1-test-fn. Durante el entrenamiento, de hecho, la función train-n espera que se le proporcione un: test-fn que verifique su rendimiento y determine si se debe guardar como una “best network” . Existe una función de prueba que llama default que identifica la pérdida cross-entropica (cross-entropy loss)  pero su valor de pérdida no es tan simple de interpretar y, además, no se ajusta perfectamente a nuestro conjunto de dataset desequilibrado. Para resolver este problema, escribiremos una función de prueba personal.

 

Pero ahora surge una pregunta: ¿cómo podemos verificar el rendimiento de nuestro modelo? La métrica estándar en las tareas de clasificación suele ser la precisión, pero, con nuestro conjunto de datos desequilibrado, esta medición es casi inútil. Dado que los ejemplos positivos solo representan el 0,172% del conjunto de datos total, incluso un modelo que se limita a predecir ejemplos negativos, podría alcanzar una precisión del 99.828%. Un porcentaje particularmente alto, pero si este modelo se usara en la realidad, surgirían varios problemas.

Entonces, un mejor grupo de métricas son: precisión, recuperación, y F1 score (o genericamente F-beta).

1 1

 

Precisamente, por lo tanto, nos enfrentamos a una pregunta: “de todos los ejemplos que predije que serían positivos, ¿qué proporción es  positiva?” En cuanto a la recuperación, preguntamos: “de todos los ejemplos positivos, ¿qué proporción es mas exacta y  predice que sea positivo?

El puntaje F-beta (una generalización del puntaje tradicional F1) es un promedio ponderado de precisión y recuperación, medido en una escala de 0 a 1:

2.jpg 2

Cuando beta = 1, obtenemos F1 a partir of2 * (precisión * recuperación) / (precisión + recuperación). Usualmente, beta representa cuántas veces la recuperación debería ser más importante que la precisión. En nuestro modelo, utilizamos el puntaje F1 como nuestro puntaje para estar muy cerca, pero también registramos los puntajes de precisión y recuperación para detectar el saldo. Este es nuestro f1-test-fn

 

(defn f-beta

“F-beta score, default uses F1”

([precision recall] (f-beta precision recall 1))

([precision recall beta]

(let [beta-squared (* beta beta)]

(* (+ 1 beta-squared)

(try                         ;; catch divide by 0 errors

(/ (* precision recall)

(+ (* beta-squared precision) recall))

(catch ArithmeticException e

0))))))

(defn f1-test-fn

“Test function that takes in two map arguments, global info and local epoch info.

Compares F1 score of current network to that of the previous network,

and returns map:

{:best-network? boolean

:network (assoc new-network :evaluation-score-to-compare)}”

[;; global arguments

{:keys [batch-size context]}

;per-epoch arguments

{:keys [new-network old-network test-ds]} ]

(let [batch-size (long batch-size)

test-results (execute/run new-network test-ds

:batch-size batch-size

:loss-outputs? true

:context context)

;;; test metrics

test-actual (mapv #(vec->label [0.0 1.0] %) (map :label test-ds))

test-pred (mapv #(vec->label [0.0 1.0] % [1 0.9]) (map :label test-results))

precision (metrics/precision test-actual test-pred)

recall (metrics/recall test-actual test-pred)

f-beta (f-beta precision recall)

;; if current f-beta higher than the old network’s, current is best network

best-network? (or (nil? (get old-network :cv-score))

(> f-beta (get old-network :cv-score)))

updated-network (assoc new-network :cv-score f-beta)

epoch (get new-network :epoch-count)]

(experiment-train/save-network updated-network network-file)

(log (str “Epoch: ” epoch “\n”

“Precision: ” precision  “\n”

“Recall: ” recall “\n”

“F1: ” f-beta “\n\n”))

{:best-network? best-network?

:network updated-network}))

La función ejecuta la red en el conjunto de prueba, calcula la puntuación F1 y, finalmente, actualiza y guarda la red como resultado. Además, imprime cada una de nuestras métricas de evaluación en cada punto. Si ahora ejecutamos el REPL, obtendríamos una puntuación que sería más o menos la misma:

 

Epoch: 30
Precision: 0.2515923566878981
Recall: 0.9186046511627907
F1: 0.395

Un resultado bastante pobre.

Enriquecimiento de datos (Data Augmentation)

Aquí nos encontramos con el problema del que hablamos al principio de este artículo, debido al desequilibrio del dataset. El modelo ahora no tiene suficientes ejemplos positivos de los que aprender. Cuando llamamos experiment-util/infinite-class-balanced-dataset en nuestra función de entrenamiento, de hecho estamos creando cientos de copias de cada instancia de entrenamiento positivo para equilibrar nuestro dataset. Como resultado, el modelo almacena esos valores de características, en lugar de aprender la distinción entre clases.

Una forma de resolver este problema es utilizar el enriquecimiento de datos, con el cual genero datos adicionales y artificiales basados en los ejemplos que ya tenemos disponibles. Para crear ejemplos de entrenamiento que sean positivos, debemos agregar cualquier cantidad de ruido a los features vectors  (vectores que contienen las características) para cada ejemplo positivo existente. La cantidad de ruido que agreguemos dependerá de la varianza de cada característica en las clases positivas, de modo que las características con amplia diferencia están enriquecidas con una gran cantidad de ruido, y lo opuesto para aquellas con baja diferencia.

A continuación se muestra el código para el enriquecimiento de datos:

(defonce get-scaled-variances

(memoize

(fn []

(let [{positives true negatives false} (group-by #(= (:label %) [0.0 1.0]) (create-dataset))

pos-data (mat/matrix (map #(:data %) positives))

variances (mat/matrix (map #(matstats/variance %) (mat/columns pos-data)))

scaled-vars (mat/mul (/ 5000 (mat/length variances)) variances)]

scaled-vars))))

(defn add-rand-variance

“Given vector v, add random vector based off the variance of each feature”

[v scaled-vars]

(let [randv (map #(- (* 2 (rand %)) %) scaled-vars)]

(mapv + v randv)))

(defn augment-train-ds

“Takes train dataset and augments positive examples to reach 50/50 balance”

[orig-train]

(let [{train-pos true train-neg false} (group-by #(= (:label %) [0.0 1.0]) orig-train)

pos-data (map #(:data %) train-pos)

num-augments (- (count train-neg) (count train-pos))

augments-per-sample (int (/ num-augments (count train-pos)))

augmented-data (apply concat (repeatedly augments-per-sample

#(mapv (fn [p] (add-rand-variance p (get-scaled-variances))) pos-data)))

augmented-ds (mapv (fn [d] {:data d :label [0 1]}) augmented-data)]

(shuffle (concat orig-train augmented-ds))))

augment-train-ds  tome nuestro dataset de entrenamiento original, calcule el número de enriquecimientos necesarios para lograr un equilibrio de clase de 50/50, y luego aplica estos enriquecimientos a nuestros ejemplos existentes a través de cualquier vector de ruido (add-rand-variance) según la diferebcua permitida (get-scaled-variances ). Finalmente, unimos los ejemplos enriquecidos con el conjunto dataset original y obtenga un dataset equilibrado.

Durante el entrenamiento, el modelo detecta una cantidad irrealmente grande de ejemplos positivos, mientras que el conjunto de verificación se mantendrá positivo al 0.172%. como resultado, aunque el modelo pueda aprender mejor la diferencia entre las dos clases, abrumaremos a nuestra clase con ejemplos positivos. Para resolver este problema, podemos cambiar los umbrales relevantes para forzar la predicción positiva durante la prueba. En otras palabras, en lugar de exigir al modelo al menos el 50% de certeza de la positividad de los ejemplos para clasificarlos como tales, podemos aumentar la demanda al menos al 70%. Después de algunas pruebas, notamos que el umbral mínimo debe establecerse en 90%. El código se puede encontrar en vec-> labelfunction en el código fuente, y se hace referencia a la línea 31 de f1-test-fn.

Usando el nuevo y enriquecido dataset de entrenamiento, nuestros puntajes se ven así:

Epoch: 25
Precision: 0.8658536585365854
Recall: 0.8255813953488372
F1: 0.8452380952380953

Resultados significativamente mejores que los anteriores.

Conclusiones

Este modelo obviamente aún puede mejorarse. Aquí les damos algunos consejos:

  • ¿Todas las características de PCA feature son informativas? Observe la distribución de valores para ejemplos positivos y negativos a través de las características y descarte cualquier característica que no ayude a distinguir entre las dos categorias.
  • ¿Hay otras arquitecturas de redes neuronales, funciones de activación, etc. que funcionan mejor?
  • ¿Existen diferentes técnicas de enriquecimiento de datos que podrían funcionar mejor?
  • ¿Cómo se compara el rendimiento del modelo en Cortex con Keras/Tensorflow/Theano/Caffe?

El código completo de fuente  para este proyecto se puede encontrar aquí. Le recomendamos que experimente con los siguientes pasos para explorar diferentes arquitecturas de red ( aquí hay un buen ejemplo de clasificación de imágenes en CNN que puede tomar como referencia).

¿Cómo encontrar un trabajo como data scientist?

Autor: Favio Vázquez

Tradutor: Paula Vidal

 

 

1 1

Este artículo es el resultado de 3 publicaciones que publiqué recientemente en LinkedIn. Puedes encontrarlos aquí: parte 1parte 2, y parte 3.

Esta es una pregunta que a menudo recibo de personas que conozco y de aquellos que forman parte de mi red en LinkedIn.

Te contaré sobre mi experiencia. He trabajado como Data Scientist desde hace un tiempo, pero te contaré cómo obtuve mi trabajo actual en BBVA Data & Analytics

El año pasado terminé mi maestría en física, especializándome en cosmología bayesiana y aprendizaje automático. Justo antes de graduarme, me detuve para reflexionar sobre lo que quería hacer y me di cuenta de que me atraía el area de data science.

Envié alrededor de 125  solocitudes, recibiendo solo treinta respuestas, de las cuales muchas fueron amables “no, gracias”. No estaba preparado para recivir todas estas cantidades de respuesta negativas. Así que participé en 15 entrevistas y tomé valiosas lecciones de cada una de ellas; Estudié mucho, programé todos los días, leí innumerables artículos y publicaciones, cada uno de los cuales me ayudó a mejorar.

Entonces llegamos a la gran  pregunta, ¿cómo conseguí este trabajo?

 

2.jpg 1

Con mucha paciencia No fue fácil, pero en la séptima entrevista finalmente me di cuenta de que:

  • Mucha gente no tenía idea de qué se trataba el data science.
  • El recluter es tu mejor amigo durante el tiempo de la entrevista, lo que él quiere es ayudarte a sentirte cómodo. Así que créeme, déjanos ayudarte y no temas hacer preguntas.
  • Las personas están mucho más interesadas en cómo puede resolver un problema y cómo se relaciona con diferentes situaciones, en lugar de su conocimiento técnico.

En ese momento estaba muy preparado para responder cualquier pregunta sobre algoritmos, aprendizaje automático,  Python, Spark, pero no a otros que probaron mis habilidades para resolver problemas.

En la octava entrevista, conte todo lo que había hecho como Data Scientist, como ingeniero de información, como físico, pero también como persona. Ahora podía responder cualquier pregunta que me hiciera: cómo manejar situaciones difíciles o nuevos datos e información, cómo explicar conceptos complejos a los gerentes, etc.

Esto me permitió mejorar considerablemente y hablar con calma y serenidad. Ya sabía que la gente de recursos humanis querían ayudarme a ingresar a la empresa.

 

 

Así que aquí hay algunos consejos personales sobre cómo obtener un puesto como Data Scientist:

  • Mantén la calma. Probablemente enfrentará cien distintas entrevistas de trabajo antes de conseguir un trabajo.
  • Prepárese, no solo estudiando conceptos y teoría, y recuerde que será una pieza importante de la compañía en la que se unirá y en la que tendrá que tratar con múltiples personas y situaciones. Prepárese para responder preguntas sobre su comportamiento en posibles escenarios de trabajo.

 

  • Cree una cartera con algunos de sus proyectos y datos reales, que puede publicar convenientemente en GitHub. Además de las competiciones de Kaggle, encuentre algo que le interese, un problema para resolver y aplicar todo su conocimiento.
  • El entrevistador es tu amigo, tiene las mejores intenciones y puede darte consejos valiosos.

 

  • No tema hacer preguntas a otras personas, preguntar qué hacen y cómo llegaron allí. Personalmente, le recomiendo que lea el mensaje por Matthew Mayo Así que aquí hay algunos consejos personales sobre cómo conseguir una posición de Data Scientist
  • No tema hacer preguntas a otras personas, preguntar qué hacen y cómo llegaron allí. Personalmente, sugiero que lea la publicación de Matthew Mayo “A day in the life of a Data Scientist” para tener una mejor idea del trabajo que va a hacer.

 

  • Si está buscando una pasantía, resalte sus experiencias académicas, para tener una mejor idea del trabajo que vas a hacer.

Les deseo el mayor de los éxitos

 

Siganme en : https://www.linkedin.com/in/faviovazquez/.

Deep Learning Italia – Roma – Luglio 2018

1) Francesco Pugliese – Co-Founder Deep Learning Italia | Ricercato ISTAT
“Introduzione divulgativa alle Reti Neurali e al Deep Learning”.
Abstract: Descrizione introduttiva del modello del neurone artificiale e confronto con il neurone biologico, la storia delle reti neurali e come si è arrivati oggi al Deep Learning, detrattori vs sostenitori delle reti neurali e vittoria dei sostenitori (Hinton, LeCunn, Benjo). I successi del Deep Learning e la disfatta del Machine Learning tradizionale di oggi in settori come Computer Vision, Natural Language Processing e Giochi (GO, Chess, ecc.).

2) Matteo Testi- Founder Deep Learning Italia
“Introduzione alla piattaforma Deep Learning Italia”
Abstract: Illustrazione della community Deep Learning Italia e degli strumenti oggi sviluppati e a disposizione della community. Introduzione alle features del sito www.deeplearningitalia.com: i tutorials, il question & answer, le references, gli sviluppi futuri.

3) Ayadi Ala Eddine – Data Scientist at InstaDeep UK – AI researcher intern at Università degli Studi di Padova on deep reinforcement learning and a kaggle expert with more than 3 years of experience in data science, machine learning and statistics by working on real-life problems, a passion holder for deploying predictive models and deep learning techniques.
“Generative Adversarial Networks – Tensorflow to build GAN’s”
Abstract: GANs has been one of the most interesting developments in deep learning and machine learning recently. Through an innovative combination of computational graphs and game theory, we are going to show you how two models fighting against each other would be
able to co-train and generate new samples. Finally, we will end up with a demo where I will show you some cool stuff people have done using GAN and give you links to some of the important resources for getting deeper into these techniques.

 

https://www.eventbrite.it/e/biglietti-meetup-aperitech-di-deep-learning-italia-46881039451

Convolutional autoencoders features visualization

Cristiano De Nobili – Fisico

 

“Convolutional autoencoders features visualization”

Le reti CNN formano delle rappresentazioni a ogni livello, le feature maps, e i livelli più lontani dal livello di input contengono features via via sempre più complesse, che catturano caratteristiche che descrivono grandi porzioni dell’immagine di input. In questo talk faremo vedere una tipica tecnica di visualizzazione di queste features, con i convolutional autoencoders, descrivendo il livello di deconvoluzione

Introduzione al deep learning

Daniele D’Armiento – Physicist presso Samsung

“Introduzione al deep learning ed alla piattaforma Deep Learning Italia”
Abstract: Illustrazione della community Deep Learning Italia e degli strumenti oggi sviluppati e a disposizione della community. Introduzione alle features del sito www.deeplearningitalia.com: i tutorials, il question & answer, le references, gli sviluppi futuri

Dalle reti convoluzionali alle strutture capsulari

 

Daniele D’Armiento – Physicist presso Samsung

Matteo Alberti – Università Milano-Bicocca

 

“Analisi di una rete neurale capsulare nella Computer Vision”
L’attuale stato dell’arte per la classificazione d’immagini, introdotte nell’ottobre 2017, sta aprendo nuove strade inesplorate nel mondo del Deep Learning non più basate sull’ormai comune prassi di aumentare la profondità della rete o aumentare i dati a nostra disposizione per raggiungere performance migliori ma contrariamente su una struttura capsulare ed un processo definito “routing-by-agreement” in grado di superare la perdita delle informazioni spaziali delle reti convoluzionali ed al tempo stesso di ottenere simil-analoghe performance con una quantità di dati inferiore.

 

 

Deep Learning & Alpha Go Zero – Maurizio Parton

 

Maurizio Parton – Professore associato – Dipartimento di Economia – Università di Chieti – Pescara “G. d’Annunzio”
“Deep Learning e AlphaGo”
In questo intervento parlerò del successo del Deep Learning nell’affrontare l’ultimo baluardo dei giochi combinatori, il Go. Dopo aver descritto perché il Go è stato fino al 2016 impossibile da affrontare per i computer, parlerò di AlphaGo – il software che ha conquistato il Go -, della rete neurale alla base del successo di AlphaGo, e delle sue evoluzioni in AlphaGo Zero e AlphaZero, i software che hanno superato AlphaGo grazie al *non*-aiuto umano 🙂

 

 

Introduzione divulgativa alle Reti Neurali e al Deep Learning

 

Francesco Pugliese : Ricercatore ISTAT

Abstract: Descrizione introduttiva del modello del neurone artificiale e confronto con il neurone biologico, la storia delle reti neurali e come si è arrivati oggi al Deep Learning, detrattori vs sostenitori delle reti neurali e vittoria dei sostenitori (Hinton, LeCunn, Benjo). I successi del Deep Learning e la disfatta del Machine Learning tradizionale di oggi in settori come Computer Vision, Natural Language Processing e Giochi (GO, Chess, ecc.). Alcuni esempi tecnici concreti.

 

Deep Learning & Alpha Go – Maurizio Parton

Maurizio Parton – Professore associato – Dipartimento di Economia – Università di Chieti – Pescara “G. d’Annunzio”
“Deep Learning e AlphaGo”
In questo intervento parlerò del successo del Deep Learning nell’affrontare l’ultimo baluardo dei giochi combinatori, il Go. Dopo aver descritto perché il Go è stato fino al 2016 impossibile da affrontare per i computer, parlerò di AlphaGo – il software che ha conquistato il Go -, della rete neurale alla base del successo di AlphaGo, e delle sue evoluzioni in AlphaGo Zero e AlphaZero, i software che hanno superato AlphaGo grazie al *non*-aiuto umano 🙂

Capsule Networks – Daniele D’Armiento

Daniele D’Armiento – Physicist presso Samsung
“Analisi di una rete neurale capsulare nella Computer Vision”
L’attuale stato dell’arte per la classificazione d’immagini, introdotte nell’ottobre 2017, sta aprendo nuove strade inesplorate nel mondo del Deep Learning non più basate sull’ormai comune prassi di aumentare la profondità della rete o aumentare i dati a nostra disposizione per raggiungere performance migliori ma contrariamente su una struttura capsulare ed un processo definito “routing-by-agreement” in grado di superare la perdita delle informazioni spaziali delle reti convoluzionali ed al tempo stesso di ottenere simil-analoghe performance con una quantità di dati inferiore.