Dependiendo de si la biblioteca / marco utilizado es de muy alto nivel o de muy bajo nivel, el código puede verse diferente.
Por ejemplo, el código keras se ve así:
modelo = secuencial ()
model.add (Conv2D (32, kernel_size = (3, 3),
activación = ‘relu’,
input_shape = input_shape))
model.add (Conv2D (64, (3, 3), activación = ‘relu’))
model.add (MaxPooling2D (pool_size = (2, 2)))
model.add (Dropout (0.25))
model.add (Flatten ())
model.add (Denso (128, activación = ‘relu’))
model.add (Dropout (0.5))
model.add (Denso (num_classes, activación = ‘softmax’))
model.compile (loss = keras.losses.categorical_crossentropy,
optimizador = keras.optimizers.Adadelta (),
métricas = [‘precisión’])
- ¿Cómo se usan las supercomputadoras?
- ¿Qué algoritmo de agrupamiento es capaz de satisfacer las 3 V de Big Data?
- ¿Cómo se puede comenzar una investigación independiente en informática?
- ¿Cómo realizo el análisis de datos / aprendizaje automático en Python?
- ¿Por qué se eligen los símbolos de asterisco y ampersand para trabajar con memoria en lenguajes de programación?
# Entrena al modelo
model.fit (x_train, y_train,
batch_size = batch_size,
épocas = épocas,
detallado = 1,
validation_data = (x_test, y_test))
TensorFlow ya se ve un poco diferente:
def cnn_model_fn (características, etiquetas, modo):
“” “Función de modelo para CNN.” “”
# Capa de entrada
input_layer = tf.reshape (características [“x”], [-1, 28, 28, 1])
# Capa Convolucional # 1
conv1 = tf.layers.conv2d (
entradas = input_layer,
filtros = 32,
kernel_size = [5, 5],
relleno = “mismo”,
activación = tf.nn.relu)
# Pooling Layer # 1
pool1 = tf.layers.max_pooling2d (input = conv1, pool_size = [2, 2], strides = 2)
# Capa convolucional # 2 y Capa de agrupación # 2
conv2 = tf.layers.conv2d (
entradas = pool1,
filtros = 64,
kernel_size = [5, 5],
relleno = “mismo”,
activación = tf.nn.relu)
pool2 = tf.layers.max_pooling2d (entradas = conv2, pool_size = [2, 2], zancadas = 2)
# Capa densa
pool2_flat = tf.reshape (pool2, [-1, 7 * 7 * 64])
denso = tf.layers.dense (entradas = pool2_flat, unidades = 1024, activación = tf.nn.relu)
dropout = tf.layers.dropout (
entradas = denso, tasa = 0.4, entrenamiento = modo == tf.estimator.ModeKeys.TRAIN)
# Logits Layer
logits = tf.layers.dense (entradas = abandono, unidades = 10)
predicciones = {
# Generar predicciones (para modo PREDICT y EVAL)
“clases”: tf.argmax (input = logits, axis = 1),
# Agregue `softmax_tensor` al gráfico. Se utiliza para PREDICT y por el
# `logging_hook`.
“probabilidades”: tf.nn.softmax (logits, name = “softmax_tensor”)
}
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec (mode = mode, predictions = predictions)
# Calcular pérdida (para los modos TRAIN y EVAL)
onehot_labels = tf.one_hot (índices = tf.cast (etiquetas, tf.int32), profundidad = 10)
pérdida = tf.losses.softmax_cross_entropy (
onehot_labels = onehot_labels, logits = logits)
# Configurar el entrenamiento Op (para el modo TRAIN)
if mode == tf.estimator.ModeKeys.TRAIN:
optimizador = tf.train.GradientDescentOptimizer (learning_rate = 0.001)
train_op = optimizer.minimize (
pérdida = pérdida,
global_step = tf.train.get_global_step ())
return tf.estimator.EstimatorSpec (mode = mode, loss = loss, train_op = train_op)
Si sabe algo sobre el aprendizaje automático (solo usé ejemplos de código de red neuronal), este código no se ve muy especial.
Tal vez sea similar a las bases de datos: si no sabe cómo funcionan las bases de datos y qué hacen, las bibliotecas de bases de datos pueden parecer extrañas. Lo mismo es cierto para el código de aprendizaje automático (y para muchas otras bibliotecas). Si sabe (al menos más o menos) cómo funcionan los algoritmos, entonces la mayoría de las bibliotecas son al menos comprensibles.
