Standard Chartered will cut 7,800 back-office jobs to ‘the machines’ by 2030

Introduction

In a world where artificial intelligence is transforming industries, banks like Standard Chartered are embracing AI to automate routine back-office tasks. In this tutorial, you'll learn how to build a simple AI-powered document classification system that can help automate tasks like categorizing financial reports or customer inquiries. This is the kind of technology that banks are using to reduce their back-office workforce.

This tutorial will teach you how to use Python and machine learning libraries to create a basic document classifier that can automatically sort text into different categories. This is a foundational skill that banks and other organizations use to implement AI solutions in their operations.

Prerequisites

Before starting this tutorial, you'll need:

• A computer with Python 3.7 or higher installed
• Basic understanding of Python programming concepts
• Internet connection to download required libraries

Don't worry if you're new to machine learning – we'll explain everything step by step.

Step-by-Step Instructions

1. Install Required Libraries

First, we need to install the Python libraries we'll use for our document classification project. Open your terminal or command prompt and run:

pip install scikit-learn pandas numpy

Why we do this: These libraries provide the tools we need for machine learning (scikit-learn), data manipulation (pandas), and numerical operations (numpy).

2. Create Your Project Structure

Create a new folder for your project and inside it, create a file called document_classifier.py. This will be our main program file.

Why we do this: Organizing our code in a proper structure makes it easier to manage and understand as we build more complex features.

3. Import Required Modules

In your document_classifier.py file, start by importing the necessary libraries:

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

Why we do this: These imports give us access to the tools we need to process text data, train our classifier, and evaluate its performance.

4. Create Sample Data

Next, let's create some sample financial documents to train our classifier. Add this code to your file:

# Sample financial documents
sample_data = {
    'text': [
        'Customer inquiry about account balance',
        'Request for loan approval',
        'Monthly financial report',
        'Investment portfolio update',
        'Customer complaint about service',
        'Bank statement request',
        'Credit card fraud alert',
        'Insurance policy renewal',
        'Stock trading transaction',
        'Account opening application'
    ],
    'category': [
        'customer_service',
        'loan_processing',
        'financial_reporting',
        'investment_management',
        'customer_service',
        'account_management',
        'fraud_detection',
        'insurance',
        'trading',
        'account_management'
    ]
}

df = pd.DataFrame(sample_data)
print(df.head())

Why we do this: This sample data represents the types of documents a bank might need to categorize. In a real-world scenario, you'd have much more data, but this gives us a working example to test our system.

5. Prepare the Data for Training

Now we need to convert our text data into a format that our machine learning algorithm can understand:

# Prepare the data
X = df['text']
y = df['category']

# Convert text to numerical features using TF-IDF
vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
X_vectorized = vectorizer.fit_transform(X)

print("Shape of vectorized data:", X_vectorized.shape)

Why we do this: TF-IDF (Term Frequency-Inverse Document Frequency) is a technique that converts text into numbers, making it possible for computers to understand and process text data for machine learning.

6. Split Data for Training and Testing

Before training our model, we need to split our data so we can test how well it performs:

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
    X_vectorized, y, test_size=0.2, random_state=42
)

Why we do this: This ensures we can evaluate how well our classifier works on data it hasn't seen before, which is crucial for real-world applications.

7. Train the Classifier

Now we'll train our machine learning model using the Naive Bayes algorithm, which works well for text classification:

# Train the classifier
classifier = MultinomialNB()
classifier.fit(X_train, y_train)

Why we do this: The Naive Bayes algorithm is simple yet effective for text classification tasks and is commonly used in real-world applications like email spam detection and document categorization.

8. Test the Classifier

Let's see how well our trained model performs:

# Make predictions
y_pred = classifier.predict(X_test)

# Calculate accuracy
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

# Show detailed classification report
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

Why we do this: Testing our model helps us understand its performance and identify areas for improvement before deploying it in a real environment.

9. Create a Function to Classify New Documents

Now let's create a function that can classify new documents:

def classify_document(text):
    # Vectorize the input text
    text_vectorized = vectorizer.transform([text])
    
    # Make prediction
    prediction = classifier.predict(text_vectorized)[0]
    
    # Get prediction probability
    probabilities = classifier.predict_proba(text_vectorized)[0]
    
    return prediction, probabilities

Why we do this: This function allows us to easily classify new documents without having to retrain our model each time.

10. Test Your Classifier with New Documents

Let's test our classifier with some new sample documents:

# Test with new documents
new_documents = [
    'Request for credit card limit increase',
    'Quarterly financial analysis report',
    'Complaint about online banking service'
]

for doc in new_documents:
    prediction, probabilities = classify_document(doc)
    print(f"Document: {doc}")
    print(f"Predicted category: {prediction}")
    print(f"Confidence: {max(probabilities):.2f}")
    print("-" * 50)

Why we do this: This demonstrates how our system can be used to automatically categorize new documents, which is exactly what banks are doing to reduce their back-office workforce.

Summary

In this tutorial, you've learned how to build a basic document classification system using Python and machine learning. This system can automatically categorize text documents, which is one of the technologies that banks like Standard Chartered are using to automate back-office tasks.

While this is a simplified example, it demonstrates the core concepts behind AI automation in financial services. Real-world implementations would include:

• Larger, more diverse datasets
• More sophisticated machine learning models
• Integration with existing banking systems
• Continuous learning and model updates

This type of automation helps banks like Standard Chartered reduce their back-office costs while improving efficiency – exactly what the bank's CEO described in the news article.