Derek Murray ya proporcionó una excelente respuesta. Como él dijo, TensorFlow es más de bajo nivel; Básicamente, los ladrillos de Lego que lo ayudan a implementar algoritmos de aprendizaje automático, mientras que scikit-learn le ofrece algoritmos estándar, por ejemplo, algoritmos de clasificación como SVM, bosques aleatorios, regresión logística y muchos, muchos más. TensorFlow realmente brilla si desea implementar algoritmos de aprendizaje profundo, ya que le permite aprovechar las GPU para una capacitación más eficiente.
Para darle una mejor idea, ajustemos un modelo de regresión softmax en el conjunto de datos de Iris a través de scikit-learn:
de sklearn.datasets import load_iris
de sklearn.linear_model import LogisticRegression
importar matplotlib.pyplot como plt
- ¿Cómo se determina la significación estadística para las curvas ROC y los valores de AUC?
- ¿Cuáles son los buenos pesos iniciales en una red neuronal?
- Cómo adaptar el filtrado colaborativo para un sistema de recomendación si solo tiene datos de compra a nivel de pedido y no datos a nivel de usuario
- ¿Cómo afectan los registros duplicados en el conjunto de datos de entrenamiento a un clasificador Naive Bayes?
- ¿Cuáles son las consecuencias y desventajas de usar datos agregados? ¿Cómo podemos combatirlos si no hay datos de nivel granular?
# Cargando datos
iris = load_iris ()
X = iris.data [:, [0, 3]] # longitud del sépalo y ancho del pétalo
y = iris.target
# estandarizar
X [:, 0] = (X [:, 0] – X [:, 0] .mean ()) / X [:, 0] .std ()
X [:, 1] = (X [:, 1] – X [:, 1] .mean ()) / X [:, 1] .std ()
lr = LogisticRegression (pena = ‘l2’,
dual = falso
tol = 0.000001,
C = 10.0,
fit_intercept = True,
intercept_scaling = 1,
class_weight = None,
random_state = 1,
solver = ‘newton-cg’,
max_iter = 100,
multi_class = ‘multinomial’,
detallado = 0,
warm_start = False,
n_jobs = 1)
lr.fit (X, y)
y_pred = lr.predict (X)
print (‘Últimas 3 etiquetas de clase:% s’% y_pred [-3:])
Además, tengo una pequeña función auxiliar para trazar la superficie de decisión 2D:
de mlxtend.evaluate import plot_decision_regions
plot_decision_regions (X, y, clf = lr)
plt.title (‘Regresión Softmax en scikit-learn’)
plt.show ()
Eso fue fácil, ¿verdad? :). Ahora, si queremos ajustar un modelo de regresión de Softmax a través de TensorFlow, sin embargo, primero tenemos que “construir” el algoritmo. Pero realmente suena más complicado de lo que realmente es.
TensorFlow viene con muchas funciones y utilidades de “conveniencia”, por ejemplo, si queremos utilizar un enfoque de optimización de descenso de gradiente, el núcleo o nuestra implementación podrían verse así:
# Construir el gráfico
g = tf.Graph ()
con g.as_default ():
si init_weights:
self._n_classes = np.max (y) + 1
self._n_features = X.shape [1]
tf_weights_, tf_biases_ = self._initialize_weights (
n_features = self._n_features,
n_classes = self._n_classes)
self.cost_ = []
más:
tf_weights_ = tf.Variable (self.weights_)
tf_biases_ = tf.Variable (self.biases_)
# Preparar los datos de entrenamiento
y_enc = self._one_hot (y, self._n_classes)
n_idx = list (rango (y.shape [0]))
tf_X = tf.convert_to_tensor (valor = X, dtype = self.dtype)
tf_y = tf.convert_to_tensor (valor = y_enc, dtype = self.dtype)
tf_idx = tf.placeholder (tf.int32,
forma = [int (y.shape [0] / n_batches)])
X_batch = tf.gather (params = tf_X, indices = tf_idx)
y_batch = tf.gather (params = tf_y, indices = tf_idx)
# Configure el gráfico para minimizar el costo de entropía cruzada
logits = tf.matmul (X_batch, tf_weights_) + tf_biases_
cross_entropy = tf.nn.softmax_cross_entropy_with_logits (logits,
y_batch)
costo = tf.reduce_mean (cross_entropy)
optimizador = tf.train.GradientDescentOptimizer (
learning_rate = self.eta)
train = optimizer.minimize (costo)
# Inicializando las variables
init = tf.initialize_all_variables ()
Y podemos ejecutar el entrenamiento de la siguiente manera:
# Lanzar el gráfico
con tf.Session (graph = g) como sess:
sess.run (init)
self.init_time_ = time ()
para época en rango (self.epochs):
si self.minibatches> 1:
n_idx = np.random.permutation (n_idx)
minis = np.array_split (n_idx, self.minibatches)
costos = []
para idx en minis:
_, c = sess.run ([tren, costo], feed_dict = {tf_idx: idx})
costos.append (c)
Para fines de demostración, he implementado la regresión de Softmax a través de TensorFlow en un estilo orientado a objetos que es algo similar a la implementación de scikit-learn. El ejemplo de código completo se puede encontrar aquí si está interesado: rasbt / mlxtend
de mlxtend.tf_classifier import TfSoftmaxRegression
lr = TfSoftmaxRegression (eta = 0.75,
épocas = 1000,
print_progress = True,
minibatches = 1,
random_seed = 1)
lr.fit (X, y)
Época: 1000/1000 | Costo 0.12
plt.plot (rango (len (lr.cost_)), lr.cost_)
plt.xlabel (‘iteraciones’)
plt.ylabel (‘Costo’)
plt.show ()
de mlxtend.evaluate import plot_decision_regions
plot_decision_regions (X, y, clf = lr)
plt.title (‘Regresión de Softmax vía Descenso de gradiente en TensorFlow’)
plt.show ()
