🥇 2024 Olympic predictor: powered by PyTorch and W&B

This data app shows the PyTorch model that predicts the total Olympic medal count for each country in the next Olympics. The main components include tensors, model training, and evaluation. The app is an easy way to explore the basics of deep learning using real-world data with PyTorch.

Team

Great Britain

Weights and Biases integration

Scheduling jobs and managing execution of experiments tracking improves the connectivity between the details of the work. Overall, W&B helps improve productivity of deep learning studies, shortening the time required for further model development and improving their quality.

The parameters for tracking are as follows:

The model will train for 100 epochs.

A small learning rate of 0.0001 helps define the step by which the model weights will be adjusted during training.

The batch size is set to 64, which defines the number of training examples passed to the algorithm before updating the internal model weights.

The hidden size of 256 indicates the size of the hidden layers in the model, which could increase the model’s ability to learn complex patterns.

wandb.login # Initialize W&B for logging wandb.init(project="olympic-medal-predictions", config={ "epochs": 100, "learning_rate": 0.0001, "batch_size": 64, "hidden_size": 256, })

This data app uses Olympic data up to the 2016 Rio Olympics. After converting key columns to numerical codes and filling missing values, the data is split into training (pre-2016) and testing (2016). SMOTE is applied to balance the training set by oversampling minority classes.

#Split data and apply SMOTE for class balancing train_data = all_sports[all_sports['Year'] < 2016] # Train on data before 2016 test_data = all_sports[all_sports['Year'] == 2016] # Test on 2016 # Drop rows with empty medals for training and testing train_data = train_data[train_data['Medal'].notna() & (train_data['Medal'] != -1)] test_data = test_data[test_data['Medal'].notna() & (test_data['Medal'] != -1)] X_train = train_data.drop(['Medal', 'Year'], axis=1) y_train = train_data['Medal'].values X_test = test_data.drop(['Medal', 'Year'], axis=1) y_test = test_data['Medal'].values # Apply SMOTE to oversample the minority classes in the training set smote = SMOTE(random_state=42) X_train_resampled, y_train_resampled = smote.fit_resample(X_train, y_train)

The data is being scaled using StandardScaler, and then converted into PyTorch tensors for use in the neural network.

#Feature Scaling and OneHotEncoding scaler = StandardScaler() encoder = OneHotEncoder() X_train_scaled = scaler.fit_transform(X_train_resampled) X_test_scaled = scaler.transform(X_test) # Convert to PyTorch tensors X_train_tensor = torch.tensor(X_train_scaled, dtype=torch.float32) X_test_tensor = torch.tensor(X_test_scaled, dtype=torch.float32) y_train_tensor = torch.tensor(y_train_resampled, dtype=torch.long) y_test_tensor = torch.tensor(y_test, dtype=torch.long)

In the training loop, the model is trained over a specified number of epochs, where the learning rate is dynamically adjusted using a scheduler after each epoch. The training loss and test accuracy are logged to Weights & Biases (W&B) for monitoring and performance evaluation.

#Training loop with learning rate scheduling num_epochs = wandb.config.epochs for epoch in range(num_epochs): model.train() optimizer.zero_grad() outputs = model(X_train_tensor) loss = criterion(outputs, y_train_tensor) loss.backward() optimizer.step() scheduler.step() # Log training loss to W&B wandb.log({"loss": loss.item()}) if (epoch + 1) % 10 == 0: print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}') # Evaluate on the test set every 10 epochs if (epoch + 1) % 10 == 0: model.eval() with torch.no_grad(): test_outputs = model(X_test_tensor) _, predicted = torch.max(test_outputs, 1) test_accuracy = (predicted == y_test_tensor).float().mean().item() # Log test accuracy to W&B wandb.log({"test_accuracy": test_accuracy}) print(f'Test Accuracy at Epoch {epoch + 1}: {test_accuracy:.4f}')

The accuracy of this model is quite low. However, this data app serves as a demonstration of using PyTorch and W&B in Deepnote, so this result will suffice.

The output below shows the medal predictions for the 2024 Olympics, with the total number of medals listed for each country. The data was trained on Olympic Games before 2016 and tested on the Rio 2016 Olympics. The comparison between the actual data and the predicted data generated using PyTorch can be seen. The comparison focuses on the total number of medals won by 20 selected countries, specifically those that historically won the most medals.

Additionally, the graph provides a comparison between the actual number of gold medals won by the selected countries and the predicted numbers.

.css-15w88e5{color:var(--chakra-colors-fg-neutral-primary);font-weight:inherit;letter-spacing:-0.09px;}🥇 2024 Olympic predictor: powered by PyTorch and W&B

Weights and Biases integration

🥇 2024 Olympic predictor: powered by PyTorch and W&B