Linear Regression
MSE
boston = datasets.load_boston()
x_data = preprocessing.StandardScaler().fit_transform(boston.data)
y_data = boston.target
x = tf.placeholder(tf.float64,shape=(None,13))
y_true = tf.placeholder(tf.float64,shape=(None))
with tf.name_scope('inference') as scope:
w = tf.Variable(tf.zeros([1,13],dtype=tf.float64,name='weights'))
b = tf.Variable(0,dtype=tf.float64,name='bias')
y_pred = tf.matmul(w,tf.transpose(x))+b
with tf.name_scope('loss') as scope:
loss = tf.reduce_mean(tf.square(y_true-y_pred))
with tf.name_scope('train') as scope:
learning_rate = 0.1
optimizer = tf.train.GradientDescentOptimizer(learning_rate)
train = optimizer.minimize(loss)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
for step in range(200):
sess.run(train,{x:x_data,y_true:y_data})
MSE = sess.run(loss,{x:x_data,y_true:y_data})
print(MSE)
Display:
TensorFlow.contrib
NUM_STEPS = 200
MINIBATCH_SIZE = 506
boston = datasets.load_boston()
x_data = preprocessing.StandardScaler().fit_transform(boston.data)
feature_columns = learn.infer_real_valued_columns_from_input(x_data)
reg = learn.LinearRegressor(feature_columns=feature_columns,optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.1))
reg.fit(x_data, boston.target, steps=NUM_STEPS,batch_size=MINIBATCH_SIZE)
MSE = reg.evaluate(x_data, boston.target, steps=1)
print(MSE)
Display:
CNN
DATA_DIR = '/tmp/data' if not 'win32' in sys.platform else "c:\\tmp\\data"
data = input_data.read_data_sets(DATA_DIR, one_hot=False)
x_data, y_data = data.train.images,data.train.labels.astype(np.int32)
x_test, y_test = data.test.images,data.test.labels.astype(np.int32)
NUM_STEPS = 2000
MINIBATCH_SIZE = 128
feature_columns = learn.infer_real_valued_columns_from_input(x_data)
dnn = learn.DNNClassifier(feature_columns=feature_columns,hidden_units=[200],n_classes=10,optimizer=tf.train.ProximalAdagradOptimizer(learning_rate=0.2))
dnn.fit(x=x_data,y=y_data, steps=NUM_STEPS,batch_size=MINIBATCH_SIZE)
test_acc = dnn.evaluate(x=x_test,y=y_test, steps=1)["accuracy"]
print('test accuracy: {}'.format(test_acc))
Display
Confusion matrix
def plot_confusion_matrix(cm, classes,normalize=False,title='Confusion matrix', cmap=plt.cm.Blues):
plt.imshow(cm, interpolation='nearest', cmap=cmap, aspect='auto')
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],horizontalalignment="center",color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.savefig('confusion_mat.png', bbox_inches='tight', format='png', dpi=300, pad_inches=0, transparent=True)
plt.show()
DATA_DIR = '/tmp/data' if not 'win32' in sys.platform else "c:\\tmp\\data"
data = input_data.read_data_sets(DATA_DIR, one_hot=False)
x_data, y_data = data.train.images,data.train.labels.astype(np.int32)
x_test, y_test = data.test.images,data.test.labels.astype(np.int32)
NUM_STEPS = 2000
MINIBATCH_SIZE = 128
feature_columns = learn.infer_real_valued_columns_from_input(x_data)
dnn = learn.DNNClassifier(feature_columns=feature_columns,hidden_units=[200],n_classes=10,optimizer=tf.train.ProximalAdagradOptimizer(learning_rate=0.2))
dnn.fit(x=x_data,y=y_data, steps=NUM_STEPS,batch_size=MINIBATCH_SIZE)
y_pred = dnn.predict(x=x_test,as_iterable=False)
class_names = ['0','1','2','3','4','5','6','7','8','9']
cnf_matrix = confusion_matrix(y_test, y_pred)
plot_confusion_matrix(cnf_matrix, class_names)
Display
FeatureColumn
N = 10000
weight = np.random.randn(N)*5+70
spec_id = np.random.randint(0,3,N)
bias = [0.9,1,1.1]
height = np.array([weight[i]/100 + bias[b] for i,b in enumerate(spec_id)])
spec_name = ['Goblin','Human','ManBears']
spec = [spec_name[s] for s in spec_id]
N = 10000
weight = np.random.randn(N) * 5 + 70
spec_id = np.random.randint(0, 3, N)
bias = [0.9, 1, 1.1]
height = np.array([weight[i] / 100 + bias[b] for i, b in enumerate(spec_id)])
spec_name = ['Goblin', 'Human', 'ManBears']
spec = [spec_name[s] for s in spec_id]
df = pd.DataFrame({'Species':spec,'Weight':weight,'Height':height})
print(df)
colors = ['r', 'b', 'g']
f, axarr = plt.subplots(1, 2, figsize=[7, 3])
ax = axarr[0]
for ii in range(3):
ax.hist(height[spec_id == ii], 50, color=colors[ii], alpha=0.5)
ax.set_xlabel('Height')
ax.set_ylabel('Frequency')
ax.set_title('Heights distribution')
height = height + np.random.randn(N) * 0.015
ax.text(1.42, 150, 'Goblins')
ax.text(1.63, 210, 'Humans')
ax.text(1.85, 150, 'ManBears')
ax.set_ylim([0, 260])
ax.set_xlim([1.38, 2.05])
df = pd.DataFrame({'Species': spec, 'Weight': weight, 'Height': height})
ax = axarr[1]
ax.plot(df['Height'], df['Weight'], 'o', alpha=0.3, mfc='w', mec='b')
ax.set_xlabel('Weight')
ax.set_ylabel('Height')
ax.set_title('Heights vs. Weights')
plt.tight_layout()
plt.savefig('test.png', bbox_inches='tight', format='png', dpi=300)
plt.show()
Display
FeatureEstimate
N = 10000
weight = np.random.randn(N) * 5 + 70
spec_id = np.random.randint(0, 3, N)
bias = [0.9, 1, 1.1]
height = np.array([weight[i] / 100 + bias[b] for i, b in enumerate(spec_id)])
spec_name = ['Goblin', 'Human', 'ManBears']
spec = [spec_name[s] for s in spec_id]
def input_fn(df):
feature_cols = {}
feature_cols['Weight'] = tf.constant(df['Weight'].values)
feature_cols['Species'] = tf.SparseTensor(indices=[[i, 0] for i in range(df['Species'].size)],values=df['Species'].values,dense_shape=[df['Species'].size, 1])
labels = tf.constant(df['Height'].values)
return feature_cols, labels
df = pd.DataFrame({'Species':spec,'Weight':weight,'Height':height})
Weight = layers.real_valued_column("Weight")
Species = layers.sparse_column_with_keys(column_name="Species", keys=['Goblin','Human','ManBears'])
reg = learn.LinearRegressor(feature_columns=[Weight,Species])
reg.fit(input_fn=lambda:input_fn(df), steps=50000)
w_w = reg.get_variable_value('linear/Weight/weight')
print('Estimation for Weight: {}'.format(w_w))
s_w = reg.get_variable_value('linear/Species/weights')
b = reg.get_variable_value('linear/bias_weight')
print('Estimation for Species: {}'.format(s_w + b))
Display
CNN Estimator
def model_fn(x, target, mode, params):
y_ = tf.cast(target, tf.float32)
x_image = tf.reshape(x, [-1, 28, 28, 1])
conv1 = layers.convolution2d(x_image, 32, [5,5],activation_fn=tf.nn.relu,biases_initializer=tf.constant_initializer(0.1),weights_initializer=tf.truncated_normal_initializer(stddev=0.1))
pool1 = layers.max_pool2d(conv1, [2,2])
conv2 = layers.convolution2d(pool1, 64, [5,5],activation_fn=tf.nn.relu,biases_initializer=tf.constant_initializer(0.1),weights_initializer=tf.truncated_normal_initializer(stddev=0.1))
pool2 = layers.max_pool2d(conv2, [2,2])
pool2_flat = tf.reshape(pool2, [-1, 7*7*64])
fc1 = layers.fully_connected(pool2_flat, 1024,activation_fn=tf.nn.relu,biases_initializer=tf.constant_initializer(0.1),weights_initializer=tf.truncated_normal_initializer(stddev=0.1))
fc1_drop = layers.dropout(fc1, keep_prob=params["dropout"],is_training=(mode == 'train'))
y_conv = layers.fully_connected(fc1_drop, 10, activation_fn=None)
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_))
train_op = tf.contrib.layers.optimize_loss(loss=cross_entropy,global_step=tf.contrib.framework.get_global_step(),learning_rate=params["learning_rate"],optimizer="Adam")
predictions = tf.argmax(y_conv, 1)
return predictions, cross_entropy, train_op
DATA_DIR = '/tmp/data' if not 'win32' in sys.platform else "c:\\tmp\\data"
data = input_data.read_data_sets(DATA_DIR, one_hot=True)
x_data, y_data = data.train.images,np.int32(data.train.labels)
tf.cast(x_data,tf.float32)
tf.cast(y_data,tf.float32)
model_params = {"learning_rate": 1e-4, "dropout": 0.5}
CNN = tf.contrib.learn.Estimator(model_fn=model_fn, params=model_params)
print("Starting training for %s steps max" % 5000)
CNN.fit(x=data.train.images,y=data.train.labels, batch_size=50,max_steps=5000)
test_acc = 0
for ii in range(5):
batch = data.test.next_batch(2000)
predictions = list(CNN.predict(batch[0], as_iterable=True))
test_acc = test_acc + (np.argmax(batch[1],1) == predictions).mean()
print(test_acc/5)
Display:
TFLearn
CNN
X, Y, X_test, Y_test = mnist.load_data(one_hot=True)
X = X.reshape([-1, 28, 28, 1])
X_test = X_test.reshape([-1, 28, 28, 1])
CNN = input_data(shape=[None, 28, 28, 1], name='input')
CNN = conv_2d(CNN, 32, 5, activation='relu', regularizer="L2")
CNN = max_pool_2d(CNN, 2)
CNN = local_response_normalization(CNN)
CNN = conv_2d(CNN, 64, 5, activation='relu', regularizer="L2")
CNN = max_pool_2d(CNN, 2)
CNN = local_response_normalization(CNN)
CNN = fully_connected(CNN, 1024, activation=None)
CNN = dropout(CNN, 0.5)
CNN = fully_connected(CNN, 10, activation='softmax')
CNN = regression(CNN, optimizer='adam', learning_rate=0.0001,loss='categorical_crossentropy', name='target')
model = tflearn.DNN(CNN,tensorboard_verbose=0,tensorboard_dir = 'MNIST_tflearn_board/',checkpoint_path = 'MNIST_tflearn_checkpoints/checkpoint')
model.fit({'input': X}, {'target': Y}, n_epoch=3,validation_set=({'input': X_test}, {'target': Y_test}),snapshot_step=1000,show_metric=True, run_id='convnet_mnist')
evaluation = model.evaluate({'input': X_test},{'target': Y_test})
print(evaluation)
pred = model.predict({'input': X_test})
print((np.argmax(testY,1)==np.argmax(pred,1)).mean())
RNN
train, test, _ = imdb.load_data(path='imdb.pkl', n_words=10000,valid_portion=0.1)
X_train, Y_train = train
X_test, Y_test = test
X_train = pad_sequences(X_train, maxlen=100, value=0.)
X_test = pad_sequences(X_test, maxlen=100, value=0.)
Y_train = to_categorical(Y_train, nb_classes=2)
Y_test = to_categorical(Y_test, nb_classes=2)
RNN = tflearn.input_data([None, 100])
RNN = tflearn.embedding(RNN, input_dim=10000, output_dim=128)
RNN = tflearn.lstm(RNN, 128, dropout=0.8)
RNN = tflearn.fully_connected(RNN, 2, activation='softmax')
RNN = tflearn.regression(RNN, optimizer='adam', learning_rate=0.001,loss='categorical_crossentropy')
model = tflearn.DNN(RNN, tensorboard_verbose=0)
model.fit(X_train, Y_train, validation_set=(X_test, Y_test),show_metric=True, batch_size=32)
Keras denoising CIFAR10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train = x_train[np.where(y_train==1)[0],:,:,:]
x_test = x_test[np.where(y_test==1)[0],:,:,:]
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train_n = x_train + 0.5 *np.random.normal(loc=0.0, scale=0.4, size=x_train.shape)
x_test_n = x_test + 0.5 *np.random.normal(loc=0.0, scale=0.4, size=x_test.shape)
x_train_n = np.clip(x_train_n, 0., 1.)
x_test_n = np.clip(x_test_n, 0., 1.)
inp_img = Input(shape=(32, 32, 3))
img= Conv2D(32, (3, 3), activation='relu', padding='same')(inp_img)
img = MaxPooling2D((2, 2), padding='same')(img)
img = Conv2D(32, (3, 3), activation='relu', padding='same')(img)
img = UpSampling2D((2, 2))(img)
decoded = Conv2D(3, (3, 3), activation='sigmoid', padding='same')(img)
autoencoder = Model(inp_img, decoded)
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
tensorboard = TensorBoard(log_dir='./models/autoencoder',histogram_freq=0, write_graph=True, write_images=True)
model_saver = ModelCheckpoint(filepath='./models/autoencoder/autoencoder_model',verbose=0, period=2)
autoencoder.fit(x_train_n, x_train,epochs=10,batch_size=64,shuffle=True,validation_data=(x_test_n, x_test),callbacks=[tensorboard, model_saver])
Display
Keras Plot CIFAR10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train = x_train[np.where(y_train==1)[0],:,:,:]
x_test = x_test[np.where(y_test==1)[0],:,:,:]
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train_n = x_train + 0.5 *np.random.normal(loc=0.0, scale=0.4, size=x_train.shape)
x_test_n = x_test + 0.5 *np.random.normal(loc=0.0, scale=0.4, size=x_test.shape)
x_train_n = np.clip(x_train_n, 0., 1.)
x_test_n = np.clip(x_test_n, 0., 1.)
inp_img = Input(shape=(32, 32, 3))
img= Conv2D(32, (3, 3), activation='relu', padding='same')(inp_img)
img = MaxPooling2D((2, 2), padding='same')(img)
img = Conv2D(32, (3, 3), activation='relu', padding='same')(img)
img = UpSampling2D((2, 2))(img)
decoded = Conv2D(3, (3, 3), activation='sigmoid', padding='same')(img)
autoencoder = Model(inp_img, decoded)
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
tensorboard = TensorBoard(log_dir='./models/autoencoder',histogram_freq=0, write_graph=True, write_images=True)
model_saver = ModelCheckpoint(filepath='./models/autoencoder/autoencoder_model',verbose=0, period=2)
autoencoder.fit(x_train_n, x_train,epochs=10,batch_size=64,shuffle=True,validation_data=(x_test_n, x_test),callbacks=[tensorboard, model_saver])
n_imgs = 10
f, axarr = plt.subplots(2, n_imgs, figsize=[20, 5])
decoded_imgs = autoencoder.predict(x_test_n)
for i in range(n_imgs):
ax = axarr[0, i]
ax.get_yaxis().set_visible(False)
ax.imshow(x_test_n[i, :, :, :])
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
ax = axarr[1, i]
ax.get_yaxis().set_visible(False)
ax.imshow(decoded_imgs[i, :, :, :])
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.tight_layout()
plt.show()
Display