How Telecom Companies Use Deep Learning to Grow Faster

# Predict network traffic with LSTM
import numpy as np
import tensorflow as tf

# X shape: (samples, time_steps, features)
# e.g. 24h of hourly traffic on 50 towers
model = tf.keras.Sequential([
    tf.keras.layers.LSTM(64, return_sequences=True, input_shape=(24, 50)),
    tf.keras.layers.LSTM(32),
    tf.keras.layers.Dense(24),  # predict next 24 hours
])

model.compile(optimizer='adam', loss='mse')
model.fit(X_train, y_train, epochs=20, validation_split=0.2)

# Detect network faults with an autoencoder
import numpy as np
import tensorflow as tf

# Input: normalised telemetry features per tower
input_dim = 20

encoder = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation='relu', input_shape=(input_dim,)),
    tf.keras.layers.Dense(8, activation='relu'),
])

decoder = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(input_dim, activation='sigmoid'),
])

autoencoder = tf.keras.Sequential([encoder, decoder])
autoencoder.compile(optimizer='adam', loss='mse')

# Train on normal data only
autoencoder.fit(normal_data, normal_data, epochs=50)

# At inference: high reconstruction error = anomaly
reconstruction_error = np.mean(
    (autoencoder.predict(new_data) - new_data) ** 2, axis=1
)
anomalies = reconstruction_error > THRESHOLD

# Churn prediction with a neural network
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(n_features,)),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid'),
])

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['AUC', 'Precision', 'Recall'],
)

model.fit(
    X_train, y_train,
    epochs=30,
    class_weight={0: 1, 1: 5},  # churn is rare but costly
    validation_split=0.2,
)

# Explain churn predictions for retention team
import shap

explainer = shap.DeepExplainer(model, X_train[:100])
shap_values = explainer.shap_values(X_test[:100])

# For each high-risk customer, show top reasons
for i, customer in enumerate(high_risk_customers[:5]):
    reasons = shap_values[i]
    top_features = sorted(
        zip(feature_names, reasons),
        key=lambda x: abs(x[1]),
        reverse=True,
    )[:3]
    print(f"Customer {customer['id']}:")
    for feature, impact in top_features:
        direction = "↑" if impact > 0 else "↓"
        print(f"  {direction} {feature} (impact: {impact:.3f})")

# Fraud detection with graph neural networks
# Each subscriber is a node; calls/messages are edges

import torch
import torch.nn as nn
from torch_geometric.nn import GCNConv

class FraudGNN(nn.Module):
    def __init__(self, in_dim, hidden_dim):
        super().__init__()
        self.conv1 = GCNConv(in_dim, hidden_dim)
        self.conv2 = GCNConv(hidden_dim, hidden_dim)
        self.classifier = nn.Linear(hidden_dim, 1)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index).relu()
        x = self.conv2(x, edge_index)
        return torch.sigmoid(self.classifier(x))

# Learn from patterns across the graph
# - Suspicious clusters → higher fraud probability
# - Fraudster nodes affect neighbours

# SMS spam detection with transformers
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModelForSequenceClassification.from_pretrained(
    "bert-base-uncased", num_labels=2
)

def is_spam(message: str) -> bool:
    inputs = tokenizer(
        message, return_tensors="pt", truncation=True, max_length=128
    )
    logits = model(**inputs).logits
    prob_spam = torch.softmax(logits, dim=-1)[0][1].item()
    return prob_spam > 0.5

# Example
assert is_spam("Click here to claim your prize!")   # True
assert not is_spam("Hey, running 5 min late")      # False