Cómo escribir tensorflow en Python
TensorFlow no es un marco de red neuronal puro, sino un marco para análisis numérico utilizando gráficos de flujo de datos.
TensorFlow utiliza gráficos dirigidos para representar tareas informáticas. Los nodos del gráfico se denominan operaciones (operaciones) para representar el procesamiento de datos, y los flujos de borde del gráfico describen el flujo de datos.
El proceso informático de este marco consiste en procesar un flujo de tensores, que también es el origen del nombre TensorFlow.
TensorFlow utiliza tensores para representar datos. Tensor significa tensor, que es una matriz de alta dimensión, representada por numpy.ndarray en Python.
TensorFlow usa sesiones para ejecutar gráficos y variables para mantener el estado. tf.constant es una operación de solo salida, que a menudo se utiliza como fuente de datos.
Construyamos un gráfico simple con solo dos constantes como entrada y luego realicemos la multiplicación de matrices:
Importar sesión, dispositivo, constante, matmul desde tensorflow ' 'Construyamos un gráfico con solo dos Un gráfico simple con una constante como entrada y multiplicación de matrices: ' ' #Si no utiliza la instrucción with session(), debe ejecutar manualmente session.close().
#con dispositivo dispositivo especifica el dispositivo para realizar los cálculos:
# "/cpu:0 ": La cpu de la máquina.
# "/gpu:0 ": La primera gpu de la máquina, si la hay.
# "/gpu:1 ": La segunda gpu de la máquina, y así sucesivamente.
Sesión() como sesión:? #Crear el contexto del gráfico de ejecución
Usar dispositivo ('/cpu:0 '):? #Especificar dispositivo informático
mat1 = constante ([[3, 3]])? #Crear nodo de origen
mat2 = constante ([[2], [2]])
Producto = matmul (mat1, mat2) #Especifique el nodo anterior del nodo y cree un gráfico.
Resultado = session.run(producto) #Ejecutar cálculo e imprimir (resultado) 12345678910121314151565438.
Usemos variables para hacer un contador:
Importar sesiones, constantes, variables de tensorflow, agregar, asignar, inicializar todas las variables
Estado = variable ( 0 , nombre = 'contador')# Crear contador uno = constante(1)# Crear fuente de datos:1 Val = agregar(estado, uno)# Crear nuevo nodo de valor Actualizar = asignar(estado, Val)# Actualizar configuración del contador = Inicializar _ all _ variables()# Inicializar variable con Session()como Sesión:
Session.run(setup) #Realizar la inicialización.
Imprimir(session.run(estado)) #Imprimir el valor inicial.
Para I en el rango (3):
Session.run(update) #Realizar actualización.
Imprimir(session.run(state)) #Valor del contador de salida 12345678910111213.
Antes de usar variables, debes ejecutar el gráfico devuelto por inicialize_all_variables(). Al ejecutar el nodo de variable, se devolverá el valor de la variable.
En este ejemplo, el proceso de construcción del gráfico se saca de contexto y no se especifica el dispositivo en ejecución.
En el ejemplo anterior, session.run solo acepta una operación como parámetro, pero de hecho, run puede aceptar una lista de operaciones como entrada:
session.run([op1 , op2 ])1
El ejemplo anterior siempre usa una constante como fuente de datos y el feed puede ingresar datos dinámicamente en tiempo de ejecución:
Importar sesión, marcador de posición, mul, float32 desde tensorflow
p>entrada1 = marcador de posición (float32)
entrada2 = marcador de posición (float32)
salida = mul(entrada1, entrada2), Sesión() es Sesión: print Session.run(output, feed_dict={input1: [3], input2: [2]})1234567
Implementación de una red neuronal simple
La red neuronal es una herramienta ampliamente utilizada. modelo de aprendizaje utilizado. Con respecto a los principios de las redes neuronales, puede consultar este breve artículo o experimentar la demostración en línea en el patio de juegos de tensorflow.
Primero, defina una clase BPNeuralNetwork:
Clase BPNeuralNetwork:
def __init__(self):
self.session = tf. sesión()
self.input_layer=Ninguno
self.label_layer=Ninguno
self-loss=Ninguno
self-coach= Ninguno
self.layers = [] def __del__(self):
self session . close()1234567891011
Escribe una función que genere un archivo único. Red neuronal de capa, cada capa de neuronas está representada por diagramas de flujo de datos. Utilice una matriz variable para representar los pesos de conexión a las neuronas frontales, otro vector variable para representar los valores de compensación y establezca una función de activación para esta capa.
def make_layer(entrada, tamaño_entrada, tamaño_salida, activación=Ninguno):
peso = tf. variable(tf.random_normal([in_size, out_size])
base = tf. variable(tf.zeros([1, out_size]) + 0.1)
resultado = tf.matmul (entradas, pesos) + base si la activación es Ninguna: devuelve el resultado; de lo contrario: devuelve activar(resultado)12345678
Usar marcador de posición como capa de entrada
self input_layer =. TF . float 32, [None, 2])1
El segundo parámetro del marcador de posición es la forma del tensor, [None, 1] representa una matriz bidimensional y el número de filas es. sin límite, el número de columnas es 1, que tiene el mismo significado que 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 . float 32, [None, 1]) 1 <. / p>
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 _ indexes =[1]))1
Tf.train proporciona algunos optimizadores que se pueden utilizar para entrenar neuronales. redes. Con el objetivo de minimizar la función de pérdida:
self trainer = TF gradientoptimizer(learn _ rate). Minimizar (autopérdida) 1
Utilice la sesión para ejecutar el modelo de red neuronal:
initer = TF. inicializar _ todas las variables()# realizar la sesión de entrenamiento (. initer)
Para I(límite) en alcance:
self.session.run(self.trainer, feed_dict = { self.input_layer:cases, self.label_layer:labels } )12345
Utilice el modelo entrenado para predecir:
self session .self .layers[-1], feed _ dict = { self . input _layer:case } )1
Código completo:
Importar tensorflow como tfimport numpy como npdef make_layer (entradas, in_size, out_size, enable=None):
peso = tf. variable(tf.random_normal([in_size, out_size])
base = tf. variable(tf.zeros([1, out_size]) + 0.1)
resultado = tf.matmul (entradas, pesos) + base si la activación es Ninguna: devolver resultado en caso contrario: devolver activar(resultado) clase BPNeuralNetwork:
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):
self.session.close() define el entrenamiento (self, casos, etiquetas, límite=100, learn_rate=0.05) :
#Construir una red
self . input _layer = TF placeholder(TF . float 32, [Ninguno, 2])
self . _ capa = TF . marcador de posición (TF . float 32, [Ninguno, 1])
self . .relu))
self . reducir _ media(TF . reducir _ suma(TF . cuadrado((self . etiqueta _ capa-self . capas[1])), reducción _ índices =[1]))
self optimizador =. TF. optimizador de gradiente (tasa de aprendizaje). Minimizar (pérdida propia)
initer = TF .inicializar _ todas las variables()#Hacer entrenamiento.
self.session.run(initer) de I dentro del alcance (límite):
self session . run(self . optimizador, feed _ dict = { self . input _ capa: casos, self. label_layer: etiquetas }) def predict(self, case):
return self session. capa: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.train(x_data, y_data)
print(self Prediccion (datos de prueba))
nn = BPNeuralNetwork()
nn test()123456789101121314161718192021222324252628
Aunque el modelo anterior es simple, no es flexible de usar. . El autor utilizó la misma idea para implementar una red con dimensiones de entrada y salida personalizadas y neuronas ocultas multicapa.
Consulte Dynamic_bpnn.py
Importar tensorflow como tfimport numpy como npdef make_layer(inputs, in_size, out_size, enable=None):
peso = tf. variable(tf.random_normal([in_size, out_size])
base = tf. variable(tf.zeros([1, out_size]) + 0.1)
resultado = tf.matmul (entradas, pesos) + base si la activación es Ninguna: devolver resultado en caso contrario: devolver activar(resultado) clase BPNeuralNetwork:
def __init__(self):
self.session = tf. session()
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 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 la capa de entrada ><. p>self . input _ Layer = TF . placeholder(TF . float 32, [none, self. input _ n]) #Construye una capa de etiqueta
self . TF . float 32, [none, self.output_n]) #Crear una capa oculta
in_size = self.input_n
out_size = self.hidden_size[0].
entrada = self.input_layer
self . capas _ ocultas append(make_layer(inputs, in_size, out_size, enable = TF . nn . relu))para I en el rango (self . oculto). _ n-1):
in_size = out_size
out _ size = self oculto _ size[I+1]
entradas = self oculto. capas [-1]
self . capas _ ocultas append(make_layer(inputs, in_size, out_size, enable = tf.nn.relu)) #Construye la capa de salida.
self .output_layer = make _layer(self . capas_ocultas[-1], self.hidden_size[-1], self.output_n) def train(self, casos, etiquetas, límite= 100, learn_rate= 0.05):
self loss = TF . reducir _ media(TF . reducir _ suma(TF . cuadrado((self . etiqueta _ capa-self . salida _ capa)), reducción _ índices =[ 1]))
self . optimizador = TF . Minimizar (pérdida propia)
initer = TF .inicializar _ todas las variables()#Hacer entrenamiento.
self.session.run(initer) de I dentro del alcance (límite):
self session . run(self . optimizador, feed _ dict = { self . input _ capa: casos, self. etiqueta_capa: etiquetas}) def predecir (auto, caso):
return self sesión (auto. salida_capa, feed_dict = {auto. entrada_capa: 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]])
Configuración de autoservicio (2, [10, 5], 1)
self.train(x_data, y_data)
Imprimir(autopredicción(datos de prueba))
nn = BPNeuralNetwork()
nn . () 123456789101121314161718192021222324252628