higgs-boson-detection.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.10","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# Model Configuration\nUNITS = 2 ** 11 # 2048\nACTIVATION = 'relu'\nDROPOUT = 0.1\n\n# Training Configuration\nBATCH_SIZE_PER_REPLICA = 2 ** 11 # powers of 128 are best","metadata":{"execution":{"iopub.status.busy":"2022-07-14T13:48:51.834425Z","iopub.execute_input":"2022-07-14T13:48:51.835012Z","iopub.status.idle":"2022-07-14T13:48:51.862689Z","shell.execute_reply.started":"2022-07-14T13:48:51.834875Z","shell.execute_reply":"2022-07-14T13:48:51.862074Z"},"trusted":true},"execution_count":1,"outputs":[]},{"cell_type":"markdown","source":"The next few sections set up the TPU computation, data pipeline, and neural network model. If you'd just like to see the results, feel free to skip to the end!\n\n# Setup #\n\nIn addition to our imports, this section contains some code that will connect our notebook to the TPU and create a **distribution strategy**. Each TPU has eight computational cores acting independently. With a distribution strategy, we define how we want to divide up the work between them.","metadata":{}},{"cell_type":"code","source":"# TensorFlow\nimport tensorflow as tf\nprint(\"Tensorflow version \" + tf.__version__)\n\n# Detect and init the TPU\ntry: # detect TPUs\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect() # TPU detection\n    strategy = tf.distribute.TPUStrategy(tpu)\nexcept ValueError: # detect GPUs\n    strategy = tf.distribute.get_strategy() # default strategy that works on CPU and single GPU\nprint(\"Number of accelerators: \", strategy.num_replicas_in_sync)\n    \n# Plotting\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n# Matplotlib defaults\nplt.style.use('seaborn-whitegrid')\nplt.rc('figure', autolayout=True)\nplt.rc('axes', labelweight='bold', labelsize='large',\n       titleweight='bold', titlesize=18, titlepad=10)\n\n\n# Data\nAUTO = tf.data.experimental.AUTOTUNE\n\n\n# Model\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom tensorflow.keras import callbacks","metadata":{"execution":{"iopub.status.busy":"2022-07-14T13:48:51.863942Z","iopub.execute_input":"2022-07-14T13:48:51.864271Z","iopub.status.idle":"2022-07-14T13:49:04.687760Z","shell.execute_reply.started":"2022-07-14T13:48:51.864244Z","shell.execute_reply":"2022-07-14T13:49:04.687154Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stderr","text":"2022-07-14 13:48:52.652407: W tensorflow/stream_executor/platform/default/dso_loader.cc:60] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /opt/conda/lib\n2022-07-14 13:48:52.652517: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n","output_type":"stream"},{"name":"stdout","text":"Tensorflow version 2.4.1\n","output_type":"stream"},{"name":"stderr","text":"2022-07-14 13:48:58.208973: I tensorflow/compiler/jit/xla_cpu_device.cc:41] Not creating XLA devices, tf_xla_enable_xla_devices not set\n2022-07-14 13:48:58.211736: W tensorflow/stream_executor/platform/default/dso_loader.cc:60] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /opt/conda/lib\n2022-07-14 13:48:58.211777: W tensorflow/stream_executor/cuda/cuda_driver.cc:326] failed call to cuInit: UNKNOWN ERROR (303)\n2022-07-14 13:48:58.211804: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (0baf3be9d8af): /proc/driver/nvidia/version does not exist\n2022-07-14 13:48:58.214623: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\nTo enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n2022-07-14 13:48:58.216609: I tensorflow/compiler/jit/xla_gpu_device.cc:99] Not creating XLA devices, tf_xla_enable_xla_devices not set\n2022-07-14 13:48:58.223495: I tensorflow/compiler/jit/xla_gpu_device.cc:99] Not creating XLA devices, tf_xla_enable_xla_devices not set\n2022-07-14 13:48:58.255886: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:301] Initialize GrpcChannelCache for job worker -> {0 -> 10.0.0.2:8470}\n2022-07-14 13:48:58.255955: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:301] Initialize GrpcChannelCache for job localhost -> {0 -> localhost:30042}\n2022-07-14 13:48:58.274419: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:301] Initialize GrpcChannelCache for job worker -> {0 -> 10.0.0.2:8470}\n2022-07-14 13:48:58.274479: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:301] Initialize GrpcChannelCache for job localhost -> {0 -> localhost:30042}\n2022-07-14 13:48:58.275838: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:411] Started server with target: grpc://localhost:30042\n","output_type":"stream"},{"name":"stdout","text":"Number of accelerators:  8\n","output_type":"stream"}]},{"cell_type":"markdown","source":"Notice that TensorFlow now detects eight accelerators. Using a TPU is a bit like using eight GPUs at once.\n\n# Load Data #\n\nThe dataset has been encoded in a binary file format called *TFRecords*. These two functions will parse the TFRecords and build a TensorFlow `tf.data.Dataset` object that we can use for training.","metadata":{}},{"cell_type":"code","source":"def make_decoder(feature_description):\n    def decoder(example):\n        example = tf.io.parse_single_example(example, feature_description)\n        features = tf.io.parse_tensor(example['features'], tf.float32)\n        features = tf.reshape(features, [28])\n        label = example['label']\n        return features, label\n    return decoder\n\ndef load_dataset(filenames, decoder, ordered=False):\n    AUTO = tf.data.experimental.AUTOTUNE\n    ignore_order = tf.data.Options()\n    if not ordered:\n        ignore_order.experimental_deterministic = False\n    dataset = (\n        tf.data\n        .TFRecordDataset(filenames, num_parallel_reads=AUTO)\n        .with_options(ignore_order)\n        .map(decoder, AUTO)\n    )\n    return dataset","metadata":{"execution":{"iopub.status.busy":"2022-07-14T13:49:04.689204Z","iopub.execute_input":"2022-07-14T13:49:04.689650Z","iopub.status.idle":"2022-07-14T13:49:04.697514Z","shell.execute_reply.started":"2022-07-14T13:49:04.689616Z","shell.execute_reply":"2022-07-14T13:49:04.696633Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"dataset_size = int(11e6)\nvalidation_size = int(5e5)\ntraining_size = dataset_size - validation_size\n\n# For model.fit\nbatch_size = BATCH_SIZE_PER_REPLICA * strategy.num_replicas_in_sync\nsteps_per_epoch = training_size // batch_size\nvalidation_steps = validation_size // batch_size\n\n# For model.compile\nsteps_per_execution = 256","metadata":{"execution":{"iopub.status.busy":"2022-07-14T13:49:04.699247Z","iopub.execute_input":"2022-07-14T13:49:04.699892Z","iopub.status.idle":"2022-07-14T13:49:04.709942Z","shell.execute_reply.started":"2022-07-14T13:49:04.699827Z","shell.execute_reply":"2022-07-14T13:49:04.709294Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"code","source":"feature_description = {\n    'features': tf.io.FixedLenFeature([], tf.string),\n    'label': tf.io.FixedLenFeature([], tf.float32),\n}\ndecoder = make_decoder(feature_description)\n\ndata_dir = '../input/higgs-boson'\ntrain_files = tf.io.gfile.glob(data_dir + '/training' + '/*.tfrecord')\nvalid_files = tf.io.gfile.glob(data_dir + '/validation' + '/*.tfrecord')\n\nds_train = load_dataset(train_files, decoder, ordered=False)\nds_train = (\n    ds_train\n    .cache()\n    .repeat()\n    .shuffle(2 ** 19)\n    .batch(batch_size)\n    .prefetch(AUTO)\n)\n\nds_valid = load_dataset(valid_files, decoder, ordered=False)\nds_valid = (\n    ds_valid\n    .batch(batch_size)\n    .cache()\n    .prefetch(AUTO)\n)","metadata":{"execution":{"iopub.status.busy":"2022-07-14T13:49:04.712722Z","iopub.execute_input":"2022-07-14T13:49:04.713373Z","iopub.status.idle":"2022-07-14T13:49:05.414600Z","shell.execute_reply.started":"2022-07-14T13:49:04.713303Z","shell.execute_reply":"2022-07-14T13:49:05.413833Z"},"trusted":true},"execution_count":5,"outputs":[{"name":"stderr","text":"2022-07-14 13:49:05.091999: I tensorflow/core/platform/cloud/google_auth_provider.cc:180] Attempting an empty bearer token since no token was retrieved from files, and GCE metadata check was skipped.\n2022-07-14 13:49:05.185940: I tensorflow/core/platform/cloud/google_auth_provider.cc:180] Attempting an empty bearer token since no token was retrieved from files, and GCE metadata check was skipped.\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# Model #\n\nNow that the data is ready, let's define the network. We're defining the deep branch of the network using Keras's *Functional API*, which is a bit more flexible that the `Sequential` method we used in the course.\n","metadata":{}},{"cell_type":"code","source":"def dense_block(units, activation, dropout_rate, l1=None, l2=None):\n    def make(inputs):\n        x = layers.Dense(units)(inputs)\n        x = layers.BatchNormalization()(x)\n        x = layers.Activation(activation)(x)\n        x = layers.Dropout(dropout_rate)(x)\n        return x\n    return make\n\nwith strategy.scope():\n    # Wide Network\n    wide = keras.experimental.LinearModel()\n\n    # Deep Network\n    inputs = keras.Input(shape=[28])\n    x = dense_block(UNITS, ACTIVATION, DROPOUT)(inputs)\n    x = dense_block(UNITS, ACTIVATION, DROPOUT)(x)\n    x = dense_block(UNITS, ACTIVATION, DROPOUT)(x)\n    x = dense_block(UNITS, ACTIVATION, DROPOUT)(x)\n    x = dense_block(UNITS, ACTIVATION, DROPOUT)(x)\n    outputs = layers.Dense(1)(x)\n    deep = keras.Model(inputs=inputs, outputs=outputs)\n    \n    # Wide and Deep Network\n    wide_and_deep = keras.experimental.WideDeepModel(\n        linear_model=wide,\n        dnn_model=deep,\n        activation='sigmoid',\n    )\n\nwide_and_deep.compile(\n    loss='binary_crossentropy',\n    optimizer='adam',\n    metrics=['AUC', 'binary_accuracy'],\n    experimental_steps_per_execution=steps_per_execution,\n)","metadata":{"execution":{"iopub.status.busy":"2022-07-14T13:49:05.415595Z","iopub.execute_input":"2022-07-14T13:49:05.415801Z","iopub.status.idle":"2022-07-14T13:49:06.370056Z","shell.execute_reply.started":"2022-07-14T13:49:05.415777Z","shell.execute_reply":"2022-07-14T13:49:06.369419Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"markdown","source":"# Training #\n\nDuring training, we'll use the `EarlyStopping` callback as usual. Notice that we've also defined a **learning rate schedule**. It's been found that gradually decreasing the learning rate over the course of training can improve performance (the weights \"settle in\" to a minimum). This schedule will multiply the learning rate by `0.2` if the validation loss didn't decrease after an epoch.","metadata":{}},{"cell_type":"code","source":"early_stopping = callbacks.EarlyStopping(\n    patience=2,\n    min_delta=0.001,\n    restore_best_weights=True,\n)\n\nlr_schedule = callbacks.ReduceLROnPlateau(\n    patience=0,\n    factor=0.2,\n    min_lr=0.001,\n)","metadata":{"lines_to_next_cell":2,"execution":{"iopub.status.busy":"2022-07-14T13:49:06.371437Z","iopub.execute_input":"2022-07-14T13:49:06.371907Z","iopub.status.idle":"2022-07-14T13:49:06.377062Z","shell.execute_reply.started":"2022-07-14T13:49:06.371867Z","shell.execute_reply":"2022-07-14T13:49:06.376522Z"},"trusted":true},"execution_count":7,"outputs":[]},{"cell_type":"code","source":"history = wide_and_deep.fit(\n    ds_train,\n    validation_data=ds_valid,\n    epochs=50,\n    steps_per_epoch=steps_per_epoch,\n    validation_steps=validation_steps,\n    callbacks=[early_stopping, lr_schedule],\n)","metadata":{"execution":{"iopub.status.busy":"2022-07-14T13:49:06.377810Z","iopub.execute_input":"2022-07-14T13:49:06.378311Z","iopub.status.idle":"2022-07-14T13:59:23.535873Z","shell.execute_reply.started":"2022-07-14T13:49:06.378280Z","shell.execute_reply":"2022-07-14T13:59:23.534971Z"},"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"Epoch 1/50\n640/640 [==============================] - 173s 270ms/step - loss: 0.6090 - auc: 0.7556 - binary_accuracy: 0.6902 - val_loss: 0.6951 - val_auc: 0.6937 - val_binary_accuracy: 0.4888\nEpoch 2/50\n640/640 [==============================] - 28s 43ms/step - loss: 0.4960 - auc: 0.8359 - binary_accuracy: 0.7533 - val_loss: 0.4817 - val_auc: 0.8479 - val_binary_accuracy: 0.7628\nEpoch 3/50\n640/640 [==============================] - 28s 43ms/step - loss: 0.4778 - auc: 0.8492 - binary_accuracy: 0.7652 - val_loss: 0.4737 - val_auc: 0.8524 - val_binary_accuracy: 0.7687\nEpoch 4/50\n640/640 [==============================] - 27s 43ms/step - loss: 0.4692 - auc: 0.8552 - binary_accuracy: 0.7709 - val_loss: 0.4668 - val_auc: 0.8582 - val_binary_accuracy: 0.7727\nEpoch 5/50\n640/640 [==============================] - 27s 43ms/step - loss: 0.4628 - auc: 0.8596 - binary_accuracy: 0.7749 - val_loss: 0.4596 - val_auc: 0.8632 - val_binary_accuracy: 0.7775\nEpoch 6/50\n640/640 [==============================] - 27s 42ms/step - loss: 0.4572 - auc: 0.8634 - binary_accuracy: 0.7785 - val_loss: 0.4533 - val_auc: 0.8667 - val_binary_accuracy: 0.7808\nEpoch 7/50\n640/640 [==============================] - 27s 43ms/step - loss: 0.4524 - auc: 0.8666 - binary_accuracy: 0.7816 - val_loss: 0.4490 - val_auc: 0.8694 - val_binary_accuracy: 0.7832\nEpoch 8/50\n640/640 [==============================] - 27s 42ms/step - loss: 0.4477 - auc: 0.8696 - binary_accuracy: 0.7844 - val_loss: 0.4477 - val_auc: 0.8725 - val_binary_accuracy: 0.7848\nEpoch 9/50\n640/640 [==============================] - 27s 42ms/step - loss: 0.4440 - auc: 0.8720 - binary_accuracy: 0.7869 - val_loss: 0.4431 - val_auc: 0.8741 - val_binary_accuracy: 0.7877\nEpoch 10/50\n640/640 [==============================] - 27s 42ms/step - loss: 0.4401 - auc: 0.8745 - binary_accuracy: 0.7893 - val_loss: 0.4366 - val_auc: 0.8766 - val_binary_accuracy: 0.7909\nEpoch 11/50\n640/640 [==============================] - 29s 45ms/step - loss: 0.4363 - auc: 0.8769 - binary_accuracy: 0.7917 - val_loss: 0.4359 - val_auc: 0.8782 - val_binary_accuracy: 0.7925\nEpoch 12/50\n640/640 [==============================] - 27s 43ms/step - loss: 0.4328 - auc: 0.8790 - binary_accuracy: 0.7940 - val_loss: 0.4327 - val_auc: 0.8797 - val_binary_accuracy: 0.7941\nEpoch 13/50\n640/640 [==============================] - 27s 42ms/step - loss: 0.4297 - auc: 0.8810 - binary_accuracy: 0.7958 - val_loss: 0.4313 - val_auc: 0.8804 - val_binary_accuracy: 0.7950\nEpoch 14/50\n640/640 [==============================] - 28s 44ms/step - loss: 0.4263 - auc: 0.8830 - binary_accuracy: 0.7977 - val_loss: 0.4297 - val_auc: 0.8815 - val_binary_accuracy: 0.7964\nEpoch 15/50\n640/640 [==============================] - 27s 42ms/step - loss: 0.4231 - auc: 0.8849 - binary_accuracy: 0.7998 - val_loss: 0.4267 - val_auc: 0.8829 - val_binary_accuracy: 0.7976\nEpoch 16/50\n640/640 [==============================] - 27s 42ms/step - loss: 0.4197 - auc: 0.8869 - binary_accuracy: 0.8018 - val_loss: 0.4266 - val_auc: 0.8830 - val_binary_accuracy: 0.7979\nEpoch 17/50\n640/640 [==============================] - 27s 43ms/step - loss: 0.4168 - auc: 0.8886 - binary_accuracy: 0.8036 - val_loss: 0.4267 - val_auc: 0.8834 - val_binary_accuracy: 0.7983\n","output_type":"stream"}]},{"cell_type":"code","source":"history_frame = pd.DataFrame(history.history)\nhistory_frame.loc[:, ['loss', 'val_loss']].plot(title='Cross-entropy Loss')\nhistory_frame.loc[:, ['auc', 'val_auc']].plot(title='AUC');","metadata":{"execution":{"iopub.status.busy":"2022-07-14T13:59:23.537293Z","iopub.execute_input":"2022-07-14T13:59:23.537522Z","iopub.status.idle":"2022-07-14T13:59:24.286307Z","shell.execute_reply.started":"2022-07-14T13:59:23.537496Z","shell.execute_reply":"2022-07-14T13:59:24.285344Z"},"trusted":true},"execution_count":9,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]}]}