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

Tutorial trasmisor de celda de carga HX711, Balanza Digital
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.

Celda de carga        Celda de carga 5Kg
   


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.
Modulo HX711

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
 Diseño Balanza

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 RojoPin  E+
Cable NegroPin E-
Cable VerdePin A-
Cable BlancoPin A+ 

Conexión entre HX711 y Arduino
Módulo HX711Arduino UNO, MEGA, NANO
Pin GNDPin GND
Pin DTPin A1
Pin SCKPin A0
Pin VCCPin 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:
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.
 
Resultados
 
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

  1. Vaya a Inicio y luego seleccione Configuración > Privacidad > Aplicaciones en segundo plano.
  2. En Aplicaciones en segundo plano, asegúrese de que Permitir que las aplicaciones se ejecuten en segundo plano esté Activado.
  3. 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

  1. Vaya a Inicio y luego seleccione Configuración > Privacidad > Aplicaciones en segundo plano.
  2. 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.
Imagen
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.
Imagen

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
  1. Type ‘gpedit.msc’ in Start Search and press Enter. It opens the Local Group Policy Editor.
  2. Go to ‘Computer Configuration’ and select ‘Administrative Templates’.
  3. Then go to ‘Windows Components’ and select ‘Store’.
  4. Find the ‘Turn Off Store application’ setting in the right pane.
  5.  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.
  1. Type ‘regedit’ in Start Search and hit ‘Enter’. This opens the Registry Editor.
  2. Navigate to HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\WindowsStore key.
  3. 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

Inserta-Traslada-Rota y Desfigura Imágenes

Transformando

Mondrian 1.PNG Se parte de una imagen Con la correspondiente Mode image.png herramienta, de Imagen en la Vista Gráfica
Note 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.
Mode move.pngCon la herramienta correspondiente, se ajusta la posición de la imagen. Mode point.png Creando tres puntos se los puede fijar como esquinas del marco de la imagen.
Imagen de Fondo Reducida.PNG 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).
Opacidad .PNG Reducir la opacidad de la imagen (con el dial que aparece en la pestaña Color del cuadro de Propiedades).
Note 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.
Modrian Esquinado y Deformado.PNG Al crear tres Mode point.pngpuntos, A, B y C, se pueden fijar como esquinas y Mode move.pngdesplazarlos para deformar la imagen.
Imágenes transformadas reducida.PNG Se puede reflejar la imagen por Tool Reflect Object in Point.gif un punto o Tool Reflect Object in Line.gif una recta También, Tool Translate Object by Vector.gif trasladarla por un vector; Tool Rotate Object around Point by Angle.gif rotarla cierto ángulo o emplear otra herramienta para transformarla.
Rellenos y Teselados Relleno 2.PNG Se puede emplear un archivo de imagen para que haga las veces de relleno de cualquier polígono, Tool Regular Polygon.gif regular o Tool Polygon.gif no
Kandinsky5.jpg
Note 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.
Tesela 1.PNG 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

viernes, 23 de noviembre de 2018

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

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

XC1P1C2P2FHOL= Image Matrix =ReLU(conv2d(X,Wc1)+Bc1)=maxPool(C1)=ReLU(conv2d(P1,Wc2)+Bc2)=maxPool(C2)= Flattened form of P2=ReLU(F×Wf1+bf1)=Softmax(H×Wf2+bf2)=Loss(O,Y)

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

TensorFlow and deep learning, without a PhD

https://codelabs.developers.google.com/codelabs/cloud-tensorflow-mnist/#0

TensorFlow and deep learning, without a PhD

 

1. Overview


In this codelab, you will learn how to build and train a neural network that recognises handwritten digits. Along the way, as you enhance your neural network to achieve 99% accuracy, you will also discover the tools of the trade that deep learning professionals use to train their models efficiently.
This codelab uses the MNIST dataset, a collection of 60,000 labeled digits that has kept generations of PhDs busy for almost two decades. You will solve the problem with less than 100 lines of Python / TensorFlow code.

What you'll learn

  • What is a neural network and how to train it
  • How to build a basic 1-layer neural network using TensorFlow
  • How to add more layers
  • Training tips and tricks: overfitting, dropout, learning rate decay...
  • How to troubleshoot deep neural networks
  • How to build convolutional networks

What you'll need

  • Python 2 or 3 (Python 3 recommended)
  • TensorFlow
  • Matplotlib (Python visualisation library)
Installation instructions are given in the next step of the lab.

 

Adding layers in Tensor Flow - Trabajando varias capas en Tensor Flow

Adding layers in Tensor Flow - Trabajando varias capas en Tensor Flow
https://codelabs.developers.google.com/codelabs/cloud-tensorflow-mnist/#6


7. Lab: adding layers


To improve the recognition accuracy we will add more layers to the neural network. The neurons in the second layer, instead of computing weighted sums of pixels will compute weighted sums of neuron outputs from the previous layer. Here is for example a 5-layer fully connected neural network:

We keep softmax as the activation function on the last layer because that is what works best for classification. On intermediate layers however we will use the the most classical activation function: the sigmoid:

To add a layer, you need an additional weights matrix and an additional bias vector for the intermediate layer:
W1 = tf.Variable(tf.truncated_normal([28*28, 200] ,stddev=0.1))
B1 = tf.Variable(tf.zeros([200]))

W2 = tf.Variable(tf.truncated_normal([200, 10], stddev=0.1))
B2 = tf.Variable(tf.zeros([10]))
The shape of the weights matrix for a layer is [N, M] where N is the number of inputs and M of outputs for the layer. In the code above, we use 200 neurons in the intermediate layer and still 10 neurons in the last layer.
And now change your 1-layer model into a 2-layer model:
XX = tf.reshape(X, [-1, 28*28])

Y1 = tf.nn.sigmoid(tf.matmul(XX, W1) + B1)
Y  = tf.nn.softmax(tf.matmul(Y1, W2) + B2)
That's it. You should now be able to push your network above 97% accuracy with 2 intermediate layer with for example 200 and 100 neurons.