Guide Complet : Configurer un Serveur Ubuntu, Installer Deepseek Localement et Intégrer un Chat Open Source

 Dans cet article détaillé, nous allons vous guider à travers toutes les étapes nécessaires pour configurer un serveur Ubuntu, installer et entraîner le modèle de langage Deepseek localement, puis intégrer un chat open source pour interagir avec ce modèle. Vous apprendrez également comment configurer une API pour connecter le chatbot à Deepseek.

Introduction

Deepseek est un modèle de langage avancé capable de générer du texte, répondre à des questions, traduire des langues, etc. Pour tirer parti de ce modèle localement, il est nécessaire de configurer un environnement approprié sur un serveur Ubuntu. Nous utiliserons également un chatbot open source comme interface utilisateur pour interagir facilement avec Deepseek.

Étape 1 : Configuration du Serveur Ubuntu

La première étape consiste à préparer votre serveur Ubuntu pour accueillir Deepseek et ses dépendances.

1.1 Installation d’Ubuntu

Si vous n'avez pas encore installé Ubuntu, téléchargez la version la plus récente depuis le site officiel : https://ubuntu.com/download. Installez Ubuntu sur votre machine physique ou virtuelle selon vos besoins.

1.2 Mise à jour du Système

Une fois Ubuntu installé, mettez à jour le système avec les commandes suivantes :

sudo apt update && sudo apt upgrade -y

1.3 Installation des Outils Essentiels

Installez quelques outils essentiels comme git, curl, et wget :

sudo apt install git curl wget -y

Étape 2 : Installation de Python et des Dépendances Nécessaires

Deepseek repose sur Python. Assurez-vous d'avoir Python 3.8 ou supérieur installé.

2.1 Vérification de la Version de Python

Vérifiez si Python est déjà installé :

python3 --version

Si Python n'est pas installé ou si la version est inférieure à 3.8, installez-le :

sudo apt install python3 python3-pip -y

2.2 Création d’un Environnement Virtuel

Il est recommandé de travailler dans un environnement virtuel pour éviter les conflits de dépendances.

sudo apt install python3-venv -y
python3 -m venv deepseek_env
source deepseek_env/bin/activate

2.3 Mise à Jour de pip

Mettez à jour pip pour éviter tout problème lors de l'installation des dépendances :

pip install --upgrade pip

Étape 3 : Installation de CUDA et cuDNN (si vous utilisez une GPU)

Si vous disposez d'une GPU NVIDIA, vous pouvez accélérer l'entraînement de Deepseek en utilisant CUDA et cuDNN.

3.1 Installation de CUDA

Suivez les instructions officielles de NVIDIA pour installer CUDA sur Ubuntu : https://developer.nvidia.com/cuda-downloads.

3.2 Installation de cuDNN

Téléchargez et installez cuDNN depuis le site officiel de NVIDIA : https://developer.nvidia.com/cudnn.

Étape 4 : Installation de Deepseek

4.1 Clonage du Dépôt Deepseek

Clonez le dépôt GitHub officiel de Deepseek (ou un fork similaire) :

git clone https://github.com/deepseek-ai/Deepseek.git
cd Deepseek

4.2 Installation des Dépendances

Installez les dépendances Python nécessaires pour Deepseek :

pip install -r requirements.txt

Étape 5 : Entraînement de Deepseek sur Vos Données

5.1 Préparation des Données

Assurez-vous que vos données d'entraînement sont au format correct (généralement JSON ou CSV). Vous pouvez les placer dans un dossier spécifique, par exemple data/.

5.2 Lancement de l'Entraînement

Lancez l'entraînement avec la commande suivante :

python train.py --data_path data/your_dataset.json --model_name deepseek_model

Vous pouvez ajuster les paramètres selon vos besoins (nombre d'époques, taille du lot, etc.).

Étape 6 : Installation d’un Chat Open Source pour Interagir avec Deepseek

Pour interagir avec Deepseek via une interface conviviale, nous allons installer un chatbot open source comme ChatUI ou Ollama.

6.1 Installation de ChatUI

Clonez le dépôt ChatUI :

git clone https://github.com/chatui/chatui.git
cd chatui

Installez les dépendances :

npm install

Démarrez le serveur :

npm start

Accédez à l'interface web via http://localhost:3000.

6.2 Connexion de ChatUI à Deepseek via une API

Pour que ChatUI puisse interagir avec Deepseek, il est nécessaire de créer une API qui servira d'intermédiaire entre ChatUI et le modèle.

6.2.1 Création d'une API Flask pour Deepseek

Nous allons utiliser Flask, un microframework Python, pour créer une API simple.

Installez Flask :

pip install flask

Créez un fichier nommé app.py :

from flask import Flask, request, jsonify
import subprocess

app = Flask(__name__)

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_input = data.get('message')

    if not user_input:
        return jsonify({'error': 'Message is required'}), 400

    try:
        result = subprocess.run(
            ['python', 'path/to/deepseek/generate.py', '--input', user_input],
            capture_output=True,
            text=True
        )
        response = result.stdout.strip()
    except Exception as e:
        return jsonify({'error': str(e)}), 500

    return jsonify({'response': response})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Lancez l'API Flask :

python app.py

6.2.2 Script de Génération de Deepseek (generate.py)

Vous devez avoir un script Python (generate.py) qui utilise le modèle Deepseek pour générer des réponses :

import sys
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "path/to/deepseek_model"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

def generate_response(input_text):
    inputs = tokenizer(input_text, return_tensors="pt")
    outputs = model.generate(**inputs, max_length=50)
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response

if __name__ == "__main__":
    input_text = sys.argv[2]
    response = generate_response(input_text)
    print(response)

6.2.3 Modification de la Configuration de ChatUI

Modifiez la configuration de ChatUI pour pointer vers l'API Flask :

{
    "apiUrl": "http://localhost:5000/chat"
}

Redémarrez ChatUI :

npm start