Lección novato -PaddlePaddle de inicio rápido

Lección novato -PaddlePaddle de inicio rápido

comando de base PaddlePaddle

de profundidad PaddlePaddle Baidu marco de aprendizaje de código abierto, así como Tensorflow de Google, Facebook y otras profundidad similar de aprendizaje Pytorch marco, en el momento del estudio en profundidad de entrada, aprender y utilizar un marco común que permita la eficiencia del aprendizaje es mucho mayor.

En PaddlePaddle, el objeto se calcula tensor , podemos primero uso PaddlePaddle para calcular un [[1, 1], [1, 1]] * [[1, 1], [1, 1]].

constantes de Cálculo de adición: 1 + 1

biblioteca PaddlePaddle primera importación

import paddle.fluid as fluid

Tensor definir dos constantes x1 y x2, y especificar su forma [2, 2], y cubierto todo el valor de 1 tensor de tipo Int64.

# 定义两个张量
x1 = fluid.layers.fill_constant(shape=[2, 2], value=1, dtype='int64')
x2 = fluid.layers.fill_constant(shape=[2, 2], value=1, dtype='int64')

A continuación, una operación definida, el cálculo es una cantidad de adición de las dos hojas de cálculo anterior, y devuelve un operador de suma. PaddlePaddle ofrece un gran número de operaciones, como la suma y la resta, multiplicación y división, funciones trigonométricas, los lectores pueden encontrar en fluid.layers.

# 将两个张量求和
y1 = fluid.layers.sum(x=[x1, x2])

Entonces crear un intérprete puede utilizarse CPU cálculo en el presente documento especificado o GPU. Utilizado cuando se usa CPUPlace () la CPU, si CUDAPlace () usando la GPU. Después de que el analizador es utilizarlo para calcular por medio, es decir, antes de realizar el cálculo, hay que ejecutar una primera inicialización de parámetros se va a utilizar para programar el analizador porque el analizador sólo puede ejecutar el programa.

# 创建一个使用CPU的解释器
place = fluid.CPUPlace()
exe = fluid.executor.Executor(place)
# 进行参数初始化
exe.run(fluid.default_startup_program())

Por último, realizar cálculos, el programa de valores de los parámetros es el programa principal, no el último paso usando los parámetros de inicialización del programa, el programa predeterminado, un total de dos, a saber default_startup_program () y default_main_program (). Fetch_list valor del parámetro es un valor que se debe ejecutar después de la salida del resolver, tenemos que calcular el valor del resultado de salida después de la adición. Es un tensor última calculada.

# 进行运算，并把y的结果输出
result = exe.run(program=fluid.default_main_program(),
                 fetch_list=[y1])
print(result)

Los resultados de cálculo: [array ([[2, 2], [2, 2]])]

La adición calculado variables: 1 + 1

El cálculo anterior es el tensor de constantes 1 + 1, y el valor constante no puede ser modificado de manera arbitraria, por lo que aquí tenemos que utilizar para escribir un programa variable tensor como un multiplicador, es similar a un marcador de posición, hasta que calcularse, a continuación, para calcular el valor añadido al marcador de posición calculada.

PaddlePaddle bibliotecas numpy importación y bibliotecas.

import paddle.fluid as fluid
import numpy as np

Definir dos tensores, no se especifica y la forma de los valores de tensor después de que se asignan dinámicamente. Éstos son sólo especificar su tipo y nombre, el nombre es la clave de nuestra tarea después.

# 定义两个张量
a = fluid.layers.create_tensor(dtype='int64', name='a')
b = fluid.layers.create_tensor(dtype='int64', name='b')

De la misma manera, la definición de la operación de suma de dos tensor.

# 将两个张量求和
y = fluid.layers.sum(x=[a, b])

Aquí también el uso de la CPU para crear un programa de análisis y parámetros de inicialización.

# 创建一个使用CPU的解释器
place = fluid.CPUPlace()
exe = fluid.executor.Executor(place)
# 进行参数初始化
exe.run(fluid.default_startup_program())

A continuación, el uso numpy crear dos tensor de valor, entonces tenemos que calcular es que estos dos valores.

# 定义两个要计算的变量
a1 = np.array([3, 2]).astype('int64')
b1 = np.array([1, 1]).astype('int64')

El parámetro exe.run () poco diferente, uno más parámetros de alimentación, esto es para asignar valores a las variables de tensor. La asignación es utilizar los pares de valores clave de formato, las variables clave definición del tensor se especifican nombre, el valor es el valor a transmitir. En el parámetro fetch_list, el valor deseado I a, b, y se emiten a, por lo que el uso de tres variables para aceptar el valor de retorno.

# 进行运算，并把y的结果输出
out_a, out_b, result = exe.run(program=fluid.default_main_program(),
                               feed={'a': a1, 'b': b1},
                               fetch_list=[a, b, y])
print(out_a, " + ", out_b," = ", result)

Los resultados de cálculo: [32] + [11] = [43]

Uso PaddlePaddle hacer regresión lineal

En la enseñanza superior, enseña a aprender a hacerlo operadores aritméticos básicos con PaddlePaddle, la siguiente información le enseñará cómo utilizar PaddlePaddle hacer una simple regresión lineal, a partir de la definición de una red de datos de uso personalizados para la formación, la verificación final de nuestra red poder predictivo.

bibliotecas PaddlePaddle importación primeros y alguna biblioteca de herramientas.

import paddle.fluid as fluid
import paddle
import numpy as np

Definir una red lineal simple, esta red es muy simple, la estructura es: capa de salida - capa oculta >> - >> __ capa de salida, la capa de red es un total de 2, debido a que el número de entrada de capas no es la capa de red. Más específicamente, un tamaño es 100, la función de activación relu está completamente conectado capas, y una salida conectada al tamaño completo de la capa 1, así construido una red muy simple. Como se usa en el presente documento, fluid.layers.data de entrada () definido en la capa de entrada fluid.layers.create_tensor similar (), también es un atributo de nombre, entonces los datos se llena de acuerdo con este atributo. Forma definida aquí como la capa de entrada 13, ya que cada una de las velocidades de datos Boston conjunto de datos de atributos 13, los datos listos entonces también para cumplir con esta dimensión.

# 定义一个简单的线性网络
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
hidden = fluid.layers.fc(input=x, size=100, act='relu')
net = fluid.layers.fc(input=hidden, size=1, act=None)

función de pérdida se define entonces la red neural, aquí también utiliza fluid.layers.data () de esta interfaz, estos datos puede entenderse como correspondiente a un resultado de lo anterior es fluid.layers.data nombre x () como datos de atributos. Tal como se usa en el presente documento, la diferencia al cuadrado entre la función de pérdida (square_error_cost), interfaz PaddlePaddle proporciona gran parte función de pérdida, como la función de pérdida de entropía cruzada (cross_entropy). Debido a que este proyecto es una tarea de regresión lineal, por lo que utilizar la función de pérdida diferencia al cuadrado. Debido fluid.layers.square_error_cost () está buscando un lote de pérdida de valor, por lo que tenemos que encontrarle un valor medio.

# 定义损失函数
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
cost = fluid.layers.square_error_cost(input=net, label=y)
avg_cost = fluid.layers.mean(cost)

Después de definición de la función de pérdida, un programa puede ser clonado en el programa principal (fluid.default_main_program) como un programa de predicción para predecir el uso de los datos de predicción después de completar el programa de entrenamiento. Esta definición de la orden no puede estar equivocado, porque se define la estructura de la red, pérdida de la función, y por lo tanto son más PaddlePaddle fin de grabar el programa principal. El programa principal define un modelo de red neuronal, el cálculo hacia adelante inversa, así como la actualización del algoritmo de optimización de la red puede aprender parámetros, es el núcleo de todo nuestro programa, esto es PaddlePaddle nos ha ayudado a lograr, y que sólo tiene que centrarse en la construcción de una red de y la formación puede ser.

# 复制一个主程序，方便之后使用
test_program = fluid.default_main_program().clone(for_test=True)

Seguido por la formación definida método de optimización usa en este documento es gradiente estocástico método de optimización descenso. PaddlePaddle ofrece una serie de interfaz de la función de optimización, además de descenso de gradiente estocástico (SGD), así como el impulso, Adagrad, Adagrad así sucesivamente. El proyecto utilizado, los lectores pueden exigir más de sus propios proyectos utilizando diferentes métodos de optimización.

# 定义优化方法
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01)
opts = optimizer.minimize(avg_cost)

A continuación, crear un programa de análisis, también utilizamos la CPU para la formación. Después de crear un programa de análisis utilizando analizador para realizar parámetros de inicialización fluid.default_startup_program ().

# 创建一个使用CPU的解释器
place = fluid.CPUPlace()
exe = fluid.Executor(place)
# 进行参数初始化
exe.run(fluid.default_startup_program())

Definimos un conjunto de datos utilizando numpy, cada uno de los datos del conjunto 13 de datos, esto es porque cuando definimos capa de red de entrada, una forma de 13, pero al final de cada de datos de 12 datos no tiene sentido, porque yo uso son todos 0 a llenar, simplemente para ajustarse al formato de sólo datos. Este conjunto de datos se encuentra en la línea y = 2 * x + 1, pero el programa no se conoce, se utiliza este conjunto de datos después de la formación, para ver si una red neuronal de gran alcance puede ser entrenado para ajustar el modelo de una función. Por último, la definición de un conjunto de datos de predicción, es en la formación de completa, empleando estos datos como entrada X para ver si el valor correcto puede predecir resultados similares.

# 定义训练和测试数据
x_data = np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
                   [2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
                   [3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
                   [4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
                   [5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]).astype('float32')
y_data = np.array([[3.0], [5.0], [7.0], [9.0], [11.0]]).astype('float32')
test_data = np.array([[6.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]).astype('float32')

Después de definir los datos, podemos utilizar los datos para el entrenamiento. Esta vez hemos entrenado 10 pase, el lector puede configurarse rondas más entrenamiento de acuerdo a la situación, más el número de entrenamiento En términos generales, mejor será el modelo de convergencia. Profram mismo tiempo estamos utilizando el fluid.default_main_program (), alimentación está en los datos de entrenamiento en fluid.layers.data () variable definida, y la clave para la clave de uso es fluid.layers. valor de nombre () de los datos. Dejamos que el valor de la avg_cost salida del proceso de formación.

Durante el entrenamiento, podemos ver que la pérdida de valor de la producción se reduce constantemente, probar nuestro modelo sigue a converger.

# 开始训练10个passfor pass_id in range(10):
    train_cost = exe.run(program=fluid.default_main_program(),
                         feed={'x': x_data, 'y': y_data},
                         fetch_list=[avg_cost])
    print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0]))

Una vez finalizada la formación, utilizamos lo anterior clonación programa principal programa de predicción para obtener una predicción de los datos que acabamos de definir. Los mismos datos de previsión de entrada x como en la alimentación, en la predicción, en teoría, no entran y, pero para que coincida con el formato de entrada, que simulan un valor de datos de y, este valor no afecta a nuestras predicciones. Fetch_list valor, es decir, después de la aplicación de los resultados que prevé una salida, esta es la última capa de la red, en lugar de la función de pérdida promedio (avg_cost), porque queremos predecir el pronóstico de la salida del programa. De acuerdo con nuestros datos de definición de arriba, los satisface de abogados y = 2 * x + 1, cuando la x es 6, y debe haber 13 cuando el resultado es la salida final debe estar cerca de 13.

# 开始预测
result = exe.run(program=test_program,
                 feed={'x': test_data, 'y': np.array([[0.0]]).astype('float32')},
                 fetch_list=[net])
print("当x为6.0时，y为：%0.5f" % result[0][0][0])

Predicción: cuando x es 6,0, y es: 13,23625