Tensorflow. Reconocimiento facial con inteligencia artificial (3/3)

23. Reconocimiento facial con inteligencia artificial (3)

• Hola a todos.Una vez finalizado el curso de google, vamos a entrenar un modelo para hacer un ejemplo de reconocimiento facial.Este ejemplo lo dividiremos en tres vídeos, que estructuraremos de la siguiente manera.

• En el tercer y último  vídeo que podéis ver a continuación practicamos el reconocimiento facial a través de la imagen de la webcam. También veremos el código necesario para este propósito.

• Os dejo el código visto en el vídeo y un enlace de descarga con el proyecto completo:

# Abajo mostramos el rectángulo delimitado (adivinado) para los ojos debajo de las gafas de sol

# Usaremos el rectángulo delimitador para averiguar cómo asignar los lentes en los puntos clave 

# glasses_triangle_vertices = np.array ([(280,220), (2800,220), (280,600)]). astype (np.float32)

thug_glasses_triangle_vertices = np.array([(65,10), (490,10), (65,70)]).astype(np.float32)

def thug_image(image):

    faces = dameCaras(image)

    image_info = obtenerPuntosClave(image, faces)

    

    sunglasses = cv2.imread("imagenes/gafas.png", cv2.IMREAD_UNCHANGED)    

    alpha_channel = sunglasses[:,:,3]

    

    for (face, keypoints) in image_info:

    

        # We keep only the keypoints related to eyes (from 0 to 9)

        eye_keypoints = keypoints[:10]

        # Compute the bounding rectangle for the eyes

        eye_boundingRect = cv2.boundingRect(np.array(eye_keypoints).astype(np.float32))

        # Build the triangle vertices needed by cv2.getAffineTransform()

        eyes_triangle_vertices = np.array([(eye_boundingRect[0],eye_boundingRect[1]), 

                                           (eye_boundingRect[0]+eye_boundingRect[2],eye_boundingRect[1]), 

                                           (eye_boundingRect[0],eye_boundingRect[1]+eye_boundingRect[3])]).astype(np.float32)

        # Compute the affine transform matrix from the two sets of three points (glasses and eyes)

        map_matrix = cv2.getAffineTransform(thug_glasses_triangle_vertices, eyes_triangle_vertices)

        # Apply the affine transformation to the glasses

        transformed_sunglasses = cv2.warpAffine(sunglasses, map_matrix, (image.shape[1], image.shape[0]))

        # Build a binary mask of the pixels where the sunglasses are

        transformed_sunglasses_mask = transformed_sunglasses[:,:,3] > 0

        # Overwrite pixels in the original image with sunglasses pixels using their mask

        image[:,:,:][transformed_sunglasses_mask] = transformed_sunglasses[:,:,0:3][transformed_sunglasses_mask]

    

    return image   

import cv2

import time 

from keras.models import load_model

def laptop_camera_go():

    # Crear instancia de captura de video.

    cv2.namedWindow("Deteccion facial")

    vc = cv2.VideoCapture(0)

    # capturamos el primer fotograma.

    if vc.isOpened(): 

        rval, frame = vc.read()

    else:

        rval = False

    

    # mantener el flujo de video abierto

    while rval:

        # trazar la imagen de la cámara con detecciones marcadas

        frame = thug_image(frame)

        cv2.imshow("Deteccion facial activada", frame)

        

        # Funcionalidad de salida: presione cualquier tecla para salir del video de 

        #la computadora portátil

        key = cv2.waitKey(20)

        if key > 0: # exit by pressing any key

            cv2.destroyAllWindows()

            

            for i in range (1,5):

                cv2.waitKey(1)

            return

        

        # obtener siguinete frame

        time.sleep(0.05)             # controlamos framerate

        rval, frame = vc.read()

laptop_camera_go()

• Os dejo un enlace al proyecto completo. https://drive.google.com/open?id=1MEZaj7CdcKzFbFqKJQWvyUrhccXkckYZ

Patrones de diseño software 7. Patrón estructural Adapter

7. Patrón estructural  Adapter

• Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.

• En esta ocasión veremos el patrón de diseño  Adapter. Este patrón permite la cooperación entre clases para extender sus funcionalidades a clases de diferentes tipos, que no pueden usarlas por mecanismos comunes como la herencia. El patrón Adapter  permite establecer un puente entre la clase incompatible con el resto de las clases que quieren usar su funcionalidad,  adaptando dichas funcionalidades con este sistema.

• En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño.

• Os dejo el código de las diferentes clases vistas en el vídeo:

• Código de las clases Bombilla, BombillaClasica y BombillaModerna

Bombilla:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Adapter

{

    abstract class  Bombilla

    {

        public abstract string encender();

        public abstract string aumentarIntensidad();

        public abstract  string apagar();

    }

}

BombillaClasica :

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Adapter

{

    class BombillaClasica:Bombilla

    {

        public override string encender()

        {

            return ("Encendido clásico");

        }

        public override string aumentarIntensidad()

        {

            return ("Aumentando intensidad clasico");

        }

        public override string apagar()

        {

            return ("Apagado clásico");

        }

    }

}

BombillaModerna:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Adapter

{

    class BombillaModerna:Bombilla

    {

        public override  string encender()

        {

            return ("Encendido moderno");

        }

        public override string aumentarIntensidad()

        {

            return ("Aumentando intensidad moderno");

        }

        public override string apagar()

        {

            return ("Apagado moderno");

        }

    }

}

• Código de las clases Vela y BombillaAdapter:

Vela:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Adapter

{

    class Vela

    {

        public string PrenderFuego()

        {

            return ("Encendemos llama");

        }

        public string SoplarParaApagar()

        {

            return ("Soplamos para apagar");

        }

        public string EcharCCombustible()

        {

            return ("Echamos gasolina");

        }

    }

}

BombillaAdapter: 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Adapter

{

    class BombillaAdapter: Bombilla

    {

        private Vela v = new Vela();

        public override string encender()

        {

            return v.PrenderFuego(); ;

        }

        public override string aumentarIntensidad()

        {

            return v.EcharCCombustible();

        }

        public override string apagar()

        {

            return v.SoplarParaApagar();

        }

    }

}

• Clase program:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Adapter

{

    class Program

    {

        static void Main(string[] args)

        {

            BombillaClasica bombilla = new BombillaClasica();

            Console.WriteLine(bombilla.encender());

            Console.WriteLine(bombilla.aumentarIntensidad());

            Console.WriteLine(bombilla.apagar());

            Console.ReadLine();

            BombillaModerna moderna = new BombillaModerna();

            Console.WriteLine(moderna.encender());

            Console.WriteLine(moderna.aumentarIntensidad());

            Console.WriteLine(moderna.apagar());

            Console.ReadLine();

            BombillaAdapter usarVela = new BombillaAdapter();

            Console.WriteLine(usarVela.encender());

            Console.WriteLine(usarVela.aumentarIntensidad());

            Console.WriteLine(usarVela.apagar());

            Console.ReadLine();

        }

    }

}

Tensorflow. Reconocimiento facial con inteligencia artificial (2/3)

22. Reconocimiento facial con inteligencia artificial (2)

• Hola a todos.Una vez finalizado el curso de google, vamos a entrenar un modelo para hacer un ejemplo de reconocimiento facial.Este ejemplo lo dividiremos en tres vídeos, que estructuraremos de la siguiente manera.

• En el segundo vídeo que podéis ver a continuación nos centramos en definir y entrenar una red convolucional con Keras. También veremos el código necesario para este propósito.

• A continuación os dejo el código visto en el vídeo.

#Imporatamos el fichero utils que tiene la lógica necesaria para obtener 15 puntos 

#representativos de las caras.

from utils import *

# load_data es un método definido en el fichero utils para cargar los csv que 

#tenemos en la carpeta data:training.csv y

# test.csv'

X_train, y_train = load_data()

print("X_train.shape == {}".format(X_train.shape))

print("y_train.shape == {}; y_train.min == {:.3f}; y_train.max == {:.3f}".format(

    y_train.shape, y_train.min(), y_train.max()))

# cargamos datos entrenamiento que son los dos csv que tene

X_test, _ = load_data(test=True)

print("X_test.shape == {}".format(X_test.shape))

#muestro los puntos 15 puntos representativos de las caras de del conjunto de entrenamiento 

import matplotlib.pyplot as plt

%matplotlib inline

fig = plt.figure(figsize=(20,20))

fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)

for i in range(9):

    ax = fig.add_subplot(3, 3, i + 1, xticks=[], yticks=[])

    plot_data(X_train[i], y_train[i], ax)

# Importamos librerias necesarias 

from keras.models import Sequential

from keras.layers import Convolution2D, MaxPooling2D, Dropout

from keras.layers import Flatten, Dense

# El modelo debe aceptar imágenes en escala de 96x96 píxeles.

# Debe tener una capa de salida totalmente conectada con 30 valores 

#(2 para cada punto clave facial)

# Como funcion de activacion utilizamos relu que activa una neoruna solo si es mayor que cero.

shape = (96,96)

modelo = Sequential()

modelo.add(Convolution2D(16,(2,2),padding='same',input_shape=(96,96, 1), activation='relu'))

modelo.add(MaxPooling2D(pool_size=3, data_format="channels_first"))

modelo.add(Convolution2D(32,(3,3),padding='same', activation='relu'))

modelo.add(MaxPooling2D(pool_size=3))

modelo.add(Dropout(0.2))

modelo.add(Convolution2D(64,(3,3),padding='same',activation='relu'))

modelo.add(MaxPooling2D(pool_size=3))

modelo.add(Dropout(0.2))

modelo.add(Convolution2D(128,(3,3),padding='same', activation='relu'))

modelo.add(MaxPooling2D(pool_size=3))

modelo.add(Dropout(0.2))

modelo.add(Flatten())

modelo.add(Dense(256,activation='relu'))

modelo.add(Dropout(0.2))

modelo.add(Dense(30))

modelo.summary()

from keras.optimizers import SGD, RMSprop, Adagrad, Adadelta, Adam, Adamax, Nadam

from keras.callbacks import ModelCheckpoint, History  

iteraciones = 50

histo = History()

## Compilamo el modelo

def compilarModelo(modelo, iteraciones):

    

    ruta = 'model.hdf5'

    modelo.compile(optimizer='adam', loss='mse', metrics=['accuracy'])

    checkpointer = ModelCheckpoint(filepath=ruta, 

                                   verbose=1, save_best_only=True)

    ## Entrenamos el modelo

    hist = modelo.fit(X_train, y_train, validation_split=0.2,

              epochs=iteraciones, batch_size=20, callbacks=[checkpointer, histo], verbose=1)

    

    modelo.save(ruta)

    

    return hist

# Booleano con el controlamos si entrenar el modelo o no

entrenarModelo = False

if entrenarModelo is True:

    hist = compilarModelo(modelo, iteraciones) 

else:

    modelo.load_weights('model.hdf5')

def obtenerPuntosClave(imagen, caras=None):

    

  

    #lista parea (cara, puntosClave)

    resultado = []

    

    if caras is None:

        caras = get_faces(imagen)

    

    # mismo tamaño que los conjuntos de entrenamiento y validacion

    carasForma = (96, 96)

    

    copiaImagen = np.copy(imagen)

    #Por cada cara detectamos puntos clave y características

    for (x,y,w,h) in caras:

        #Recortamos la región de la imagen donde esta la cara

        cara = copiaImagen[y:y+h,x:x+w]

        # Cara convertida a escala de grises y tamaño 96x96x1

        caraGris = cv2.cvtColor(cara, cv2.COLOR_BGR2GRAY)

        caraGrisRedimensionar = cv2.resize(caraGris, carasForma) / 255

        # Adaptando entrada a (1, 96, 96, 1)

        inputs = np.expand_dims(np.expand_dims(caraGrisRedimensionar, axis=-1), axis=0)

                                

        # obtener puntos clave                        

        puntosClavePrediccion = modelo.predict(inputs)

        # Todos los puntos clave en una sola matriz plana. 

        # Recuperaremos puntos clave como (x, y) con (idx, idx + 1) valores.

        puntosClavePrediccion = np.squeeze(puntosClavePrediccion)

        

        puntosClave = []        

        for idx in range(0, len(puntosClavePrediccion), 2):

            #Factor de escala (revertir escala)

            x_scale_factor = cara.shape[0]/carasForma[0] 

            y_scale_factor = cara.shape[1]/carasForma[1] 

            x_center_left_offset = puntosClavePrediccion[idx] * carasForma[0]/2 + carasForma[0]/2 

            y_center_left_offset = puntosClavePrediccion[idx + 1] * carasForma[1]/2 + carasForma[1]/2

            

            x_center = int(x + (x_scale_factor * x_center_left_offset))

            y_center = int(y + (y_scale_factor * y_center_left_offset))

            puntosClave.append([x_center, y_center])

        

        resultado.append([(x,y,w,h), puntosClave])

    

    return resultado

def mostrarImagenCaracteristicas(image_path):

    imagen = cargaImagen(image_path)

    caras = dameCaras(imagen)

    puntosClave = obtenerPuntosClave(imagen, caras)

    imagenConCaras = pintarCaras(imagen, caras ,plot=False)

    pintarPuntosClave(imagenConCaras, puntosClave)

mostrarImagenCaracteristicas('imagenes/clubdelalucha.jpg')

Patrones de diseño software 6. Prototype deep

6.Patrón de creación. Prototype deep

• Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.

• En esta ocasión veremos el patrón de diseño  Prototype deep. Este patrón de diseño prototipo tiene como finalidad crear nuevos objetos clonando una instancia creada previamente.Es similar al patrón prototype superficial. Sin embargo, utilizando este patrón podremos clonar objetos que contengan otros objetos complejos.

• En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño.

• Os dejo el código de las diferentes clases vistas en el vídeo:

• Código de las clases Persona y DetallePesona

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace PrototypeDeep

{

    class Persona : ICloneable

    {

        int altura;

        int peso;

        DetallePesona detalle = new DetallePesona();

        public int Altura { get => altura; set => altura = value; }

        public int Peso { get => peso; set => peso = value; }

        internal DetallePesona Detalle { get => detalle; set => detalle = value; }

        private object CopiaSuperfical()

        {

            return this.MemberwiseClone();

        }

        private object copiaProfunda()

        {

            Persona clon = this.MemberwiseClone() as Persona;

            clon.detalle = new DetallePesona();

            clon.detalle.ColorOjos = this.detalle.ColorOjos;

            clon.detalle.EstaCAlvo = this.detalle.EstaCAlvo;

            return clon;

        }

        public object Clone()

        {

            return copiaProfunda();

        }

    }

    class DetallePesona

    {

        string colorOjos;

        Boolean estaCAlvo;

        public bool EstaCAlvo { get => estaCAlvo; set => estaCAlvo = value; }

        public string ColorOjos { get => colorOjos; set => colorOjos = value; }

    }

}

• Código de la clase Program:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace PrototypeDeep

{

    class Program

    {

        static void Main(string[] args)

        {

            Persona p = new Persona();

            p.Altura = 170;

            p.Peso = 80;

            p.Detalle = new DetallePesona();

            p.Detalle.EstaCAlvo = false;

            p.Detalle.ColorOjos = "rojos";

            Persona clon = p.Clone() as Persona;

            clon.Detalle.EstaCAlvo = true;

            clon.Detalle.ColorOjos = "Verdes";

            Console.WriteLine(p.Detalle.ColorOjos);

            Console.WriteLine(p.Detalle.EstaCAlvo);

            Console.WriteLine(clon.Detalle.ColorOjos);

            Console.WriteLine(clon.Detalle.EstaCAlvo);

            Console.ReadLine();

        }

    }

}

Tensorflow. Reconocimiento facial con inteligencia artificial (1/3)

21. Reconocimiento facial con inteligencia artificial (1)

• Hola a todos.Una vez finalizado el curso de google, vamos a entrenar un modelo para hacer un ejemplo de reconocimiento facial.Este ejemplo lo dividiremos en tres vídeos, que estructuraremos de la siguiente manera.

• En el primer vídeo que podéis ver a continuación nos centramos en explicar la estructura del proyecto.Y además implementamos el código necesario para detectar las caras que aparecen en una foto.

• A continuación os dejo el código visto en el vídeo.

#importamos las librerias necesarias

import numpy as np

import matplotlib.pyplot as plt

import math

import cv2                 # Libreria OpenCV.En el caso de tenerla instalada.Ponera via Conda 

from PIL import Image

import time

from keras.models import load_model

# funciones auxiliares

def cargaImagen(ruta):

    """ Método que carga una imagen de una ruta"""

    imagen = cv2.imread(ruta)

    imagen = cv2.cvtColor(imagen, cv2.COLOR_BGR2RGB)

    return imagen

def dibujarImagen(imagen, title=''):

    """Funcion que muestra imagen """

    fig = plt.figure(figsize = (8,8))

    ax1 = fig.add_subplot(111)

    ax1.set_xticks([])

    ax1.set_yticks([])

    ax1.set_title(title)

    ax1.imshow(imagen)

def dameCaras(imagen):

    """A partir de una imagen detecta las cara y devuelve un rectangulo en la posición que se ubica la cara

    """

    

    copiaImagen = np.copy(imagen)

    

    # Filtro para escala de grises

    gray = cv2.cvtColor(copiaImagen, cv2.COLOR_RGB2GRAY)

    # Extraemos un detector de caras frontales preentrenado desde un fichero xml 

    clasificadorCaras = cv2.CascadeClassifier('Detectores/haarcascade_frontalface_default.xml')

    

    # Detectar caras de la imagen

    caras = clasificadorCaras.detectMultiScale(gray, 1.2,4)

    

    return caras 

def pintarCaras(imagen, caras=None, plot=True):

    """ Pinta una imagen con las cara detectadas.

    """

    if caras is None:

        faces = dameCaras(imagen)

        

    imagenConCaras = np.copy(imagen)

    

    # Obtener el cuadro delimitador para cada cara detectada y pintar un cuadro 

    for (x,y,w,h) in caras:

        cv2.rectangle(imagenConCaras, (x,y), (x+w,y+h), (255,0,0), 3)

        

    if plot is True:

        dibujarImagen(imagenConCaras)

    else:

        return imagenConCaras

    

    

def  pintarPuntosClave(imagen, informacionImagen):

    """Traza los puntos clave dados en formato (x, y)

    """

    fig = plt.figure(figsize = (8,8))

    ax1 = fig.add_subplot(111)

    

    for (cara, keypoints) in informacionImagen:

        for (x,y) in keypoints:ax1.scatter(x, y, marker='o', c='c', s=10)

   

    ax1.set_xticks([])

    ax1.set_yticks([])

    ax1.imshow(imagen)

imagen = cargaImagen('imagenes/clubdelalucha.jpg')

caras = dameCaras(imagen)

print("Caras detectadas: {}".format(len(caras)))

pintarCaras(imagen, caras)

Patrones de diseño software 5. Prototype superficial

5.Patrón de creación Prototype superficial

• Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.

• En esta ocasión veremos el patrón de diseño  Prototype superficial. El patrón de diseño prototipo tiene como finalidad crear nuevos objetos clonando una instancia creada previamente. 

• Este patrón especifica la clase de objetos a crear mediante la clonación de un prototipo que es una instancia ya creada. La clase de los objetos que servirán de prototipo deberá incluir en su interfaz la manera de solicitar una copia, que será desarrollada luego por las clases concretas de prototipos.

• En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño.

• Os dejo el código visto en el vídeo:

* Clase Mueble:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Prototype_superficial

{

    class Mueble:ICloneable

    {

        private int numAsientos;

        private string nombre;

        public int NumAsientos { get => numAsientos; set => numAsientos = value; }

        public string Nombre { get => nombre; set => nombre = value; }

        public object Clone()

        {

            return this.MemberwiseClone();

        }

 }

}

* Clase Program:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Prototype_superficial

{

    class Program

    {

        static void Main(string[] args)

        {

            Mueble mueble = new Mueble();

            mueble.NumAsientos = 1;

            mueble.Nombre = "Silla";

            Console.WriteLine("num:" + mueble.NumAsientos.ToString());

            Console.WriteLine("nombre:" + mueble.Nombre);

            Mueble clonMueble = mueble.Clone() as Mueble;

            clonMueble.NumAsientos = 3;

            clonMueble.Nombre = "Sofa";

            Console.WriteLine("num:" + clonMueble.NumAsientos.ToString());

            Console.WriteLine("nombre:" + clonMueble.Nombre);

            Console.ReadLine();

        }

    }

}

    

Patrones de diseño software 4. Singleton

4.Patrón de creación Singleton

• Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.

• En esta ocasión veremos el patrón de diseño Singelton. Es un patrón de diseño que permite restringir la creación de objetos pertenecientes a una clase o el valor de un tipo a un único objeto.Su intención consiste en garantizar que una clase solo tenga una instancia y proporcionar un punto de acceso global a ella.

• El patrón singleton se implementa creando en nuestra clase un método que crea una instancia del objeto solo si todavía no existe alguna. Para asegurar que la clase no puede ser instanciada nuevamente se regula el alcance del constructor.

• En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño.

• Os dejo el código visto en el vídeo:

*Clase SingletonEjemplo:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Singleton

{

    public class SingletonEjemplo

    {

        private static SingletonEjemplo singleton = null;

        public string texto = String.Empty;

        public int numerito = -1;

        SingletonEjemplo(string valor)

        {

            texto = valor;

            numerito = 2;

        }

        public static SingletonEjemplo Singleton

        {

            get

            {

                if (singleton == null)

                    singleton = new SingletonEjemplo("Creado");

                return singleton;

            }

            set => singleton = value;

        }

    }

}

*Clase Program:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Singleton

{

    class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine(SingletonEjemplo.Singleton.texto);

            Console.WriteLine(SingletonEjemplo.Singleton.numerito.ToString());

            Console.ReadLine();

            SingletonEjemplo.Singleton.texto = "DSAfaadfasfasasfas";

            SingletonEjemplo.Singleton.numerito = 3;

            Console.WriteLine(SingletonEjemplo.Singleton.texto);

            Console.WriteLine(SingletonEjemplo.Singleton.numerito.ToString());

            Console.ReadLine();

        }

    }

}

Patrones de diseño software 3.Builder

3.Patrón de creación Builder

• Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.

• En esta ocasión veremos el patrón de diseño Builder, que separa la creación de un objeto complejo de su representación, de modo que el mismo proceso de construcción pueda crear representaciones diferentes. Básicamente significa que en lugar de implementar la creación de un objeto en el constructor de la clase, habrá otras clases encargadas de crear el objeto  y asignarles las propiedades iniciales. Cada una de estas "otras" clases será un builder. Y cada uno de estos builders será capaz de crear un objeto nuevo con ciertas características.

• En nuestro caso la jerarquía de clase que hemos creado tiene el aspecto que veis en la imagen:
  
  
  
• En el siguiente vídeo vemos con un ejemplo como construir esta estructura de clases basándonos en el patrón de diseño Builder. 

• Os dejo el código de las diferentes clases vistas en el vídeo:

*Clase ConexionBuilder:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Builder

{

    // Builder

    public abstract class ConexionBuilder

    {

        protected CadenaConexion conexion;

        public CadenaConexion dameCadenaConexion() { return conexion; }

         public virtual void asignarServidor()

        {

        }

        public virtual void asignarBasedatos()

        {

        }

        public virtual void asignarUsuario()

        {

        }

        public virtual void asignarPasswor()

        {

        }

    }

}

*Clase MySQLBuilder:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Builder

{

    public class MySQLBuilder : ConexionBuilder

    {

        public MySQLBuilder()

        {

            conexion = new CadenaConexion();

        }

        public override void asignarServidor()

        {

            conexion.Servidor = "Servidor MySQl";

        }

        public override void asignarBasedatos()

        {

            conexion.NombreBaseDAtos = "Nombre instancia MySQl";

        }

        public override void asignarUsuario()

        {

            conexion.Usuario = "usuario MySQl";

        }

        public override void asignarPasswor()

        {

            conexion.Password = "pass usuario MySQl";

        }

    }

}

*Clase OracleBuilder :

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Builder

{

    public class OracleBuilder : ConexionBuilder

    {

        public OracleBuilder()

        {

            conexion = new CadenaConexion();

        }

        public override void asignarServidor()

        {

            conexion.Servidor = "Servidor ORACLE";

        }

        public override void asignarBasedatos()

        {

            conexion.NombreBaseDAtos = "Nombre instancia ORACLE";

        }

        public override void asignarUsuario()

        {

            conexion.Usuario = "usuario ORACLE";

        }

        public override void asignarPasswor()

        {

            conexion.Password = "pass usuario ORACLE";

        }

    }

}

*Clase OracleBuilder :

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Builder

{

    public class SqlServerBuilder : ConexionBuilder

    {

        public SqlServerBuilder()

        {

            conexion = new CadenaConexion();

        }

        public override void asignarServidor()

        {

            conexion.Servidor = "Servidor SQL SERVER";

        }

        public override void asignarBasedatos()

        {

            conexion.NombreBaseDAtos = "Nombre instancia SQL SERVER";

        }

        public override void asignarUsuario()

        {

            conexion.Usuario = "usuario SQL SERVER";

        }

        public override void asignarPasswor()

        {

            conexion.Password = "pass usuario SQL SERVER";

        }

    }

}

*Clase CadenaConexion:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Builder

{

    public class CadenaConexion

    {

        public string Servidor { get; set; }

        public string NombreBaseDAtos { get; set; }

        public string Usuario { get; set; }

        public string Password { get; set; }

        public CadenaConexion()

        {

        }

        public CadenaConexion(string servidor, string baseDatos, string usuario, string pass) : this()

        {

            Servidor = servidor;

            NombreBaseDAtos = baseDatos;

            Usuario = usuario;

            Password = pass;

        }

    }

}

*Clase Conexion:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Builder

{

    public class Conexion

    {

        private ConexionBuilder conexionBuilder;

        public void nuevaConexion(ConexionBuilder conBuilder)

        {

            conexionBuilder = conBuilder;

        }

        public void crearCadenaConexion()

        {

            conexionBuilder.asignarServidor();

            conexionBuilder.asignarBasedatos();

            conexionBuilder.asignarPasswor();

            conexionBuilder.asignarUsuario();

        }

        public CadenaConexion ConexionLista

        {

            get { return conexionBuilder.dameCadenaConexion(); }

        }

    }

}

*Clase Program:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Builder

{

    class Program

    {

        static void Main(string[] args)

        {

            var conexion = new Conexion();

            // queremos crear cadena conexion a SQL SERVER

            conexion.nuevaConexion(new SqlServerBuilder());

            conexion.crearCadenaConexion();

            var conexionSQLServer = conexion.ConexionLista;

            // queremos crear cadena conexion a My SQL

            conexion.nuevaConexion(new MySQLBuilder());

            conexion.crearCadenaConexion();

            var conexionMySQl = conexion.ConexionLista;

            // queremos crear cadena conexion a oracle

            conexion.nuevaConexion(new OracleBuilder());

            conexion.crearCadenaConexion();

            var conexionOracle = conexion.ConexionLista;

        }

    }

  }

Curso Tensorflow con Anaconda -20 Creando nuestros propio clasificador de imágenes (2)

20 Nuestros propio clasificador de imágenes (2)

• Hola a todos.Una vez finalizado el curso de google nos disponemos a crear nuestro propio clasificador de imágenes.En esta segunda entrada veremos en detalle el código implementado para poder entrenar nuestro modelo.

• Os dejo un vídeo donde explico que hace el código implementado con el objetivo de clasificar nuestros conjuntos de imágenes de perros y de gatos que descargamos en el capítulo anterior:

• Os dejo el código visto en el vídeo:

 

#importamos librerias necesarias

import sys

from PIL import Image

sys.modules['Image'] = Image 

import os

from tensorflow.python.keras import optimizers #libreria optimizadores para entrenar modelo

from tensorflow.python.keras.preprocessing.image import ImageDataGenerator # libreria prepocesa imagenes

from tensorflow.python.keras.layers import Dropout, Flatten, Dense, Activation # Libreria para las capas

from tensorflow.python.keras.layers import  Convolution2D, MaxPooling2D #capas donde hacemos convuliones

from tensorflow.python.keras.models import Sequential # libreria para redes neuronales secuenciales

from tensorflow.python.keras import backend as K 

from tensorflow.python.keras import applications

K.clear_session() # limpiamos por si hubiera algo corriendo

datosEntrenamiento = './imagenes/entrenamiento' #ruta imagenes enetrenamiento

datosValidacion = './imagenes/validacion' # ruta imagenes validacion

longitud, altura = 224, 224 

#longitud y altura de las imagenes.Le pongo 224 en el ancho y alto porque es lo que se espera el

 #el modelo preentrenado

    

#reescalamos las imágenes para que los valores en vez de ir de 1 a 255(posibles valores pixel) vayan de 0 a 1.

#shear_range--> inclina imágenes

#horizontal_flip --> invierte imágenes

entDatagen = ImageDataGenerator(rescale=1. / 255,shear_range=0.2,zoom_range=0.2,horizontal_flip=True)

#en el grupo de validación simplemente reescalamos

validacionDatagen = ImageDataGenerator(rescale=1. / 255)

#carga las imágenes de entrenammiento y las procesa según la altura pasada y las clasifica en modo el modo categorical

Entrenamiento = entDatagen.flow_from_directory(datosEntrenamiento,

                                                  target_size=(altura, longitud),batch_size=32,class_mode='categorical')

#carga las imágenes de validación y las procesa según la altura pasada y las clasifica en modo el modo categorical

Validacion = validacionDatagen.flow_from_directory(datosValidacion,

                                                             target_size=(altura, longitud),

                                                              batch_size=32, class_mode='categorical')

#cargamo el modelo preentrenado

vgg=applications.vgg16.VGG16()

#vgg=applications.vgg16.VGG16()# Ejemplo del modelo

cnn=Sequential()

#cargamos las capas del modelo preentrenado en nuestro modelo secuencial y quitamos la última capa

for capa in vgg.layers:

    cnn.add(capa)

cnn.layers.pop()

#queremos que solo se entrenna la capa que añadimos nosotros asi que le decimos  layer.trainable=False

for layer in cnn.layers:

    layer.trainable=False

#añadimos nuestra capa

cnn.add(Dense(2,activation='softmax'))

#compilamos nuestro modelo utilizando el optimizado de Adam

cnn.compile(loss='categorical_crossentropy',

            optimizer=optimizers.Adam(lr=0.0004),

            metrics=['accuracy'])

#utilizamos la función v para entrenar el algoritmo

cnn.fit_generator(Entrenamiento,steps_per_epoch=100,epochs=20,validation_data=Validacion,validation_steps=300)

#una vez entreando guardamos nuestro modelo

cnn.save('./modelo/modelo.h5')

cnn.save_weights('./modelo/pesos.h5')

    

import numpy as np

from tensorflow.keras.preprocessing.image import load_img, img_to_array

from tensorflow.python.keras.models import Sequential # libreria para redes neuronales secuenciales

from tensorflow.keras.models import load_model

from tensorflow.python.keras import applications

from tensorflow.python.keras.layers import  Dense

longitud, altura = 224, 224

weights_model='./modelo/pesos.h5'  

vgg=applications.vgg16.VGG16()

cnn=Sequential()

for capa in vgg.layers:

    cnn.add(capa)

cnn.layers.pop()

for layer in cnn.layers:

    layer.trainable=False

cnn.add(Dense(2,activation='softmax'))  

cnn.load_weights(weights_model)

def predict(file):

  x = load_img(file, target_size=(longitud, altura))

  x = img_to_array(x)

  x = np.expand_dims(x, axis=0)

  array = cnn.predict(x)

  result = array[0]

  answer = np.argmax(result)

  if answer == 0:

    print("Gato")

  elif answer == 1:

    print("Perro")

  return answer

Instalación y descarga nuevo Visual Studio 2019

Visual Studio community 2019

• Hola a todos.Hoy os traigo información sobre como descargar e instalar el nuevo visual studio 2019. Podemos descargar este nuevo entorno de desarrollo desde la página oficial de microsoft. 
• Existe un enlace de descarga gratuito que os dejo a continuación: 
• https://visualstudio.microsoft.com/es/downloads

• Algunas de las novedades más destacadas que nos trae este Visual Studio 2019 es que mejora la navegación a través del código y  mejora la sección de plantillas para que sea más fácil iniciar un nuevo proyecto. También se ha mejorado la experiencia de depuración, y todas las novedades funcionan tanto con proyectos existentes como con los nuevos.Desde aplicaciones cross-plataforma escritas en C++, hasta aplicaciones móviles .NET para iOS y Android escritas en Xamarin, o aplicaciones basadas en la nube que usen los servicios de Azure.

• En el siguiente vídeo podéis ver como descargarlo e instalarlo.También creamos nuestro primer proyecto:

• Os dejo un enlace con la lista de novedades completa: https://docs.microsoft.com/es-es/visualstudio/ide/whats-new-visual-studio-2019?view=vs-2019

Curso Tensorflow con Anaconda -19 Creando nuestro propio clasificador de imagenes (1)

19 Nuestro propio clasificador de imágenes (1)

• Hola a todos.Una vez finalizado el curso de google nos disponemos a crear nuestro propio clasificador de imágenes.En esta primera entrada de las dos que  dedicaremos a este tema veremos como preparar nuestra máquina para poder realizar este ejercicio.

• Para poder entrenar el modelo correctamente necesitaremos bastantes imágenes de los elementos  que queremos clasificar. Para este objetivo me he ayudado de un plugin de chrome que nos permite bajar todas la imágenes de una página de manera automática. El plugin es este. Además para facilitar el entrenamiento de nuestro modelo hemos utilizado un modelo preentrenado de google.

• Os dejo un enlace a un blog con más información sobre Deep Learning básico con Keras, que se trata del modelo preentrenado de google sobre el que nos hemos basado: https://enmilocalfunciona.io/deep-learning-basico-con-keras-parte-3-vgg/

• En el siguiente vídeo os cuento todo esto con mucho más detalle: