Cacher is the code snippet organizer for pro developers

import tensorflow as tf

sess = tf.Session()
tf.python.control_flow_ops = tf
from keras import backend as K

K.set_session(sess)

from keras.layers import ZeroPadding2D, Activation
from keras.layers.convolutional import Convolution2D, MaxPooling2D, AveragePooling2D
from keras.layers.core import Dense, Flatten
from keras.models import Sequential
from keras.optimizers import SGD
from keras.regularizers import l2
from keras.initializations import normal
from keras.callbacks import LearningRateScheduler
from keras.datasets import cifar10
from keras.utils.np_utils import to_categorical

from functools import partial
from math import floor
import numpy as np


# Helper functions

def schedule(epoch, decay, max_epoch=24):  # Fixed interval lr step function
    interval = max_epoch / decay
    lr = .001 / (10 ** floor(epoch / interval))
    return lr


def LR_scheduler(decay):
    return LearningRateScheduler(partial(schedule, decay=decay))


def gaussian(shape, name=None, scale=.01):
    return normal(shape, scale=scale, name=name)


# Network definition
weight_decay = .004
filter_size = 5
stride = (1, 1)
pool_stride = (2, 2)
pool_size = (3, 3)
padding_size = (2, 2)

nn = Sequential()

nn.add(Convolution2D(32, filter_size, filter_size, dim_ordering='tf', subsample=stride, input_shape=(32, 32, 3),
                     init=partial(gaussian, scale=.0001), W_regularizer=l2(weight_decay)))
nn.add(ZeroPadding2D(padding_size))
nn.add(MaxPooling2D(pool_size=pool_size, strides=pool_stride))
nn.add(Activation('relu'))

nn.add(Convolution2D(32, filter_size, filter_size, dim_ordering='tf', subsample=stride, activation='relu',
                     init=partial(gaussian, scale=.01), W_regularizer=l2(weight_decay)))
nn.add(ZeroPadding2D(padding_size))
nn.add(AveragePooling2D(pool_size=pool_size, strides=pool_stride))

nn.add(Convolution2D(64, filter_size, filter_size, dim_ordering='tf', subsample=stride, activation='relu',
                     init=partial(gaussian, scale=.01), W_regularizer=l2(weight_decay)))
nn.add(ZeroPadding2D(padding_size))
nn.add(AveragePooling2D(pool_size=pool_size, strides=pool_stride))
nn.add(Flatten())

nn.add(Dense(64, activation='linear', init=partial(gaussian, scale=.1), W_regularizer=l2(weight_decay)))
nn.add(Dense(10, activation='softmax', init=partial(gaussian, scale=.1), W_regularizer=l2(weight_decay)))
nn.compile(loss='categorical_crossentropy',
           optimizer=SGD(.001, momentum=.9),
           metrics=['accuracy'])

# Get and format data:
(train, label), (test, test_label) = cifar10.load_data()
label, test_label = to_categorical(label), to_categorical(test_label)

# Mean subtraction
mean = np.mean(train, axis=0).astype(np.float32)
train = train.astype(np.float32) - mean
test = test.astype(np.float32) - mean

# Fit and evaluate network on CIFAR10
lr_sched = LR_scheduler(3)
nn.fit(train, label, validation_data=(test, test_label), nb_epoch=24, batch_size=100, callbacks=[lr_sched])

print("\n", "Final Accuracy:", nn.evaluate(test, test_label)[1])