domingo, 30 de diciembre de 2018

Regaeton video - Karol G - Mi Cama (Official Video)

Karol G - Mi Cama (Official Video)

https://youtu.be/8-mloCL49vs?list=PLRZlMhcYkA2GDuq-8BTLzTRGpwNsGlWjj

miércoles, 19 de diciembre de 2018

RITMOS GUITARRA - porro, son paisa, parranda, merengue vallenato y campesino, paseo

https://www.youtube.com/watch?v=vW-8Tk84g44

martes, 4 de diciembre de 2018

Modelamiento de Ecuación Diferencial en Simulink por medio de Diagrama de Bloques

https://sites.google.com/site/programacionyal/home/unidad-8/8-1-ejemplo-del-uso-de-simulink

8.1 Ejemplo del uso de Simulink.

Modelos Matemáticos no Linealizados.

a) Simular la siguiente ecuación diferencial y encontrar su respuesta ante una entrada escalón.

Solución:

Seleccionar los bloques necesarios para representar el modelo y llevarlos a la hoja de trabajo. Para ello debe buscar los bloques en las librerías correspondientes, seleccionar cada uno haciendo "click" sobre él para marcarlo y arrastrarlo con el "mouse" hasta la ventana.

(bloques necesarios para la representación de la ecuación)

Armar el modelo. Las ecuaciones diferenciales pueden representarse en bloques de "Simulink" como función del tiempo sin linealizarlas ni llevarlas al dominio de Laplace. En primer lugar, se debe despejar la derivada temporal para expresarla en función de los demás términos de la ecuación:

Luego, se debe establecer qué valores en la ecuación son constantes y cuáles son función del tiempo, en este caso, la conversión X depende del tiempo, pero la temperatura T es constante.

El primer término del lado derecho de la ecuación (1) se puede representar como un escalón unitario o como una entrada constante.

En el segundo término [5exp(-60/T).X(t)], la temperatura se representa, igualmente, como una entrada escalón o como una entrada constante, luego se invierte con un bloque Matlab Function, donde se especifica la función 1/u, se multiplica por una ganancia de –60 con un bloque Gain, y se introduce nuevamente en una Matlab Función para obtener la exponencial, que va a ser multiplicada por 5 con otro bloque Gain, como se muestra en la figura 5.

La variable X(t) no se conoce porque es el resultado de integrar el lado derecho de la ecuación, esta variable debe multiplicarse con la exponencial con un bloque producto para formar el segundo término de la ecuación diferencial, luego ambos términos se combinan con un bloque Sum para obtener la ecuación (dX(t)/dt) completa que pasa por un integrador para obtener la variable X(t), que se realimenta al bloque producto.

Se debe colocar igualmente un bloque de reloj para que el simulador contabilice el tiempo. Todas las señales que se deseen guardar o ser posteriormente llamadas para graficar, deben ser alimentadas a un bloque workspace (Save format : Array)

(Diagrama de bloques de la simulación de la ecuación diferencial)

Haciendo clic en cada bloque se pueden cambiar sus parámetros y sus nombres. En este caso se colocan los siguientes:

de esta forma tenemos:

(Diagrama de bloques con sus parametros)

A continuación se abre el menú Simulation .
Simulation Parameters y se modifica el tiempo de parada. En este caso se pondrá 8 seg. Posteriormente se simula la ecuación diferencial apretando el botón o símbolo de “play” en la parte superior de la pantalla y se espera a que la maquina realice el calculo (indicado en la parte inferior derecha de la ventana)

Después de realizar la simulación se regresa a la ventana principal de Matlab y se grafican los resultados colocando el comando: plot(T,X) y se obtiene:

(simulación de la respuesta de la ecuación diferencial)

Para observar la respuesta del sistema ante una perturbación se coloca:

Para que el simulador acepte el cambio, el archivo debe ser guardado (no debe aparecer un “asterisco” al lado del nombre del programa en la parte superior de la ventana). Después de simular y graficar, se obtiene:

(Respuesta del sistema de la ecuacion diferencial ante entrada escalon)

se observa la perturbacion del sistema en el tiempo = 4 seg.

jueves, 29 de noviembre de 2018

Tutorial trasmisor de celda de carga HX711, Balanza Digital

https://naylampmechatronics.com/blog/25_tutorial-trasmisor-de-celda-de-carga-hx711-ba.html

Tutorial trasmisor de celda de carga HX711, Balanza Digital

Posted by Tutoriales 264 Comments

En este tutorial trabajaremos con la trasmisor de celda de carga HX711, he indicaremos todos los pasos en su conexión y programación para armar una balanza digital o cualquier uso que lo podamos dar

Celdas De Carga

Una celda de carga es un transductor capaz de convertir una fuerza en una señal eléctrica, esto la hace a través uno o más galgas internas que posee, configuradas en un puente Wheatstone.

Existen diversos tipos de Celdas de carga, en diversos modelos, el que utilizaremos para este tutorial es el que se muestra en la imagen. Usaremos una celda de carga de 5Kg que es el valor máximo que puede sensar, pero el tutorial también aplica a celdas de 20Kg y otros modelos.

Trasmisor de celda de carga HX711

Este módulo es una interface entre las celdas de carga y el microcontrolador, permitiendo poder leer el peso de manera sencilla. Internamente se encarga de la lectura del puente wheatstone formado por la celda de carga, convirtiendo la lectura analógica a digital con su conversor A/D interno de 24 bits.

Es muy utilizado en procesos industriales, sistemas de medición automatizada e industria médica.

Se comunica con el microcontrolador mediante 2 pines (Clock y Data) de forma serial.

Armando la parte mecánica de nuestra Balanza Digital

Para instalar la celda de carga hay que hacerlo con separadores, los cuales deben de distanciar a la base y recipiente de la celda para que la parte central quede libre; además hay que tener en cuenta que el sentido de la flecha indica la dirección de la fuerza o peso a aplicar

La siguiente figura muestra un ejemplo de cómo instalar la celda de carga, pero dependerá de su aplicación para hacer las variaciones necesarias

Conexiones entre la Celda de carga, módulo HX711 y Arduino.

Conexión entre la Celda de carga y módulo HX711

Celda De Carga	Módulo HX711
Cable Rojo	Pin E+
Cable Negro	Pin E-
Cable Verde	Pin A-
Cable Blanco	Pin A+

Conexión entre HX711 y Arduino

Módulo HX711	Arduino UNO, MEGA, NANO
Pin GND	Pin GND
Pin DT	Pin A1
Pin SCK	Pin A0
Pin VCC	Pin 5V

La conexión final sería como se muestra en la imagen.

Coenxiones Celda de carga HX711 Arduino

Librería HX711 para Arduino

Estamos utilizando la librería HX711 de Bogde el cual lo pueden descargar desde Github:

- https://github.com/bogde/HX711

Una vez descargado hay que importarla a nuestro IDE de Arduino.

Explicaremos las funciones principales de esta librería.

HX711(byte PinData, byte PinClock)

Es el constructor del objeto HX711, se puede trabajar con cualquiera de los pines.

void tare(byte n);

Establece el peso actual como el peso de tara, n indica el número de lecturas que se realizan para obtener la tara, por defecto n=10;

void set_scale(float scale);

Establece el valor de la escala, que es el factor de conversión para convertir valor de lectura en un valor con unidades de peso. Por defecto es scale=1;

long read()

Espera hasta que el dispositivo esté listo y devuelve la lectura del ADC del HX711

long read_average(byte n)

Realiza n veces la lectura del ADC y devuelve el promedio

double get_value(byte n)

Devuelve el valor actual restando el peso de tara. Equivalente a (read_average() - OFFSET) . Si se especifica un valor de n, devuelve el promedio de n lecturas.

float get_units(byte n)

Devuelve el valor actual restado del peso de tara y dividido por la escala. Es equivalente a (get_value()/SCALE). Si se especifica un valor de n, devuelve el promedio de n lecturas.

1. Calibrando nuestra Balanza

Lo primero que se debe de hacer es calibrar, que es básicamente hallar el valor de la escala que se usará; es decir hallar el factor de conversión para convertir valor de lectura en un valor con unidades de peso. La escala es diferente para cada celda y cambia de acuerdo a la forma de instalar, al peso máximo o modelo de celda de carga, incluso así se trate del mismo modelo de celdas no necesariamente tienen el mismo valor de escala.
Primero necesitamos conseguir un objeto con peso conocido, en otras palabras debemos saber el peso real del objeto. Se recomienda que el peso conocido sea cercano al valor máximo del rango de trabajo de la celda de carga. En nuestro caso usaremos un peso de 4Kg pues nuestra celda es de 5Kg.

El siguiente paso es cargar el siguiente Sketch a nuestro Arduino.

#include "HX711.h"

#define DOUT  A1
#define CLK  A0

HX711 balanza(DOUT, CLK);

void setup() {
  Serial.begin(9600);
  Serial.print("Lectura del valor del ADC:  ");
  Serial.println(balanza.read());
  Serial.println("No ponga ningun  objeto sobre la balanza");
  Serial.println("Destarando...");
  balanza.set_scale(); //La escala por defecto es 1
  balanza.tare(20); //El peso actual es considerado Tara.
  Serial.println("Coloque un peso conocido:");
  
}


void loop() {

  Serial.print("Valor de lectura:  ");
  Serial.println(balanza.get_value(10),0);
  delay(100);
}

El programa debe correr sin el peso colocado, pues al inicio de programa calcula la tara.
Después de abrir el monitor serial y esperar para que reste la tara, Se pone el objeto de 4Kg o el peso con el que estén trabajando.

Calibracion con peso 4Kg

Después de poner el peso en la balanza, en el monitor serial se mostraran las lecturas del peso, son lecturas sin escalar, por lo que les deben aparecer números grandes.
Datos calibracion

Con uno o el promedio de estos datos calculamos el valor de la escala que usaremos, para esto usaremos la siguiente formula:
Formula escala HX711

El valor del peso debe estar en las unidades con las que queremos que trabaje nuestra balanza, por ejemplo podría ser 4Kg o 4000g para Kilogramo o gramos respectivamente.
Entonces el valor de la Escala que usaremos es:
Factor de escala HX711

Con este dato ya obtenido pasamos a programar el sketch que vamos a utilizar para pesar.

2. Programa final para nuestra Balanza

El programa que se utilizara es similar al programa que usamos para calibrar, con la diferencia que ya conocemos la escala.

#include "HX711.h"

#define DOUT  A1
#define CLK  A0

HX711 balanza(DOUT, CLK);

void setup() {
Serial.begin(9600);
  Serial.print("Lectura del valor del ADC:  ");
  Serial.println(balanza.read());
  Serial.println("No ponga ningun  objeto sobre la balanza");
  Serial.println("Destarando...");
  Serial.println("...");
  balanza.set_scale(439430.25); // Establecemos la escala
  balanza.tare(20); //El peso actual es considerado Tara.
  
  Serial.println("Listo para pesar");  
}

void loop() {
  Serial.print("Peso: ");
  Serial.print(balanza.get_units(20),3);
  Serial.println(" kg");
  delay(500);
}

Como se observa en el código, es necesario encender el Arduino antes de colocar los objetos que se desean pesar, de lo contrario el peso que esté sobre la balanza se considerará como tara.
A continuación se muestran las lecturas agregando sucesivamente pesos de 1Kg aproximadamente.

Como pueden ver el módulo HX711 es fácil de implementar en cualquier proyecto, la aplicaciones son varias y espero puedan sacarle provecho.

Descargar Movie Maker en Español

Descargar Movie Maker en Español}

https://www.topwin-movie-maker.com/es/download.html

miércoles, 28 de noviembre de 2018

Desactivar las aplicaciones en segundo plano de Windows 10

https://privacy.microsoft.com/es-es/windows-10-background-apps-and-your-privacy

https://www.youtube.com/watch?v=IxX350_N3ac

Para controlar qué aplicaciones se pueden ejecutar en segundo plano

Vaya a Inicio y luego seleccione Configuración  > Privacidad > Aplicaciones en segundo plano.
En Aplicaciones en segundo plano, asegúrese de que Permitir que las aplicaciones se ejecuten en segundo plano esté Activado.
En Elegir qué aplicaciones se pueden ejecutar en segundo plano, cambie las opciones de configuración de las aplicaciones y servicios individuales a Activado o Desactivado.

Para bloquear la ejecución de la mayor parte de las aplicaciones en segundo plano

Vaya a Inicio y luego seleccione Configuración  > Privacidad > Aplicaciones en segundo plano.
En Aplicaciones en segundo plano, asegúrese de que Permitir que las aplicaciones se ejecuten en segundo plano esté Desactivado.

Cómo evitar que Windows Update actualice controladores

https://answers.microsoft.com/es-es/windows/forum/windows_10-hardware-winpc/c%C3%B3mo-evitar-que-windows-update-actualice/7c2d54cc-e9dc-47cb-8ec5-c110e9552280

A) Deshabilitar la actualización de controladores en Windows Update mediante Directiva de grupo

Para llevar a cabo esta acción, puedes seguir estos pasos:
1. Pulsa las teclas Windows+R
2. En la casilla Abrir escribe gpedit.msc y pulsa Intro
3. En la consola de Directiva de grupo local, localiza la siguiente ruta:

Directiva de equipo local
Configuración del equipo
Plantillas administrativas
Componentes de Windows
Windows Update

4. En el panel derecho haz doble clic en la opción No incluyas controladores con las actualizaciones de Windows y la habilitas.

5. Cierra la Directiva de grupo y reinicia el sistema.

B) Deshabilitar la actualización de controladores en Windows Update mediante el registro de Windows

Este ajuste puede llevarse a cabo en cualquiera de las ediciones de Windows 10 (a partir de la build 14328):

1. Pulsa las teclas Windows+R
2. En la casilla Abrir escribe regedit y pulsa Intro
3. En el editor del registro localiaza la siguiente clave:
HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows

4. Selecciona la subclave Windows y haz clic en Edición > Nuevo > Clave. Dale el nombre Windows Update

5. Selecciona ahora Windows Update y en el panel derecho crea un nuevo valor DWORD (32 bits) con el nombre ExcludeWUDriversInQualityUpdate

6. Haz doble clic sobre este valor y en la casilla Información del valor escribe un uno (1) y guarda los cambios.

7. Cierra el editor del registro y reinicia el sistema.

Solucionado: Windows 10 PRoblemas con disco full windows\temp o con AppXSvc o wsappx o AppXDeploymentServer_477B15EF-8531-0001-1A5C-7D473185D401

La solución fue deshabilitar las aplicaciones en segundo plano
https://profeitm.blogspot.com/2018/11/desactivar-las-aplicaciones-en-segundo.html

https://www.thewindowsclub.com/wsappx-fix-high-disk-usage-issue

Using Group Policy Editor

Type ‘gpedit.msc’ in Start Search and press Enter. It opens the Local Group Policy Editor.
Go to ‘Computer Configuration’ and select ‘Administrative Templates’.
Then go to ‘Windows Components’ and select ‘Store’.
Find the ‘Turn Off Store application’ setting in the right pane.
Select ‘Enable’ and ‘Apply’.

Using Registry Editor
Some versions of Windows do not have the Group Policy Editor option. So, here is the other way to do it. But before you begin, create a backup of your data first.

Type ‘regedit’ in Start Search and hit ‘Enter’. This opens the Registry Editor.
Navigate to HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\WindowsStore key.
Here you need to create new DWORD value within the Windows Store key and name it RemoveWindowsStore and give it the value of ‘1’. If the WindowsStore key does not exist itself, you will have to create it.

martes, 27 de noviembre de 2018

Geogebra - Tutorial para hacer Transformaciones a Imágenes en Geogebra

Geogebra - Tutorial para hacer Transformaciones a Imágenes en Geogebra

https://wiki.geogebra.org/es/Tutorial:Transformando_Im%C3%A1genes

Tutorial:Transformando Imágenes

Tutorial: Transformando Imágenes Versión del Centro Babbage

Lista de Tutoriales

Inserta-Traslada-Rota y Desfigura Imágenes

Transformando

Se parte de una imagen	Con la correspondiente herramienta, de Imagen en la Vista Gráfica
Pista: Un clic en una posición de la Vista Gráfica establece el vértice inferior izquierdo de la figura.	Nota: El vértice inferior izquierdo permite desplazar la imagen.
Con la herramienta correspondiente, se ajusta la posición de la imagen.	Creando tres puntos se los puede fijar como esquinas del marco de la imagen.
	Fijar la imagen como la de fondo (tildando la casilla correspondiente que aparece en la pestaña Básico del caja de diálogo de Propiedades).
	Reducir la opacidad de la imagen (con el dial que aparece en la pestaña Color del cuadro de Propiedades).
Pista: Tras determinar la imagen como de fondo, para hacer cualquier modificación, es preciso abrir el Cuadro de Propiedades desde el Menú Edita (ya no es posible seleccionarla en la Vista Gráfica).	Nota: Se puede quitar la cualidad de la imagen como de fondo para seguir operando con ella con las herramientas de transformación.
	Al crear tres puntos, A, B y C, se pueden fijar como esquinas y desplazarlos para deformar la imagen.
	Se puede reflejar la imagen por un punto o una recta También, trasladarla por un vector; rotarla cierto ángulo o emplear otra herramienta para transformarla.
Rellenos y Teselados	Se puede emplear un archivo de imagen para que haga las veces de relleno de cualquier polígono, regular o no
Pista: En la pestaña Estilo se puede establecer que el Sombreado sea una Imagen (a seleccionar Desde Archivo).	Nota: Es posible fijar la Opacidad con el dial correspondiente y/o establecer que se Invierte Relleno.
	Se puede teselar cualquier polígono y algunos de los regulares con maniobras de traslación sencillas y cuando el relleno del original es una imagen, el resultado es vistoso y artístico, incluso. en:Tutorial:Transformations & Inserting Pictures into the Graphics View

Categoría:

Tutoriales

viernes, 23 de noviembre de 2018

ACTIVAR Windows 10 - Para Siempre 2018 - Sin programas ni activadores [FÁCIL]

https://www.youtube.com/watch?v=VUONT6m_zgM

https://www.youtube.com/watch?v=OKvz8pjlScA

slmgr /ipk ***---*-***
slmgr /skms kms.digiboy.ir o kms.msguides.com
slmgr /ato

Windows 10 Home: TX9XD-98N7V-6WMQ6-BX7FG-H8Q99
Windows 10 Home N: 3KHY7-WNT83-DGQKR-F7HPR-844BM
Windows 10 Home Single Language: 7HNRX-D7KGG-3K4RQ-4WPJ4-YTDFH
Windows 10 Home Country Specific: PVMJN-6DFY6-9CCP6-7BKTT-D3WVR
Windows 10 Professional: W269N-WFGWX-YVC9B-4J6C9-T83GX
Windows 10 Professional N: MH37W-N47XK-V7XM9-C7227-GCQG9
Windows 10 Enterprise: NPPR9-FWDCX-D2C8J-H872K-2YT43
Windows 10 Enterprise N: DPH2V-TTNVB-4X9Q3-TJR4H-KHJW4
Windows 10 Education: NW6C2-QMPVW-D7KKK-3GKT6-VCFB2
Windows 10 Education N: 2WH4N-8QGBV-H22JP-CT43Q-MDWWJ
Windows 10 Enterprise 2015 LTSB: WNMTR-4C88C-JK8YV-HQ7T2-76DF9
Windows 10 Enterprise 2015 LTSB N: 2F77B-TNFGY-69QQF-B8YKP-D69TJ

martes, 20 de noviembre de 2018

Como hacer DropOut en TensorFlow con Mnist - Convolutional Neural Network for MNIST -Как сделать DropOut в TensorFlow с помощью Mnist

Como hacer DropOut en TEnsor Flow con Mnist - Convolutional Neural Network for MNIST
Как сделать DropOut в TensorFlow с помощью Mnist

https://wpovell.github.io/posts/cnn-mnist.html

Convolutional Neural Network for MNIST

Jun 23 2017

☀️ This post is a part of my Summer of Tensorflow series ☀️
In this post I’m going to walk through implementing a Convolutional Neural Network in TensorFlow to classify MNIST digits.

Code adapted from siddk's tensorflow workshop

The Math

\begin{aligned} X & = Image Matrix \\ C_{1} & = ReLU (conv2d (X, W_{c 1}) + B_{c 1}) \\ P_{1} & = maxPool (C_{1}) \\ C_{2} & = ReLU (conv2d (P_{1}, W_{c 2}) + B_{c 2}) \\ P_{2} & = maxPool (C_{2}) \\ F & = Flattened form of P_{2} \\ H & = ReLU (F \times W_{f 1} + b_{f 1}) \\ O & = Softmax (H \times W_{f 2} + b_{f 2}) \\ L & = Loss (O, Y) \end{aligned}

Setup

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf 

# Fetch MNIST Dataset using the supplied Tensorflow Utility Function
mnist = input_data.read_data_sets("data/MNIST_data/", one_hot=True)

# Setup the Model Parameters
INPUT_SIZE, OUTPUT_SIZE = 784, 10  
FILTER_SIZE, FILTER_ONE_DEPTH, FILTER_TWO_DEPTH = 5, 32, 64
FLAT_SIZE, HIDDEN_SIZE = 7 * 7 * 64, 1024

Convolution and Pooling

The two main transformations used in the CNN different from the FFNN are convolution and pooling.

Convolution

From which the CNN gets its name, Convolution is a process of applying filters to the image. In our case, the filter is a 5x5 matrix which is positioned over every cell of the image, multiplying pairwise and summing. For our model we have 32 of these filters in the first convolution, and 64 for the second. The values in these are trained by TensorFlow to minimize the loss.

Source

Pooling

Pooling shrinks the outputted feature maps from the convolution, removing less important information. In max pooling, each 2x2 area is condensed to its largest value, cutting each side length in half (28 to 14 and 14 to 7). Average pooling is also used where the average of each pool is outputted into the new cell.

Source

# Create Convolution/Pooling Helper Functions 
def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

### Start Building the Computation Graph ###

# Initializer - initialize our variables from standard normal with stddev 0.1
initializer = tf.random_normal_initializer(stddev=0.1)

# Setup Placeholders => None argument in shape lets us pass in arbitrary sized batches
X = tf.placeholder(tf.float32, shape=[None, INPUT_SIZE])  
Y = tf.placeholder(tf.float32, shape=[None, OUTPUT_SIZE])
keep_prob = tf.placeholder(tf.float32) 

# Reshape input so it resembles an image (height x width x depth)
X_image = tf.reshape(X, [-1, 28, 28, 1])

# Conv Filter 1 Variables
Wconv_1 = tf.get_variable("WConv_1", shape=[FILTER_SIZE, FILTER_SIZE,
                                            1, FILTER_ONE_DEPTH], initializer=initializer)
bconv_1 = tf.get_variable("bConv_1", shape=[FILTER_ONE_DEPTH], initializer=initializer)

# First Convolutional + Pooling Transformation
h_conv1 = tf.nn.relu(conv2d(X_image, Wconv_1) + bconv_1)
h_pool1 = max_pool_2x2(h_conv1)

# Conv Filter 2 Variables
Wconv_2 = tf.get_variable("WConv_2", shape=[FILTER_SIZE, FILTER_SIZE,
                                            FILTER_ONE_DEPTH, FILTER_TWO_DEPTH],
                          initializer=initializer)
bconv_2 = tf.get_variable("bConv_2", shape=[FILTER_TWO_DEPTH], initializer=initializer)

# Second Convolutional + Pooling Transformation
h_conv2 = tf.nn.relu(conv2d(h_pool1, Wconv_2) + bconv_2)
h_pool2 = max_pool_2x2(h_conv2)

Feed-Forward & Dropout

Our model finishes with flattening out last pool into a giant 3136 long vector and running it through our FFNN model from the last notebook. However, there is a small but important addition.
Dropout disables nodes with a probability of keep_prob, removing them as well as their connections from the graph. This also means they aren't trained during that particular iteration. This limits the performance of the model, preventing it from over fitting the train dataset.

# Flatten Convolved Image, into vector for remaining feed-forward transformations
h_pool2_flat = tf.reshape(h_pool2, [-1, FLAT_SIZE])

# Hidden Layer Variables
W_1 = tf.get_variable("W_1", shape=[FLAT_SIZE, HIDDEN_SIZE], initializer=initializer)
b_1 = tf.get_variable("b_1", shape=[HIDDEN_SIZE], initializer=initializer)

# Hidden Layer Transformation
hidden = tf.nn.relu(tf.matmul(h_pool2_flat, W_1) + b_1)

# DROPOUT - For regularization
hidden_drop = tf.nn.dropout(hidden, keep_prob)

# Output Layer Variables
W_2 = tf.get_variable("W_2", shape=[HIDDEN_SIZE, OUTPUT_SIZE], initializer=initializer)
b_2 = tf.get_variable("b_2", shape=[OUTPUT_SIZE], initializer=initializer)

# Output Layer Transformation
output = tf.matmul(hidden_drop, W_2) + b_2

# Compute Loss
loss = tf.losses.softmax_cross_entropy(Y, output)

Training & Results

# Compute Accuracy
correct_prediction = tf.equal(tf.argmax(Y, 1), tf.argmax(output, 1))
accuracy = 100 * tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# Setup Optimizer
train_op = tf.train.AdamOptimizer().minimize(loss)

### Launch the Session, to Communicate with Computation Graph ###
BATCH_SIZE, NUM_TRAINING_STEPS = 100, 1000
with tf.Session() as sess:
    # Initialize all variables in the graph
    sess.run(tf.global_variables_initializer())

    # Training Loop
    for i in range(NUM_TRAINING_STEPS):
        batch_x, batch_y = mnist.train.next_batch(BATCH_SIZE)
        curr_acc, _ = sess.run([accuracy, train_op], feed_dict={X: batch_x,
                                                                Y: batch_y,
                                                                keep_prob: 0.5})
        if i % 100 == 0:
            print('Step {} Current Training Accuracy: {:.3f}'.format(i, curr_acc))
    
    # Evaluate on Test Data
    # keep-prop = 1.0 to disable dropout
    print('Test Accuracy: {:.3f}'.format(sess.run(accuracy, feed_dict={X: mnist.test.images, 
                                                                Y: mnist.test.labels,
                                                                keep_prob: 1.0})))

Step 0 Current Training Accuracy: 9.000
Step 100 Current Training Accuracy: 91.000
Step 200 Current Training Accuracy: 96.000
Step 300 Current Training Accuracy: 99.000
Step 400 Current Training Accuracy: 96.000
Step 500 Current Training Accuracy: 95.000
Step 600 Current Training Accuracy: 98.000
Step 700 Current Training Accuracy: 97.000
Step 800 Current Training Accuracy: 99.000
Step 900 Current Training Accuracy: 99.000
Test Accuracy: 98.730