Cycling Shoes: Wear Prediction Guide With Machine Learning

Have you ever stopped to think that your cycling shoes might be harming your performance without you even realizing it?

Well, invisible wear on the sole can affect performance, comfort, and even your safety during training or racing.

With the help of artificial intelligence, specifically basic machine learning models, it’s now possible to predict when your shoes are about to fail, before it compromises your results. The main benefits? Preventing injuries, increasing equipment durability, and saving on unnecessary replacements.

In this guide, you’ll discover how technology can work to your advantage. We’ll explore practical solutions, easy-to-apply models, and a complete step-by-step guide to analyzing the wear and tear of your cycling shoes based on real-world usage data. Ready to ride smarter?

Why is Cycling Shoe Wear so Important?

It may not seem like it, but the condition of your cycling shoe’s sole directly impacts your performance. When the sole’s stiffness decreases over time, some of the force you apply to the pedal is lost, and this affects your efficiency.

Another important point to consider: uneven wear can alter your pedaling posture, causing compensations in the hip, knee, or ankle. This not only reduces your performance but can lead to pain and injuries, especially during long rides.

It’s also worth noting that prematurely replacing your shoes can generate unnecessary costs. Have you ever thought about replacing an expensive piece of equipment thinking it was at the end of its useful life, when in fact it still had months of use left? Technology can prevent this type of error.

Machine Learning in Wear Prediction

Let’s delve a little deeper into this topic. Machine learning allows you to teach an algorithm to identify patterns in your equipment’s usage data. Instead of guesswork, you can make decisions based on reliable predictions.

You can start with simple models like:

• Linear Regression: ideal for predicting the amount of wear based on variables such as mileage or usage time.
• Decision Trees: useful when you want to consider multiple factors such as soil type, humidity, pedaling style, and others.

These models are simple to train and can yield great results even with limited data.

What Data to Collect?

For the model to work, you need to feed it relevant data. Here are some that make a difference:

• Total distance traveled (km)
• Rider weight
• Frequency of use (days per week)
• Terrain type (road, trail, indoor)
• Weather during training (humid, dry, hot, cold)
• Pedal type (clip-in or platform)
• Brand and model of cycling shoes
• Average time per training session

It’s important to note that the more data you have, the more accurate your prediction model will be.

How a Pipeline Works in scikit-learn

Let’s now explore a basic pipeline with scikit-learn in more detail:

• Data collection: You can use data from Strava, Garmin, TrainingPeaks, or even manual spreadsheets.
• Preprocessing: Normalize the data, remove null values, and transform categorical variables into numeric ones.
• Data splitting: Separate training and testing data (e.g., 80% training, 20% testing).
• Model training: With algorithms like LinearRegression() or DecisionTreeRegressor().
• Performance evaluation: Using metrics like R², MAE (mean absolute error), and RMSE.
• Prediction generation: You input your current data, and the model reports the estimated attrition rate.

Pipeline Example with scikit-learn to Predict Cycling Shoe Wear

Here is a working example that simulates data and applies linear regression:

python

CopyEdit

# 1. Import Libraries

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_absolute_error, r2_score

import matplotlib.pyplot as plt

# 2. Generate Dummy Data

np.random.seed(42)

n = 100

data = pd.DataFrame({

‘km_total’: np.random.randint(500, 10000, size=n),

‘peso_ciclista’: np.random.randint(55, 90, size=n),

‘weekly_use’: np.random.randint(2, 7, size=n),

‘rainy_climate’: np.random.randint(0, 2, size=n),

‘percentage_wear’: np.random.uniform(20, 100, size=n)

})

# 3. Split into X and Y

X = data[[‘total_km’, ‘cyclist_weight’, ‘weekly_use’, ‘rainy_climate’]]

y = data[‘percentage_wear’]

# 4. Split into training and testing

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 5. Train the model

model = LinearRegression()

model.fit(X_train, y_train)

# 6. Predict and Evaluate

y_pred = model.predict(X_test)

print(“Mean Absolute Error:”, mean_absolute_error(y_test, y_pred))

print(“R²:”, r2_score(y_test, y_pred))

# 7. Visualize Results

plt.scatter(y_test, y_pred)

plt.xlabel(“Actual Wear (%)”)

plt.ylabel(“Predicted Wear (%)”)

plt.title(“Cycling Shoe Wear Prediction”)

plt.grid(True)

plt.show()

How to Use

• Copy this code into your Jupyter Notebook or Google Colab.
• Then, replace the simulated data with your own training data, if you have any.
• This will serve as a foundation for expanding with other models such as decision trees, random forests, etc.

Tools and Resources for Monitoring Wear

It’s important to have tools that help you organize and visualize your data. Here are some options:

• Strava: to automatically record workouts.
• Google Sheets + AppSheet: create a smart spreadsheet with alerts.
• Notebooks on Google Colab: ideal for testing models without installing anything.
• Recording apps like Training Peak: useful for structured workouts.

These resources allow you to integrate your workouts with equipment durability monitoring.

Creating Your Custom Alert System

Imagine receiving a simple notification: “You’re 200 km away from the ideal cycling shoe replacement.” This is possible with a basic model plus conditional logic.

Here’s how:

• Use your data in the predictive model.
• Set a wear threshold (e.g., 85%).
• If the model predicts wear above this threshold, trigger an email notification or mobile alert.
• Keep a history to adjust the model over time.

You can automate this with tools like Zapier, IFTTT, or even create an app with Glide or Appgyver.

Unique Tips for Monitoring Your Shoes

• Record each workout with an emoji to identify the weather: you can then cross-reference this with wear and tear.
• Add discreet QR codes to your shoes: scan and manually log each use.
• Use insole sensors: technologies like RunScribe already measure impact and inclination.
• Perform a monthly visual inspection: use a ruler or printed template to measure deformations.
• Compare two pairs simultaneously: with the same ML model, and see which one offers the best value.

Brands and Products that Offer Innovation in Durability

For cyclists who want products with a longer lifespan or more onboard technology, here are some suggestions:

• SIDI Shot 2: carbon sole with excellent resistance and replacement support.
• Shimano RC9: reinforced structure and insole that resists sweat well.
• Fizik Infinito R1: uses materials designed to resist deformation even after long distances.
• Northwave Extreme Pro: lightweight, firm, and durable.
• RunScribe sensor (with adapter): measures impact, angle, and stride wear.

These options are recommended by athletes and tested in long-distance races.

Conclusion: Technology for More Conscious Cycling Shoes

If you’ve made it this far, you’ve realized that it’s possible to use machine learning to predict the wear and tear of your cycling shoes and, therefore, improve your performance, avoid unnecessary expenses, and even prevent injuries.

You’ve seen how to collect simple data, train effective models, use practical tools, and apply tips that few cyclists know. Now it’s your turn to apply this knowledge to your training and routine.

The next step is yours: download the example notebook, record your workouts, try a spreadsheet or app. The difference between cycling well and cycling smart is in the use of data.

Pedal better. Spend less. Predict accurately. Get started today!