TensorFlow

sudo apt install python3-pip
pip3 install tensorflow-gpu

if not tf.test.gpu_device_name():
    print('GPU not detected! This could take a while.')
else:
    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))

print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
print(tf.__version__)
tf.test.is_gpu_available(
    cuda_only=True, min_cuda_compute_capability=None
)

import tensorflow as tf
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(linear_model, {x:[1,2,3,4]}))

y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

import tensorflow as tf
with tf.Session() as sess:
    print( sess.run( tf.constant('Hello World!') ) )

import tensorflow as tf

# Output depth
k_output = 64

# Image Properties
image_width = 10
image_height = 10
color_channels = 3

# Convolution filter
filter_size_width = 5
filter_size_height = 5

# Input/Image
input = tf.placeholder(
    tf.float32,
    shape=[None, image_height, image_width, color_channels])

# Weight and bias
weight = tf.Variable(tf.truncated_normal(
    [filter_size_height, filter_size_width, color_channels, k_output]))
bias = tf.Variable(tf.zeros(k_output))

# Apply Convolution
conv_layer = tf.nn.conv2d(input, weight, strides=[1, 2, 2, 1], padding='SAME')
# Add bias
conv_layer = tf.nn.bias_add(conv_layer, bias)
# Apply activation function
conv_layer = tf.nn.relu(conv_layer)

#!/usr/bin/python3
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
import numpy as np

def batches(batch_size, features, labels):
    assert len(features) == len(labels)
    outout_batches= list()
    sample_size= len(features)
    for start_i in range(0, sample_size, batch_size):
        end_i= start_i + batch_size
        batch= [features[start_i:end_i], labels[start_i:end_i]]
        outout_batches.append(batch)
    return outout_batches

def print_epoch_stats(epoch_i, sess, last_features, last_labels):
    """Print cost and validation accuracy of an epoch"""
    current_cost= sess.run( cost,
        feed_dict={features: last_features, labels: last_labels})
    valid_accuracy= sess.run( accuracy,
        feed_dict={features: valid_features, labels: valid_labels})
    print('Epoch: {:<4} - Cost: {:<8.3} Valid Accuracy: {:<5.3}'.format(
        epoch_i, current_cost, valid_accuracy))

n_input= 784  # MNIST data input (img shape: 28*28)
n_classes= 10  # MNIST total classes (0-9 digits)
mnist = input_data.read_data_sets('../../datasets/mnist', one_hot=True) # Import MNIST data

# The features are already scaled and the data is shuffled
train_features=  mnist.train.images
valid_features=  mnist.validation.images
test_features=  mnist.test.images

train_labels=  mnist.train.labels.astype(np.float32)
valid_labels=  mnist.validation.labels.astype(np.float32)
test_labels=  mnist.test.labels.astype(np.float32)

# Features and Labels
features= tf.placeholder(tf.float32, [None, n_input])
labels= tf.placeholder(tf.float32, [None, n_classes])

# Weights & bias
weights= tf.Variable(tf.random_normal([n_input, n_classes]))
bias= tf.Variable(tf.random_normal([n_classes]))

# Logits - xW + b
logits= tf.add(tf.matmul(features, weights), bias)

# Define loss and optimizer
learning_rate= tf.placeholder(tf.float32)
cost= tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
optimizer= tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)

# Calculate accuracy
correct_prediction= tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
accuracy= tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init= tf.global_variables_initializer()
batch_size= 128
epochs= 20
learn_rate= 0.01

train_batches= batches(batch_size, train_features, train_labels)

with tf.Session() as sess:
    sess.run(init)
    for epoch_i in range(epochs): # Training cycle
        for batch_features, batch_labels in train_batches: # Loop over all batches
            train_feed_dict = {
                features: batch_features,
                labels: batch_labels,
                learning_rate: learn_rate}
            sess.run(optimizer, feed_dict=train_feed_dict)
        # Print cost and validation accuracy of an epoch
        print_epoch_stats(epoch_i, sess, batch_features, batch_labels)
    # Calculate accuracy for test dataset
    test_accuracy = sess.run(
        accuracy,
        feed_dict={features: test_features, labels: test_labels})
print('Test Accuracy: {}'.format(test_accuracy))

#!/home/xedu/miniconda3/envs/carnd-term1/bin/python
# Obtain data here:
# http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data
from keras.models import Sequential
from keras.layers import Dense
import numpy
# == Load Dataset
dataset= numpy.loadtxt("pima-indians-diabetes.csv",delimiter=",")
# == Establish X and Y
X,Y= dataset[:,0:8],dataset[:,8]
# == Create Model
model= Sequential()
model.add(Dense(12,input_dim=8, activation='relu'))
model.add(Dense(8,activation='relu'))
model.add(Dense(1,activation='sigmoid'))
# == Compile Model
model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])
# == Fit Model
model.fit(X,Y,nb_epoch=130,batch_size=10) #,validation_split=0.2)
# == Evaluate Model
scores= model.evaluate(X,Y)
print("\nModel Success: %s: %.2f%%" % (model.metrics_names[1],scores[1]*100))

import pickle
import numpy as np
import tensorflow as tf
tf.python.control_flow_ops = tf
# == Imports for Keras
from keras.models import Sequential
from keras.layers.core import Dense, Activation, Flatten, Dropout
from keras.layers.convolutional import Convolution2D
from keras.layers.pooling import MaxPooling2D
from sklearn.preprocessing import LabelBinarizer

# == Data Wrangling
with open('small_train_traffic.p', mode='rb') as f:
    data = pickle.load(f)
X_train, y_train = data['features'], data['labels']
with open('small_test_traffic.p', 'rb') as f:
    data_test = pickle.load(f)
X_test,y_test = data_test['features'], data_test['labels']

# == Build the Final Test Neural Network in Keras
model = Sequential()
model.add(Convolution2D(32, 3, 3, input_shape=(32, 32, 3)))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(.5))
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dense(5))
model.add(Activation('softmax'))

# == Preprocess Data
X_normalized = np.array(X_train / 255.0 - 0.5 )

label_binarizer = LabelBinarizer()
y_one_hot = label_binarizer.fit_transform(y_train)

model.compile('adam', 'categorical_crossentropy', ['accuracy'])
history = model.fit(X_normalized, y_one_hot, nb_epoch=10, validation_split=0.2)

X_normalized_test = np.array(X_test / 255.0 - 0.5 )
y_one_hot_test = label_binarizer.fit_transform(y_test)

print("Testing")
metrics = model.evaluate(X_normalized_test,y_one_hot_test)
for metric_i in range(len(model.metrics_names)):
    metric_name = model.metrics_names[metric_i]
    metric_value = metrics[metric_i]
    print('{}: {}'.format(metric_name, metric_value))