{
  "fetched_at": "2026-10-20T02:28:37Z",
  "source_url": "https://www.kaggle.com/competitions/application-failure-prediction-part1/data",
  "pages": [
    {
      "name": "data-description",
      "content": "# Training Data\n\nThe training data for this assignment can be found in the file `train_data.csv`. This file contains resource consumption metrics of 20,000 jobs run on one of the HPC clusters at Purdue University. A **job** is typically an execution of a scientific application on the HPC cluster, e.g., training your model with one set of parameters can be considered as a **job**.\n\nThe training data consists of about 8% failure data (this is referred to as the “positive class”). You will build Machine Learning models in Python to predict whether a job will fail or not, given the resource usage data.\n\nThe columns in the data file are:\n\n- **`job_id`**: Unique identifier for a job.\n- **`memory_GB`**: Aggregate memory utilization for a job.\n- **`network_log10_MBps`**: Aggregate network utilization for a job (in logarithmic scale).\n- **`local_IO_log10_MBps`**: Aggregate local disk IO for a job (in logarithmic scale).\n- **`NFS_IO_log10_MBps`**: Aggregate remote filesystem (NFS) IO for a job (in logarithmic scale).\n- **`failed`**: Failure status of a job. A failed job is marked as `1`.\n\n# Test Data\n\nTest data for this competition may be found in the file `test_data_unlabeled.csv`. This file contains resource usage metrics from 10,000 jobs. The columns in the the test data are identical to the training data except for the column `failed`. Your Machine Learning model should predict the value of this column.\n\nThe test data contains about 20% validation data which will be used to determine your ranking in the Public leaderboard. The rest 80% of test data will be used to determine your final score.",
      "isPublished": false,
      "hasIsPublished": false,
      "postTitle": "",
      "hasPostTitle": false,
      "mimeType": "",
      "hasMimeType": false
    },
    {
      "name": "Description",
      "content": "# Challenge 1.1: Computer System Failure Data Analysis (Model Complete)\n\nWith the growing scale of supercomputing systems , scientists are now able to solve challenging computing problems in a matter of seconds which would take hundreds of years on a personal computer. However, with increasing scale (and complexity thereof) grows the probability of application failure, either due to hardware or software errors. Such application failures not only delay scientific progress, but also leads to a tremendous amount of wasted resources, both in terms of time and energy consumption. If we are able to predict when an application would fail due to a system error or due to software bugs, preventive mechanisms such as checkpointing can be initiated to save intermediate results, thereby, reducing the amount of wasted computation.\n\nThis assignment deals with predicting failure of application executions (referred to as “job”) on Purdue ITaP’s central computing cluster. This is data that we have collected, collated, and analyzed as part of two projects from the National Science Foundation (NSF), one completed (“Computer System Failure Data Repository to Enable Data-Driven Dependability Research”, Project No. CNS-1513197) and one ongoing (“Open Computer System Usage Repository and Analytics Engine”, Project No. CNS-2016704). \n\nFor each job, we have data about the resources the job uses and whether the job succeeded or failed. The resources for which we have data are:\n 1.\tMemory\n 2.\tNetwork\n 3.\tLocal IO\n 4.\tNetwork File System (NFS)\n\nWe are releasing the training data from 20,000 jobs, which has about 8% failure data (this is referred to as the “positive class”). You will build Machine Learning models in Python to predict whether a job will fail or not, given the resource usage data. More details about the training and the test data are presented in the \"Data\" section.\n\nThe assignment, including the data, is available at the following Github repo:\nhttps://github.com/bagchi/application-failure-prediction\n\nThere are two parts for this challenge problem with slightly different objectives: \n [Challenge 1.1](https://www.kaggle.com/c/application-failure-prediction-part1/overview) and [Challenge 1.2](https://www.kaggle.com/c/application-failure-prediction-part2/overview). You must complete both parts and **upload your solutions separately**.\n\nYou will do the following steps for this Challenge Problem 1.1:\n 1. You will write code in Python. We have found the following packages to be useful for this task: `pandas`, `sklearn`, `numpy`. \n 2. You will use the training dataset `train_data.csv`.\n 3. You will create a Machine Learning model that achieves the highest **[balanced accuracy](https://www.kaggle.com/c/application-failure-prediction-part1/overview/definitions)**. Use all the features available in the dataset to train your model. We will call this _“Model Complete”_. You can use any algorithm of your choice. \n 4. Give a short writeup explaining:\n    a.\tWhat did you do for the _Model Complete_? Give the confusion matrix and the balanced accuracy that you obtained on the training data.\n    b.\tUpload this writeup. You will upload the writeup to this (as well as integrated with the writeup for Challenge 1.2) to [this Dropbox folder](https://www.dropbox.com/request/f58oGdpPA94cLQUAk7t5).\n 5. Upload your Python code with a `README` that tells us how we can run your code. \n\nAfter completing this assignment, you can proceed to [Challenge 1.2](https://www.kaggle.com/c/application-failure-prediction-part2/overview)\n",
      "isPublished": false,
      "hasIsPublished": false,
      "postTitle": "",
      "hasPostTitle": false,
      "mimeType": "",
      "hasMimeType": false
    },
    {
      "name": "Evaluation",
      "content": "Please note that your overall score for Challenge Problem 1 will be based on both [Challenge 1.1](https://www.kaggle.com/c/application-failure-prediction-part1/overview) and [Challenge 1.2](https://www.kaggle.com/c/application-failure-prediction-part2/overview).\n\nThere are two evaluation components for this challenge. \n\n## Automated evaluation\n\nFor **automated evaluation**, we use balanced accuracy as the evaluation metric for your model. This will be based on the output of `model_complete_test.csv`. The **[balanced accuracy](https://www.kaggle.com/c/application-failure-prediction-part1/overview/definitions)** is computed by assigning equal weight to the positive and the negative class accuracy. Challenge participants are expected to achieve a minimum balanced accuracy of 60%, however, the winning teams will likely have an accuracy of 80% or higher.\n\n## Offline evaluation\n\nWe will also evaluate selected teams based on their final reports and their presentations. This process is offline and may not be reflected on the competition leaderboard immediately. For details please see: https://syp.computer.org/gsc/\n\n## Submission format\n\n- Your code should generate the output file `model_complete_test.csv`This will be used for automated evaluation in Kaggle for Challenge 1.1.\n- The output files must have two columns: \n      - `job_id`: Unique ID for the job.\n      - `failed`: Based on the resource usage metrics, can you predict if the job will fail? A value of `1` indicates failure.\n- You must also submit a report explaining the following:\n      a. What did you do for the _Model Complete_? Give the confusion matrix and the balanced accuracy that you obtained on the training data.\n- Upload your Python code with a README that tells us how we can run your code.",
      "isPublished": false,
      "hasIsPublished": false,
      "postTitle": "",
      "hasPostTitle": false,
      "mimeType": "",
      "hasMimeType": false
    },
    {
      "name": "rules",
      "content": "Teams must register at https://www.computer.org/publications/tech-news/events/global-student-challenge-competition-2021 \n\nFor detailed policies and evaluation steps please check: https://syp.computer.org/gsc/",
      "isPublished": false,
      "hasIsPublished": false,
      "postTitle": "",
      "hasPostTitle": false,
      "mimeType": "",
      "hasMimeType": false
    },
    {
      "name": "Definitions",
      "content": "## Balanced Accuracy\n\nBalanced accuracy is defined as the average of positive class accuracy and the negative class accuracy. Assume your data set has 20 positive samples and 80 negative samples. Your model predicted 23 samples as positive and 77 samples as negative as shown in the confusion matrix below.\n\n|                            | Predicted positive  | Predicted negative | Total |\n|-----------------|--------------------|---------------------|------|\n| Actual positive  |         TP = 15            |          FN = 5            | 20     |\n| Actual negative |         FP = 8              |          TN =72          | 80     |\n| Total                   |             23                |               77              | 100   |\n\nBased on this confusion matrix: \nyour _**positive class accuracy**_ = 15 / (15+5) = 0.75 \nyour _**negative class accuracy**_ = 72 / (72+8) = 0.90\nTherefore, your _**balanced accuracy**_ = (0.75 + 0.90) / 2 = 0.825\n",
      "isPublished": false,
      "hasIsPublished": false,
      "postTitle": "",
      "hasPostTitle": false,
      "mimeType": "",
      "hasMimeType": false
    }
  ]
}