Comment je m’assure que ma carrière d’analyste ne soit pas dévorée par l’IA

Comment je fais en sorte que ma carrière dans l'analytique ne soit pas dévorée par l'IA

Chaque semaine, un nouveau titre flash : « L'IA peut maintenant écrire vos rapports », « GPT-4 réussit l'examen CPA », « Les analystes de données sont les prochains sur la liste des suppressions. » En tant que professionnel de l'analytique, je passais des nuits blanches à me demander combien de temps il me restait avant qu'un grand modèle de langage ne remplace chaque ligne de SQL que j'écris. Puis j'ai réalisé que la question n'est pas de savoir si l'IA va s'attaquer à mon emploi, mais plutôt si je vais utiliser l'IA pour améliorer, accélérer et rendre mon travail plus précieux.

Les grands acteurs technologiques sont clairs sur leur direction. OpenAI, Google et Microsoft investissent des milliards pour rendre les modèles génératifs plus intelligents, moins chers et plus accessibles. Pendant ce temps, la communauté Towards Data Science regorge d'analystes qui passent du statut de « presse-boutons » à celui de conseillers stratégiques. Mon plan à moi n'est pas de distancer les machines, mais de les chevaucher. Cet article détaille les étapes concrètes que je suis en train de mettre en œuvre – y compris les outils, le code et les workflows – pour garantir que ma carrière dans l'analytique survive et prospère à l'ère de l'IA.

Pourquoi le manuel standard ne suffit pas

Il y a quelques années, la sécurité de carrière signifiait maîtriser Tableau, Excel et un peu de SQL. Aujourd'hui, un analyste junior peut demander à un chatbot de produire une maquette de tableau de bord en quelques secondes. Les compétences qui vous différenciaient autrefois – écrire du SQL propre, formater des graphiques – deviennent des commodités. Comme le souligne le blog Microsoft AI, l'entreprise intègre Copilot à tous les niveaux de la pile de données, d'Excel à Power BI. Le blog Google AI montre quant à lui des agents Vertex AI qui écrivent des requêtes à la volée.

Les analystes qui survivront seront ceux capables de **poser les bonnes questions, valider les réponses et traduire les chiffres en décisions**. C'est un ensemble de compétences qu'aucune IA (pour l'instant) ne maîtrise pleinement. Pour développer ces compétences, je combine trois stratégies :

• **Automatiser les parties ennuyeuses** afin de me concentrer sur la stratégie.
• **Construire des outils d'IA personnalisés** qui augmentent, et non remplacent, mon raisonnement.
• **Approfondir ma connaissance du domaine** pour repérer les absurdités qu'un modèle pourrait générer.

Ci-dessous, j'explique exactement comment j'ai mis en place la base technique de cette approche.

Prérequis

Avant de plonger dans l'installation, voici les prérequis pour l'environnement que j'utilise quotidiennement :

• **Système d'exploitation** : macOS ou Linux (Windows avec WSL2 fonctionne aussi)
• **Python** 3.10 ou ultérieur
• **Git** (pour le contrôle de version et le clonage de dépôts)
• **Une machine locale** avec au moins 16 Go de RAM (pour exécuter des petits modèles de langage)
• **Une connexion Internet** pour télécharger les modèles et les paquets
• (Optionnel) Une clé API d'OpenAI si vous souhaitez utiliser des modèles cloud en secours

Installation pas à pas

Je construis mon workflow d'analytique augmentée autour de trois composants principaux : un modèle de langage local (via Ollama), un environnement Python avec LangChain, et une base de données vectorielle légère (Chroma) pour indexer les documents internes. Voici comment je les installe.

#### 1. Installer Ollama pour l'IA locale

Ollama exécute des grands modèles de langage en local, ce qui garde les données sensibles hors du cloud. Je l'utilise pour l'analyse exploratoire quand je ne veux pas payer par appel API ou quand je suis hors ligne.

# Comment je fais en sorte que ma carrière dans l'analytique ne soit pas dévorée par l'IA
curl -fsSL https://ollama.com/install.sh | sh

Une fois installé, démarrez le serveur Ollama en arrière-plan :

ollama serve &

Téléchargez maintenant un modèle de taille raisonnable. Je recommande `mistral` pour les tâches d'analytique car il est rapide et correct avec les chiffres.

ollama pull mistral

Vous pouvez le tester en exécutant :

ollama run mistral "Quel est 15% de 340 ?"

#### 2. Configurer un environnement virtuel Python

Je garde mes projets isolés pour éviter les conflits de dépendances.

# Créer un nouveau répertoire pour le projet
mkdir ~/analytique-ia
cd ~/analytique-ia

# Créer un environnement virtuel
python3 -m venv venv

# L'activer
source venv/bin/activate

#### 3. Installer les paquets Python essentiels

Installez maintenant les bibliothèques qui relient le tout. J'utilise `langchain` pour les chaînes de prompts, `chromadb` pour la mémoire locale, et `pandas` pour le traitement des données.

pip install langchain langchain-community chromadb pandas openai

Si vous prévoyez d'utiliser Ollama depuis Python, installez aussi :

pip install ollama

#### 4. Vérifier l'installation

Exécutez un petit test de validation pour confirmer que tout fonctionne.

# test_imports.py
import langchain
import chromadb
import pandas as pd
import ollama

print("Toutes les importations réussies !")

Exécutez :

python test_imports.py

Si vous ne voyez aucune erreur, vous êtes prêt à passer aux exemples d'utilisation.

Exemples d'utilisation

Une fois l'environnement prêt, je peux montrer trois scénarios réels où l'IA augmente mon travail d'analytique.

#### Exemple 1 : Automatiser le résumé de données avec LangChain

Au lieu d'écrire une note de plusieurs pages, je laisse un modèle local produire une première ébauche. Le script ci-dessous lit un CSV de données de ventes et demande au modèle un résumé concis.

# summarize_data.py
import pandas as pd
from langchain.llms import Ollama
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# Charger un exemple de CSV (remplacez par votre propre fichier)
df = pd.read_csv("sales_data.csv")

# Préparer une représentation textuelle (10 premières lignes + description des colonnes)
sample_text = f"Colonnes : {list(df.columns)}\n\n5 premières lignes :\n{df.head(5).to_string()}"

# Définir le prompt
prompt = PromptTemplate(
    input_variables=["data"],
    template="À partir des données de ventes suivantes, fournissez un résumé exécutif d'un paragraphe mettant en évidence les tendances clés.\n\nDonnées :\n{data}\n\nRésumé :"
)

# Utiliser le modèle local Ollama
llm = Ollama(model="mistral")
chain = LLMChain(llm=llm, prompt=prompt)

# Générer le résumé
result = chain.run(data=sample_text)
print("Résumé généré par l'IA :\n", result)

Exécutez le script :

python summarize_data.py

Le modèle renverra un paragraphe du type : « Les ventes dans la région Nord-Est ont augmenté de 12 % d'un trimestre à l'autre, tandis que l'Ouest a connu une baisse de 3 % due à des ruptures de stock… » **Je vérifie toujours les chiffres manuellement**, mais l'ébauche me fait gagner vingt minutes de rédaction.

#### Exemple 2 : Poser des questions sur vos propres documents avec RAG

Je dois souvent répondre à des questions sur les politiques internes (par exemple : « Quelle est notre politique de conservation des données ? »). Stocker ces politiques dans une base vectorielle me permet de poser des questions sans les exposer à l'Internet public.

# rag_query.py
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.llms import Ollama

# 1. Charger vos documents internes (ici un seul fichier texte)
loader = TextLoader("company_policies.txt")
documents = loader.load()

# 2. Découper en morceaux
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_documents(documents)

# 3. Créer les embeddings et les stocker dans Chroma
embeddings = OllamaEmbeddings(model="mistral")
vectordb = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")

# 4. Créer une chaîne de question-réponse avec recherche
qa_chain = RetrievalQA.from_chain_type(
    llm=Ollama(model="mistral"),
    retriever=vectordb.as_retriever()
)

# 5. Poser une question
query = "Quelle est la durée maximale de conservation des données d'achat des clients ?"
answer = qa_chain.run(query)
print("Réponse :", answer)

Sauvegardez et exécutez :

python rag_query.py

Cette approche fait de moi la personne de référence pour des réponses rapides – je n'ai plus besoin de fouiller des dizaines de PDF.

#### Exemple 3 : Générer des requêtes SQL répétitives

Écrire du SQL répétitif me déprime. J'utilise un LLM pour produire une première version de la requête, que je révise ensuite et optimise.

# generate_sql.py
from langchain.llms import Ollama
from langchain.prompts import PromptTemplate

prompt = PromptTemplate(
    input_variables=["question", "table_schema"],
    template="À partir du schéma de table ci-dessous, écrivez une requête SQL pour répondre à la question.\n\nSchéma de table :\n{table_schema}\n\nQuestion :\n{question}\n\nRequête SQL :"
)

llm = Ollama(model="mistral")
chain = LLMChain(llm=llm, prompt=prompt)

schema = """
Table : orders (
  order_id INT PRIMARY KEY,
  customer_id INT,
  order_date DATE,
  total_amount DECIMAL(10,2)
)
Table : customers (
  customer_id INT PRIMARY KEY,
  name VARCHAR(100),
  region VARCHAR(50)
)
"""

question = "Quel est le chiffre d'affaires total par région pour chaque mois en 2024 ?"
sql = chain.run(question=question, table_schema=schema)
print("SQL généré :\n", sql)

Exécutez :

python generate_sql.py

Je vérifie toujours les jointures et les agrégations, mais partir d'une requête raisonnable accélère considérablement le développement.

Le côté humain : validation, éthique et expertise du domaine

Aucun de ces outils n'a d'importance si je les utilise comme une boîte noire. L'idée clé de la communauté Towards Data Science est que **l'IA est un assistant junior, pas un analyste senior**. Chaque résultat que j'obtiens, je le vérifie :

• Affirmations numériques : suis-je sûr que le modèle a correctement calculé le pourcentage ? (Souvent non.)
• Cohérence logique : le résumé contredit-il des règles métier connues ?
• Biais : le modèle ignore-t-il un segment qui importe à l'entreprise ?

Je maintiens aussi ma connaissance du domaine. Je lis le blog Google AI pour comprendre ce que les modèles ne peuvent pas faire (par exemple, l'inférence causale, les contrefactuels). Je suis le blog Microsoft AI pour voir comment les outils d'entreprise intègrent l'IA – et ensuite j'apprends à utiliser ces outils avant mes pairs.

Conclusion

La menace de l'IA pour les carrières dans l'analytique est réelle, mais ce n'est pas une condamnation à mort – c'est une remise à zéro. Les analystes qui prospéreront seront ceux qui cesseront d'écrire chaque ligne de code à la main et commenceront à **concevoir des systèmes qui produisent des insights plus rapidement**, tout en appliquant le jugement humain pour interpréter, remettre en question et communiquer ces insights.

Je m'assure que ma carrière ne soit pas dévorée par l'IA en dévorant l'IA en premier : installer des modèles locaux, construire des pipelines de recherche augmentée, et automatiser le travail ingrat qui prenait des heures auparavant. Les étapes techniques de cet article constituent la base. Le véritable différenciateur, cependant, est la curiosité – demander « pourquoi » quand le modèle crache une réponse, et savoir quand l'ignorer.

Si vous êtes un professionnel de l'analytique, commencez dès aujourd'hui : installez Ollama, écrivez un script qui augmente un rapport que vous produisez déjà, et voyez combien de temps vous libérez. Utilisez ce temps pour parler aux parties prenantes, apprendre le modèle économique, et devenir la personne qui connecte les données aux décisions. C'est ainsi que vous restez irremplaçable.

**Lectures complémentaires (contexte général uniquement) :**

• Towards Data Science – articles sur les reconversions professionnelles et la pensée analytique
• OpenAI News – mises à jour sur les capacités et la sécurité des modèles
• Google AI Blog – recherche sur l'IA responsable et les outils de données
• Microsoft AI Blog – intégration de l'IA en entreprise dans l'analytique

*Aucun article, date ou auteur spécifique provenant des sources ci-dessus n'a été cité car il s'agit de pages d'accueil générales.*