# Install your backend

pip install tensorflow==1.8.0 

# (or tensorflow-gpu==1.8.0 or theano, or cntk...)


# Install keras

pip install keras==2.2.0

y = df2["Target"]
X = df2[features]
dt = DecisionTreeClassifier(min_samples_split=20, random_state=99)
dt.fit(X, y)

# Tensorflow Estimator High Level API
model = tf.estimator.Estimator(model_fn)

# Define the input function for training
input_fn = tf.estimator.inputs.numpy_input_fn(
                x={'images': mnist.train.images}, 
                y=mnist.train.labels,
                batch_size=batch_size, num_epochs=None, shuffle=True)

# Train the Model - Here you see that we wrap functions to objects....
model.train(input_fn, steps=num_steps)

# Evaluate the Model

# Define the input function for evaluating
input_fn = tf.estimator.inputs.numpy_input_fn(
                x={'images': mnist.test.images}, 
                y=mnist.test.labels,
                batch_size=batch_size, shuffle=False)

# Use the Estimator 'evaluate' method
e = model.evaluate(input_fn)

# Keras

model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
                    validation_data=(x_test,
                                     y_test),
                    epochs=10, 
                    verbose=1,
                    workers=4,
                    callbacks=[TerminateOnNaN()])

# Calculate crossentropy

tf.nn.softmax_cross_entropy_with_logits(
    labels=None, 
    logits=None, # WTF is a logit ?
    dim=-1,      # EVERYBODY IS USING AXIS
    name=None)


# Calculate mean of tensor

tf.reduce_mean(      # Ok why not just mean ? 
    input_tensor,
    axis=None,
    keepdims=None, 
    name=None,
    reduction_indices=None,# Axis & Reduction indices -> one of them is deprecated...
    keep_dims=None) # Two keep_dims -> One of them is deprecated...

# have you heard of **kwargs ?

|_ dataset
    |_ train
        |_ cats
            |_ cats_01.jpg
        |_ dogs
            |_ cats_01.jpg
    |_ test
        |_ cats
            |_ cats_01.jpg
        |_ dogs
            |_ cats_01.jpg

from keras.preprocessing.image import ImageDataGenerator

# Define a data generator with augmentation for train
train_data_generator = ImageDataGenerator(
    rotation_range=90.,
    zoom_range=0.1,
    channel_shift_range=0.1,
    fill_mode='nearest',
    horizontal_flip=True,
    vertical_flip=True,
    rescale=1. / 255.,
)

# Get a generator w/ augmented Data
train_generator = train_data_generator.flow_from_directory(
    TRAIN_DIR,
    target_size=input_shape[:2],
    batch_size=batch_size,
    class_mode='categorical',
    shuffle=True,
    seed=2018)

def my_first_model(input_shape, num_classes):
    # We use Sequential API to build this model

    model = Sequential()

    # Feature extractor 
    model.add(Conv2D(32, (3, 3), padding="same", 
            input_shape=input_shape))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))

    model.add(Conv2D(32, (3, 3), padding="same"))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))

    (...)

    # Feature bottleneck
    model.add(Flatten())

    # Classifier part
    model.add(Dense(64))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(num_classes))
    model.add(Activation('softmax'))

    return model


model = my_first_model(input_shape, num_classes)

from keras.optimizers import SGD

optimizer = SGD(lr=learning_rate, momentum=0.9, nesterov=True)

model.compile(
    loss='categorical_crossentropy',
    optimizer=optimizer,
    metrics=['categorical_accuracy'])

model.fit_generator(
    train_generator,
    steps_per_epoch=train_samples // batch_size,
    epochs=max_epochs,
    validation_data=valid_generator,
    validation_steps=valid_samples // batch_size,
    verbose=2)

# Generate predictions for the test set
y_pred, y_true = predict_generator_with_y_true(
    model, test_generator, steps=len(test_generator))


# Go to sklearn. Seemless due to the closeness of the API

from sklearn.metrics import precision_recall_curve
from sklearn.metrics import average_precision_score

for i in range(num_classes):
    precision[i], recall[i], _ = 
                    precision_recall_curve(
                               y_true[:, i], 
                               y_pred[:, i])
    average_precision[i] = average_precision_score \
        (y_true[:, i], y_pred[:, i])

class Sequence(object):

    def __getitem__(self, index):
        """Gets batch at position `index`.

        # Returns
            A batch
        """

    def __len__(self):
        """
        # Returns
            The number of batches in the Sequence.
        """

    def on_epoch_end(self):
        """Method called at the end of every epoch.
        """
        pass

from keras.applications import VGG16

def finetuning(input_shape, num_classes):
    feature_extractor = VGG16(include_top=False, 
        input_shape=input_shape)
    
    inputs = Input(input_shape)

    # Feature extraction with VGG16 trained on ImageNet
    x = feature_extractor(inputs)

    # Classifier
    x = Flatten()(x)
    x = Dense(512)(x)
    x = Activation("relu")(x)
    x = Dropout(0.5)(x)
    x = Dense(num_classes)(x)
    outputs = Activation("softmax")(x)
    
    model = Model(inputs=inputs, outputs=outputs)

    return model

model = finetuning(input_shape, num_classes)

class Callback(object):
    def __init__(self):
        pass

    def set_params(self, params):
        self.params = params

    def set_model(self, model):
        self.model = model

    def on_epoch_begin(self, epoch, logs=None):
        pass

    def on_epoch_end(self, epoch, logs=None):
        pass

    def on_batch_begin(self, batch, logs=None):
        pass

    def on_batch_end(self, batch, logs=None):
        pass

    def on_train_begin(self, logs=None):
        pass

    def on_train_end(self, logs=None):
        pass

class DiceLoss(object):
    def __init__(self, smooth=1.):
        self.smooth = smooth

    def __call__(self, y_true, y_pred):
        smooth = K.epsilon()

        # Sum over the pixels
        union = K.sum(y_pred + y_true, axis=(1, 2))
        intersection = K.sum(y_pred * y_true, axis=(1, 2))

        # Per sample per class IoU
        iou = (2 * intersection + smooth) / (union + smooth)

        iou = smooth * (1. - iou)  

        return iou

class BinaryAccuracy(object):
    def __init__(self):
        pass

    def __call__(y_true, y_pred):
        accuracy = K.equal(y_true, K.round(y_pred)
        return K.mean(accuracy)

class BinaryTruePositives(Layer):
    def __init__(self):
        self.stateful = True
        self.true_positives = 0

    def __call__(y_true, y_pred):
        y_pred = K.round(y_pred)
        correct_preds = K.equal(y_pred, y_true)
        true_pos = K.sum(correct_preds * y_true)

        current_true_pos = self.true_positives * 1

        self.add_update(K.update_add(self.true_positives,
                                     true_pos),
                        inputs=[y_true, y_pred])

        return current_true_pos + true_pos

class BilinearUpSampling2D(Layer):
    def __init__(self, size=(2, 2)):
        super(BilinearUpSampling2D, self).__init__()
        self.size = size
        # + Some params

    def compute_output_shape(self, input_shape):
        # Basically returns 2x input shape

    def call(self, inputs, **kwargs):
        # Call a TF ops
        return tf.image.resize_images_bilinear
                        (inputs, 
                         self.size[0], 
                         self.size[1],
                         self.data_format)

    def get_config(self):
        # Serialize Layer

pip install tensorflow-gpu==1.9.0rc1

import tensorflow as tf
from tensorflow import keras

def parse_function(filename, label):
    image_string = tf.read_file(filename)

    # Don't use tf.image.decode_image, or the output shape will be undefined
    image = tf.image.decode_jpeg(image_string, channels=3)

    # This will convert to float values in [0, 1]
    image = tf.image.convert_image_dtype(image, tf.float32)

    return image, label

def train_preprocess(image, label):
    # Image data augmentation coded with tf.image.random*
    return image, label

# Let train_images, train_labels the list of image filename and label

train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_labels))
train_dataset = train_dataset.shuffle(len(train_images))
train_dataset = train_dataset.map(parse_function, num_parallel_calls=4)
train_dataset = train_dataset.map(train_preprocess, num_parallel_calls=4)
train_dataset = train_dataset.batch(batch_size)
train_dataset = train_dataset.prefetch(1)
train_dataset = train_dataset.repeat()

def input_fn():
    return train_dataset

estimator = keras.estimator.model_to_estimator(model)

estimator.train(input_fn=input_fn)

INFO:tensorflow:loss = 0.80180705, step = 1
INFO:tensorflow:global_step/sec: 211.485
INFO:tensorflow:global_step/sec: 161.321
INFO:tensorflow:loss = 1.25377, step = 201 (1.093 sec)
INFO:tensorflow:global_step/sec: 319.681
INFO:tensorflow:global_step/sec: 320.532
INFO:tensorflow:loss = 0.71999, step = 401 (0.625 sec)
INFO:tensorflow:global_step/sec: 317.201
INFO:tensorflow:global_step/sec: 319.046
INFO:tensorflow:loss = 1.009802, step = 601 (0.629 sec)