TensorFlow中的Scikit Flow_scikit-tensor和tensorflow

import random
import pandas
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.utils import check_array
from sklearn.cross_validation import train_test_split
 
import tensorflow as tf
 
import skflow
 
train = pandas.read_csv('data/titanic_train.csv')
y, X = train['Survived'], train[['Age', 'SibSp', 'Fare']].fillna(0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
lr = LogisticRegression()
lr.fit(X_train, y_train)
print accuracy_score(lr.predict(X_test), y_test)
 
 
# Linear classifier.
 
random.seed(42)
tflr = skflow.TensorFlowLinearClassifier(n_classes=2, batch_size=128,
                                         steps=500, learning_rate=0.05)
tflr.fit(X_train, y_train)
print accuracy_score(tflr.predict(X_test), y_test)
 
# 3 layer neural network with rectified linear activation.
 
random.seed(42)
classifier = skflow.TensorFlowDNNClassifier(hidden_units=[10, 20, 10],
    n_classes=2, batch_size=128, steps=500, learning_rate=0.05)
classifier.fit(X_train, y_train)
print accuracy_score(classifier.predict(X_test), y_test)
 
# 3 layer neural network with hyperbolic tangent activation.
 
def dnn_tanh(X, y):
    layers = skflow.ops.dnn(X, [10, 20, 10], tf.tanh)
    return skflow.models.logistic_regression(layers, y)
 
random.seed(42)
classifier = skflow.TensorFlowEstimator(model_fn=dnn_tanh,
    n_classes=2, batch_size=128, steps=500, learning_rate=0.05)
classifier.fit(X_train, y_train)
print accuracy_score(classifier.predict(X_test), y_test)

>>> classifier = skflow.TensorFlowDNNClassifier(
...     hidden_units=[10, 20, 10],
...     n_classes=2,
...     batch_size=128,
...     steps=500,
...     learning_rate=0.05)
>>> classifier.fit(X_train, y_train)
>>> score = accuracy_score(classifier.predict(X_test), y_test)
>>> print("Accuracy: %f" % score)
Accuracy: 0.67597765363

>>> def dnn_tanh(X, y):
...    layers = skflow.ops.dnn(X, [10, 20, 10], tf.tanh)
...    return skflow.ops.logistic_classifier(layers, y)
 
>>> classifier = skflow.TensorFlowEstimator(
...     model_fn=dnn_tanh,
...     n_classes=2,
...     batch_size=128,
...     steps=500,
...     learning_rate=0.05)
>>> classifier.fit(X_train, y_train)
>>> score = accuracy_score(classifier.predict(X_test), y_test)
>>> print("Accuracy: %f" % score)
Accuracy: 0.692737430168

import random
from sklearn import datasets, cross_validation, metrics
import tensorflow as tf
 
import skflow
 
random.seed(42)
 
# Load dataset and split it into train / test subsets.
 
digits = datasets.load_digits()
X = digits.images
y = digits.target
 
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y,
    test_size=0.2, random_state=42)
 
# TensorFlow model using Scikit Flow ops
 
def conv_model(X, y):
    X = tf.expand_dims(X, 3)
    features = tf.reduce_max(skflow.ops.conv2d(X, 12, [3, 3]), [1, 2])
    features = tf.reshape(features, [-1, 12])
    return skflow.models.logistic_regression(features, y)
 
# Create a classifier, train and predict.
classifier = skflow.TensorFlowEstimator(model_fn=conv_model, n_classes=10,
                                        steps=500, learning_rate=0.05,
                                        batch_size=128)
classifier.fit(X_train, y_train)
score = metrics.accuracy_score(classifier.predict(X_test), y_test)
print('Accuracy: %f' % score)

import tensorflow as tf
 
a = tf.placeholder("float") # Create a symbolic variable 'a'
b = tf.placeholder("float") # Create a symbolic variable 'b'
 
y = tf.mul(a, b) # multiply the symbolic variables
 
sess = tf.Session() # create a session to evaluate the symbolic expressions
 
print "%f should equal 2.0" % sess.run(y, feed_dict={a: 1, b: 2}) # eval expressions with parameters for a and b
print "%f should equal 9.0" % sess.run(y, feed_dict={a: 3, b: 3})

import tensorflow as tf
import numpy as np
 
trX = np.linspace(-1, 1, 101)
trY = 2 * trX + np.random.randn(*trX.shape) * 0.33 # create a y value which is approximately linear but with some random noise
 
X = tf.placeholder("float") # create symbolic variables
Y = tf.placeholder("float")
 
 
def model(X, w):
    return tf.mul(X, w) # lr is just X*w so this model line is pretty simple
 
 
w = tf.Variable(0.0, name="weights") # create a shared variable (like theano.shared) for the weight matrix
y_model = model(X, w)
 
cost = (tf.pow(Y-y_model, 2)) # use sqr error for cost function
 
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost) # construct an optimizer to minimize cost and fit line to my data
 
sess = tf.Session()
init = tf.initialize_all_variables() # you need to initialize variables (in this case just variable W)
sess.run(init)
 
for i in range(100):
    for (x, y) in zip(trX, trY):
        sess.run(train_op, feed_dict={X: x, Y: y})
 
print(sess.run(w))  # something around 2

import tensorflow as tf
import numpy as np
import input_data
 
 
def init_weights(shape):
    return tf.Variable(tf.random_normal(shape, stddev=0.01))
 
 
def model(X, w):
    return tf.matmul(X, w) # notice we use the same model as linear regression, this is because there is a baked in cost function which performs softmax and cross entropy
 
 
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels
 
X = tf.placeholder("float", [None, 784]) # create symbolic variables
Y = tf.placeholder("float", [None, 10])
 
w = init_weights([784, 10]) # like in linear regression, we need a shared variable weight matrix for logistic regression
 
py_x = model(X, w)
 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(py_x, Y)) # compute mean cross entropy (softmax is applied internally)
train_op = tf.train.GradientDescentOptimizer(0.05).minimize(cost) # construct optimizer
predict_op = tf.argmax(py_x, 1) # at predict time, evaluate the argmax of the logistic regression
 
sess = tf.Session()
init = tf.initialize_all_variables()
sess.run(init)
 
for i in range(100):
    for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)):
        sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end]})
    print i, np.mean(np.argmax(teY, axis=1) ==
                     sess.run(predict_op, feed_dict={X: teX, Y: teY}))

   在线教程

• 麻省理工学院人工智能视频教程 – 麻省理工人工智能课程
• 人工智能入门 – 人工智能基础学习。Peter Norvig举办的课程
• EdX 人工智能 – 此课程讲授人工智能计算机系统设计的基本概念和技术。
• 人工智能中的计划 – 计划是人工智能系统的基础部分之一。在这个课程中，你将会学习到让机器人执行一系列动作所需要的基本算法。
• 机器人人工智能 – 这个课程将会教授你实现人工智能的基本方法，包括：概率推算，计划和搜索，本地化，跟踪和控制，全部都是围绕有关机器人设计。
• 机器学习 – 有指导和无指导情况下的基本机器学习算法
• 机器学习中的神经网络 – 智能神经网络上的算法和实践经验
• 斯坦福统计学习

有需要的小伙伴，可以点击下方链接免费领取或者V扫描下方二维码免费领取