Curso Tensor Flow

Curso Tensor Flow.

9) Bases de cómo funciona tensor Flow.

Como funciona tensor Flow.

Loa algoritmos de tensorflow se estructuran en dos faces

• Importación o generación del conjunto de datos ( Dataset ) obtener datos es bueno probar datos generados para saber qué es lo que espero del algoritmo o que tenía que dar porque si no no sabre si los datos son correctos o no.
• Transformación o normalización de datos para aplicar algoritmos tensor Flow espera datos normalizados cambiados de escala o con distribución normal.
• Dividir el conjunto de datos en entrenamiento, validación y test algunos no requieren test, es importante que el algoritmo no se centre en aprender datos de los elementos, sino que tenga una visión de los mismos por ello muchas veces utilizaremos un 80% de entrenamiento y otro 20% para test para saber si saco información global para saber si funciona bien con datos que se entrenaros y con datos que no se entrenaron
• Definir los hiper parametros del algoritmo(Radio de aprendizaje,# de Iteraciones u otros parámetros fijos) inicializar estos valores grandes y luego ir acomodando-----------Learning_rate = 0.01   Tamaño de la muestra para que el algoritmo repita batch_size = 50 y el numero de iteraciones Iterations = 1000 definir los hiper parámetros es importante.

Bach Global Normalizacion: Se encarga de la etapa de transformación. www.aoneapps.com

Import tensorflow as tf

#Inicializar variables y placeholder que variables y con que formato debe operar en el #algoritmo mas bites mas tiempo

Tensor Flow depende de conocer que varibales y con que formato durante el proceso de optmizacion para reducir el proceso de perdida.. ¿Qué tipo de dato? Float 16,32,64

Python…..

import tensorflow as tf
'''
1) Importacion o generacion de un conjunto de datos
2) Transformacion y normalizacion de datos
3) Dividir el conjunto de datos en conjunto de entrenamiento de validacion y de test
4) Definir los hiper parametros del algoritm
'''
learning_rate = 0.01
batch_size = 50
iterations = 10000

#inicializar variables y placeholders

#numero constante
x = tf.constant(30)
# 5) definir placeholder para un tipo de variable
x_input = tf.placeholder(tf.float32,[None,3])
y_input = tf.placeholder(tf.float32,[None,5])

# 6) Definir la estructura del modelo de algoritmo example Y = mx+n
y_pred = tf.add(tf.multiply(Matriz,x_input),n_vector)

# 7) declara la funcion de perdida (loss function)
#como se han alejado la predicciones del valor real que queriamos predecir..
#error cuadrado medio, Media de los errores.

#reduce la media square cuadrado
loss = tf.reduce_mean(tf.square(Y_actual-y_pred))

# 8) Inicializar y entrenar el modelo anterior.
#inicializar una sesion de forma obligatoria para que el algoritmo inicii con tensor flow
with tf.Session(graph = graph) as session:
   .......
   session.run(....)
   .......

#Otra forma

session = tf.Session(graph = graph)
...
session.run(...)
...

# 9) Evaluacion del modelo
# el modelo ha predecido sobre los datos obtenidos
# es importante que el algoritmo aprenda una receta general
# es decir que no aprenda cosas concretas que funcione con muchos valores

# 10) Ajustar los hiper parametros volver a evaluar
# y verificar

# 10) Publicar (subir a produccion) y predecir nuevos resultados

10) Formas de definir tensores.

Los tensores son la fuente principal de la estructura de datos que utiliza tensor Flow se suele declarar como variables o como placeholders… un tensor es una estructura n dimencional donde n puede ser 1,2,3,…..n

[pic 1]

Es un tensor unidimensional (vector)

                                        [pic 2]

Este se llama tensor bidimensional (Matrix)

                        [pic 3]

Tensor Flow solo añade datos tras inicializar las variables al algoritmo.

## Tensores fijos

Zero_t = tf.zeros([3,4])

 Función de relleanado de ceros

#Tensor relleno con 1997
filled_t = tf.fill([4,5,2],1997)
print(filled_t)

#un tensor a partir de un solo numero
cte_t = tf.constant([1,2,3,4,5])
print(cte_t)

#Tensor por tamaño

#Tensor de tamaño similar
#se crea un tensor con diferentes tamaños pero
#con diferentes valores
zero_sim = tf.zeros_like(cte_t)

Este ultimo deveria cte_t inicializado inicialmente

#Tensor por secuencia. Serie de intervalos definidos

-linspace() de numpy

-range()

Secuencia en forma de tensor

#num es diviciones donde inicia, donde pare, numero de diviciones que se quieren.
sec_t = tf.linspace(start=0.0,stop=1.0,num = 5)
print(sec_t)

[pic 4]

También se puede utilizar la función range

#no tiene en cuenta el valor final
range_seq = tf.range(start=0.0,limit= 15.0,delta = 4.0)
print(range_seq)

[pic 5]

#Tensores aleatorios
#que me de un tensor de 3 filas y 4 columnas de numeros aletorios
#con una distribucion uniforme 0 hasta 1 no oncluye el 1
rand_unif_t = tf.random_uniform([3,4],minval=0,maxval=1)
print(rand_unif_t)

[pic 6]

Distribución normal

Truncar entre dos valores para no tener un dominio de la función infinitio[pic 7]

Las imágenes son tensores de tamaño 3 fila columna y los tres canales Rgb.

#Varibles para crear funciones y algoritmos.

[pic 8]

[pic 9]

Convierte a tensor

11) Place holders vs variables.

Que es un place holder y que es una variable

Variable: parámetros del algoritmo, tf los utiliza para optmizar el resultado de nuestro algoritmos

Place holder: objeto que permite recibir información de datos de un tipo y tamaño concreto.

Cada uno de ellos se define de una manera diferente

Placeholder es una estructura que en cualquier momento puede obtener cualquier dato

Feed dict. Utiliza los diccionarios.

import tensorflow as tf

my_var = tf.Variable(tf.zeros([4,3]))
session = tf.Session()
inits = tf.global_variables_initializer()
session.run(inits)

session = tf.Session()
x = tf.placeholder(tf.float32,shape=[2,2])
y = tf.identity(x)
session.run(y,feed_dict(x:x_vals))

13)Matrices en tensorflow

[pic 10]

Convertir numpy a tensorflow

[pic 11]

Operar con matrices

 [pic 12]

Transpuesta

[pic 13]

Determinanate

[pic 14]

Inversa

[pic 15]

15 y 15) operaciones aritmeticas y otras operaciones

import tensorflow as tf
session = tf.Session()

x = 3.
y = 4.

print(session.run(tf.add(x,y)))
print(session.run(tf.subtract(x,y)))
print(session.run(tf.multiply(x,y)))
print(session.run(tf.div(x,y)))
#Divicion redondeada
print(session.run(tf.floor_div(x,y)))
#Modulo
print(session.run(tf.mod(x,y)))
#Producto cruz
print(session.run(tf.cross([1.0,0.,0.],[0.,1.,0.])))
#Valor absoluto
z = [-3.,-2.,-1.,0.,1.,2.]
print(session.run(tf.abs(z)))
#Redondeo a la alta
print(session.run(tf.ceil(6.4)))
#Redondeo a la baja
print(session.run(tf.floor(6.4)))
#Redondeo dependiendo 5.5
print(session.run(tf.round(6.5)))
print(session.run(tf.sin(4)))
#tf.cos()
#tf.exp()
#tf.log(x)

'''
#devuelve el maximo entre dos vectores
tf.maximun(x,y)

#devuelve el minimo entre dos vectores
tf.minimun(x,y)

#tf.negative(x) lo que es negativo pasa a ser positivo
y lo que es positivo pasa a ser negativo

#tf.pow(x,y) eleva a la potencia
elevar un vector a otro

#tf.sqrt(x) raiz cuadrada

#tf.square(x) cuadrado de los numeros del tensor

#tf.sign(x) -1 si el valor era negativo 1 si era positivo y cero si esta era cero


machine learnig
otras funciones

#tf.digamma(x)
calcular la derivada de gamma de euler

#tf.lbeta(x)
logaritmo de la beeta

#tf.erf(x)
gausiana

#tf.erfc(x)
complementario de la anterior

#tf.squared_difference(x,y)
sumaria los cuadrados de la diferencia

y = 5*x^2-7*x+15

def custom_parabola(value):
   return tf.substrac(5*tf.squeare(value),7*value)+15

'''

...