def testBoston(self):
random.seed(42)
boston = datasets.load_boston()
regressor = skflow.TensorFlowDNNRegressor(
hidden_units=[10, 20, 10], n_classes=0,
batch_size=boston.data.shape[0],
steps=200, learning_rate=0.001)
regressor.fit(boston.data, boston.target)
score = mean_squared_error(
boston.target, regressor.predict(boston.data))
self.assertLess(score, 100, "Failed with score = {0}".format(score))
def testBostonDNN(self):
random.seed(42)
boston = datasets.load_boston()
regressor = skflow.TensorFlowDNNRegressor(
hidden_units=[10, 20, 10],
n_classes=0,
batch_size=boston.data.shape[0],
steps=200,
learning_rate=0.001)
regressor.fit(boston.data, boston.target)
score = mean_squared_error(boston.target,
regressor.predict(boston.data))
self.assertLess(score, 100, "Failed with score = {0}".format(score))
weights = regressor.weights_
self.assertEqual(weights[0].shape, (13, 10))
self.assertEqual(weights[1].shape, (10, 20))
self.assertEqual(weights[2].shape, (20, 10))
self.assertEqual(weights[3].shape, (10, 1))
biases = regressor.bias_
self.assertEqual(len(biases), 4)
# 标准化
ss = preprocessing.StandardScaler()
X_train = ss.fit_transform(X_train)
X_test = ss.transform(X_test)
# 使用skflow的TensorFlowLinearRegressor回归器训练
tf_lr = skflow.TensorFlowLinearRegressor(steps=10000,
learning_rate=0.01,
batch_size=50)
tf_lr.fit(X_train, y_train)
tf_lr_y_predict = tf_lr.predict(X_test)
# 使用skflow的TensorFlowDNNRegressor回归器训练
tf_dnn_regressor = skflow.TensorFlowDNNRegressor(hidden_units=[100, 40],
steps=10000,
learning_rate=0.01,
batch_size=50)
tf_dnn_regressor.fit(X_train, y_train)
tf_dnn_regressor_y_predict = tf_dnn_regressor.predict(X_test)
# 使用skflow的RandomForestRegressor回归器训练
rfr = RandomForestRegressor()
rfr.fit(X_train, y_train)
rfr_y_predict = rfr.predict(X_test)
print 'Boston房价TensorFlowLinearRegressor预测的'
print ' R-squared是：', metrics.r2_score(tf_lr_y_predict, y_test)
print ' 平均绝对误差是：', metrics.mean_absolute_error(tf_lr_y_predict, y_test)
print ' 均方差是：', metrics.mean_squared_error(tf_lr_y_predict, y_test)
print 'Boston房价TensorFlowDNNRegressor预测的'
import cv2
import numpy as np
from random import randrange, randint
from ale_python_interface import ALEInterface
import skflow
import sys
g = 0.9
append = lambda x, y: np.append(x, y)
regressor = skflow.TensorFlowDNNRegressor(hidden_units=[20, 10, 10, 15, 20],
learning_rate=0.01,
verbose=int(sys.argv[2]))
regressor.fit(np.random.randn(1601, 1), append([1.], np.zeros((1600, 1))))
# regressor = skflow.TensorFlowEstimator.restore('./regressor')
def Q(s, a):
return regressor.predict(append(s, a))
def detectState(ale):
return cv2.resize(ale.getScreenGrayscale(), (40, 40))
while True:
ale = ALEInterface()
ale.loadROM("breakout.bin")
actionSet = ale.getMinimalActionSet()
while not ale.game_over():
if sys.argv[1] == 'disp':
cv2.imshow('', cv2.resize(ale.getScreenRGB(), (600, 600)))
cv2.waitKey(1)
import random
from sklearn import datasets, cross_validation, metrics
from sklearn import preprocessing
import skflow
random.seed(42)
# Load dataset
boston = datasets.load_boston()
X, y = boston.data, boston.target
# Scale data to 0 mean and unit std dev.
scaler = preprocessing.StandardScaler()
X = scaler.fit_transform(X)
# Split dataset into train / test
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y,
test_size=0.2, random_state=42)
# Build 2 layer fully connected DNN with 10, 10 units respecitvely.
regressor = skflow.TensorFlowDNNRegressor(hidden_units=[10, 10],
steps=5000, learning_rate=0.1, batch_size=1)
# Fit and predict.
regressor.fit(X_train, y_train)
score = metrics.mean_squared_error(regressor.predict(X_test), y_test)
print('MSE: {0:f}'.format(score))
gray_image = rgb2gray(image).flatten()
flat_image = image.flatten()
if len(flat_image) > len(gray_image):
if color_images == None or gray_images == None:
gray_images = np.array([gray_image])
color_images = np.array([flat_image])
else:
gray_images = np.vstack((gray_images, gray_image))
color_images = np.vstack((color_images, flat_image))
X_train = gray_images[:len(gray_images) / 2]
y_train = color_images[:len(color_images) / 2]
X_test = gray_images[len(gray_images) / 2:]
y_test = color_images[len(color_images) / 2:]
print 'Generating test split'
print 'Starting to train'
classifier = skflow.TensorFlowDNNRegressor(
hidden_units=[1024, 2048, 2048, 3072],
batch_size=128,
verbose=1,
optimizer='SGD',
steps=20000)
classifier.fit(X_train, y_train)
classifier.save('models/skflow_09/')
