Cómo escribir tensorflow en Python
Comenzar
TensorFlow no es un marco de red neuronal puro, sino un marco que utiliza gráficos de flujo de datos para análisis numérico.
TensorFlow usa gráficos dirigidos (gráfico ) representa una tarea informática. Los nodos del gráfico se denominan operaciones (operaciones) para representar el procesamiento de datos, y el flujo de borde del gráfico describe el flujo de datos.
El proceso informático de este marco. es procesar el flujo compuesto por tensores. Este es también el origen del nombre TensorFlow.
TensorFlow usa tensor para representar datos. tensor significa tensor, que es una matriz de alta dimensión y está representada por numpy. .ndarray en python.
TensorFlow usa Session para ejecutar la figura, usa Variable para mantener el estado tf.constant es una operación que solo puede generar salida y, a menudo, se usa como fuente de datos.
Ahora construimos un gráfico simple con solo dos constantes como entrada y luego realizamos la multiplicación de matrices:
p>
desde tensorflow import Sesión, dispositivo, constante, matmul''''Construimos un gráfico simple con solo dos constantes como entrada y luego realice la multiplicación de matrices:'''#Si no utiliza la instrucción with session(), debe ejecutar manualmente session.close().
#with device dispositivo especifica el dispositivo para realizar cálculos:
# "/cpu: 0": la CPU de la máquina.
# "/gpu:0": la primera GPU de la máquina, si cualquiera.
# "/gpu:1": La segunda GPU de la máquina, y así sucesivamente.
con Session() como sesión: ?# Crea el contexto de ejecución gráfico
con dispositivo('/cpu:0'): ?# Especificar el dispositivo informático
mat1 = constante([[3, 3]]) ?# Crear nodo de origen
mat2 = constante([[2], [2]])
product = matmul(mat1, mat2 ) # Especifica el nodo anterior del nodo y crea el gráfico
resultado = session.run(product) # Ejecutar cálculo print(resultado)123456789101112131415161718
Utilice la variable para crear un contador a continuación:
p>desde sesión de importación de tensorflow, constante , Variable, agregar, asignar, inicializar_todas_variables
estado = Variable(0, nombre='contador') #Crear contador uno = constante(1) #Crear fuente de datos: 1val = agregar(estado, uno) # Crear nueva actualización de nodo de valor = asignar(estado, val) # Actualizar configuración del contador = inicializar_all_variables() # Inicializar variable con sesión() como sesión:
session.run (configuración) #Realizar inicialización
print(sesión.ejecutar(estado
)) # Valor inicial de salida
para i en el rango(3):
session.run(update) # Realizar actualización
print(session.run( state)) # Valor del contador de salida 12345678910111213
El gráfico devuelto por inicialize_all_variables() debe ejecutarse antes de usar variables. La ejecución del nodo Variable devolverá el valor de la variable.
En esto. Por ejemplo, el gráfico se construirá. El proceso se escribe fuera del contexto y no se especifica el dispositivo en ejecución.
En el ejemplo anterior, session.run solo acepta una operación como parámetro. De hecho, ejecutar. puede aceptar una lista de operaciones como entrada:
session.run([op1, op2])1
Los ejemplos anteriores siempre usan constantes como fuente de datos y el feed puede ingresar datos dinámicamente en tiempo de ejecución:
desde la sesión de importación de tensorflow, marcador de posición, mul, float32
entrada1 = marcador de posición(float32)
entrada2 = marcador de posición(float32)
salida = mul(entrada1, entrada2)con sesión( ) como sesión: print session.run(salida, feed_dict={entrada1: [3], entrada2: [2]})1234567
Implementación una red neuronal simple
La red neuronal es un modelo de aprendizaje automático ampliamente utilizado. Para conocer los principios de las redes neuronales, puede consultar este ensayo o experimentar la demostración en línea en el campo de juego de tensorflow.
p>
Primero defina una clase BPNeuralNetwork:
clase BPNeuralNetwork:
def __init__(self):
self.session = tf.Session()
self.input_layer = Ninguno
self .label_layer = Ninguno
self.loss = Ninguno
self.trainer = Ninguno
self.layers = [] def __del__(self):
self.session.close()1234567891011
Escribe una función para generar una red neuronal de una sola capa Cada capa de neuronas está representada por un diagrama de flujo de datos. Se utiliza una matriz variable para representar la relación con las neuronas anteriores. Conecte los pesos, otro vector variable representa el valor de sesgo y establezca una función de activación para la capa.
def make_layer(inputs, in_size, out_size, enable=None):
pesos = tf.Variable(tf.random_normal([in_size, out_size]))
basis = tf.Variable(tf.zeros([1, out_size]) 0.1)
resultado = tf.matmul(inputs,weights) base si se activa
es Ninguno: devolver resultado; de lo contrario: devolver activar(resultado)12345678
Usar marcador de posición como capa de entrada.
self.input_layer = tf.placeholder(tf.float32, [Ninguno, 2] )1
El segundo parámetro del marcador de posición es la forma del tensor [Ninguno, 1] indica un número ilimitado de filas y una matriz bidimensional con un número de columna de 1. El significado es el mismo. como numpy.array.shape Aquí, self.input_layer se define como la capa de entrada que acepta entradas bidimensionales.
Utilice también un marcador de posición para representar la etiqueta de los datos de entrenamiento:
self.label_layer = tf.placeholder(tf.float32 , [None, 1])1
Utilice make_layer para definir dos capas ocultas para la red neuronal y utilice la última capa como capa de salida:
self.loss = tf.reduce_mean( tf.reduce_sum(tf.square((self.label_layer - self.layers[1])), reducción_indices=[1]))1
tf.train proporciona algunos optimizadores que se pueden utilizar para entrenar redes neuronales. El objetivo es minimizar la función de pérdida:
self.trainer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss). )1
Utilice Session para ejecutar el modelo de red neuronal:
initer = tf.initialize_all_variables()# dotrainingself.session.run(initer)
para i in range(limit):
self. session.run(self.trainer, feed_dict={self.input_layer: casos, self.label_layer: etiquetas})12345
Utilice el modelo entrenado para predicción:
self.session .run(self.layers[-1], feed_dict={self.input_layer: case})1
Código completo:
importar tensorflow como tfimport numpy como npdef make_layer(inputs, in_size, out_size, enable=None):
pesos = tf.Variable(tf.random_normal([in_size, out_size]))
basis = tf.Variable(tf.zeros( [1, out_size]) 0.1)
resultado = tf.matmul(inputs,weights) base si la activación es Ninguna: devuelve el resultado en caso contrario: volver activar(resultado)clase BPNeuralN
etwork:
def __init__(self):
self.session = tf.Session()
self.input_layer = Ninguno
self.label_layer = Ninguno
self.loss = Ninguno
self.optimizer = Ninguno
self.layers = [] def __del__(self): p>
self.session.close() def train(self, casos, etiquetas, límite=100, learn_rate=0.05):
# Construir red
self .input_layer = tf.placeholder(tf.float32, [Ninguno, 2])
self.label_layer = tf.placeholder(tf.float32, [Ninguno, 1])
self .layers .append(make_layer(self.input_layer, 2, 10, enable=tf.nn.relu))
self.layers.append(make_layer(self.layers[0], 10, 2, activar= Ninguno))
self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer - self.layers[1])), reducción_indices=[1]))
self.optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)
initer = tf.initialize_all_variables() # Hacer entrenamiento
self .session .run(initer) para i en rango(límite):
self.session.run(self.optimizer, feed_dict={self.input_layer: casos, self.label_layer: etiquetas}) def predecir (self , case):
return self.session.run(self.layers[-1], feed_dict={self.input_layer: case}) def test(self):
x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_data = np.array([[0, 1, 1, 0]]).transpose()
test_data = np.array([[0, 1]])
self.train(x_data, y_data)
imprimir(self.predict(test_data))
nn = BPNeuralNe
twork()
nn.test()12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152
El modelo anterior es simple pero fácil de usar. flexible, el autor utiliza la misma idea para implementar una dimensión de entrada y salida personalizable y múltiples -layer Para la red de neuronas ocultas, consultedynamic_bpnn.py
importar tensorflow as tfimport numpy as npdef make_layer(inputs, in_size, out_size, enable=None):
weights = tf . Variable(tf.random_normal([in_size, out_size]))
base = tf.Variable(tf.zeros([1, out_size]) 0.1)
resultado = tf. base matmul (entradas, pesos) si la activación es Ninguna: devolver resultado; de lo contrario: devolver activar(resultado)clase BPNeuralNetwork:
def __init__(self):
self.session = tf. Sesión ()
self.loss = Ninguno
self.optimizer = Ninguno
self.input_n = 0
self.hidden_n = 0
self.hidden_size = []
self.output_n = 0
self.input_layer = Ninguno
self.hidden_layers = [ ]
self.output_layer = Ninguno
self.label_layer = Ninguno
def __del__(self):
self.session.close ( ) def setup(self, ni, nh, no):
# Establecer el número de parámetros
self.input_n = ni
self.hidden_n = len( nh) ?#Número de capas ocultas
self.hidden_size = nh ?#Número de celdas en cada capa oculta
self.output_n = no #Construir capa de entrada
self.input_layer = tf.placeholder(tf.float32, [Ninguno, self.input_n]) #Construir capa de etiqueta
self.label_layer = tf.placeholder(tf.float32, [Ninguno, self.output_n]) #Construir capa oculta
in_size = self.input_n
out_size = self.hidden_size[0]
inp
uts = self.input_layer
self.hidden_layers.append(make_layer(inputs, in_size, out_size, enable=tf.nn.relu)) for i in range(self.hidden_n-1):
in_size = out_size
out_size = self.hidden_size[i 1]
entradas = self.hidden_layers[-1]
self.hidden_layers. append(make_layer(inputs, in_size, out_size, enable=tf.nn.relu)) #Construye la capa de salida
self.output_layer = make_layer(self.hidden_layers[-1], self.hidden_size[- 1 ], self.output_n) def train(self, casos, etiquetas, límite=100, learn_rate=0.05):
self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self . label_layer - self.output_layer)), reducción_indices=[1]))
self.optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)
initer. = tf.initialize_all_variables() #Hacer entrenamiento
self.session.run(initer) para i en rango(límite):
self.session.run(self.optimizer, feed_dict = {self.input_layer: casos, self.label_layer: etiquetas}) def predecir(self, caso):
return self.session.run(self.output_layer, feed_dict={self.input_layer: caso} ) def prueba(self):
x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_data = np.array([[0, 1, 1, 0]]).transpose()
test_data = np.array([[0, 1]])
self.setup(2, [10, 5], 1)
self.train(x_data, y_data)
print(self.predict(test_data))
nn = BPNeuralNetwork()
nn.test()1234567891011121314151617181920
2122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576