26.04 + ollama, gemma4, openwebui

Astrolivier · Le 11/07/2026, à 19:53

Bonjour,

je crois qu'il y en a que ça intéresse alors mon retour sur ollama, gemma4:12b, openwebui, aider etc... sur un portable dell g15

carte graphique :

0000:01:00.0 VGA compatible controller: NVIDIA Corporation GA107BM / GN20-P0-R-K2 [GeForce RTX 3050 6GB Laptop GPU] (rev a1)

avec une intel integrated en + 16gb de ram et 90gb swap (pour d'autres raisons je veux pas être limité par la mémoire)

depuis avril et la 26.04 les drivers nvidia marchent enfin sur mon ordi et donc j'ai pu tester des trucs. La carte n'a rien de mirobolant (c'est un dell à 800€ en promo)

j'ai testé quelques autres avant (deepseek, et qwen) qwen était pas mal mais gemma semble vraiment un niveau au dessus. on parle de tout petits modèles <8b

openwebui me permet d'avoir une page comme sur les chatgpt et cie, un chat, historique, mise en page markdon etc...
openwebui s'installe en docker, voici mon compose. j'ai essayé les v10 mais ils ne marchent pas chez moi donc revenu à la v9.6

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:v0.9.6-cuda
    container_name: open-webui
    restart: unless-stopped
    network_mode: host
    environment:
      - OLLAMA_BASE_URL=http://127.0.0.1:11434
      - WEBUI_AUTH=True
      - WEBUI_NAME=Open WebUI Local
      - NVIDIA_VISIBLE_DEVICES=all
      - CUDA_VISIBLE_DEVICES=all
      # Désactiver OpenAI complètement
      - ENABLE_OPENAI_API=false
      - OPENAI_API_KEY=
      - OPENAI_API_BASE_URL=
      - WEBUI_SECRET_KEY=mon-super-secret-123456789
    volumes:
      - /mnt/data/openwebui:/app/backend/data
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

ollama rien de bien spécial, l'image est
gemma4:12b 7.6GB 256K

https://ollama.com/library/gemma4

c'est optimisé pour rentrer sur une 8b et je sais pas pourquoi mais ça marche aussi sur ma 6b

Voici le code formaté en **BBCode** pour une publication sur le forum ubuntu.fr. J'ai organisé les blocs pour qu'ils soient clairs et faciles à copier pour les autres utilisateurs.

***

Simulation d'un pendule simple avec SimPy et NumPy

Voici un exemple de code pour simuler les équations d'un pendule simple en utilisant SimPy (pour la gestion du temps) et NumPy (pour les calculs).

1. Importations et Paramètres physiques :

import numpy aspy
import simpy
import matplotlib.pyplot as plt
from math import sin, pi

# Constantes Physiques
g = 9.81          # Accélération de la pesanteur (m/s^2)
L = 2.0           # Longueur du pendule (m)
m = 1.0           # Masse (kg)

# Paramètres de simulation
dt = 0.01         # Pas de temps (secondes)
t_max = 20        # Durée totale (secondes)

2. Logique du Pendule (Processus SimPy) :

def pendulum_process(env, initial_theta, initial_omega):
    """
    Simule le mouvement du pendule.
    initial_theta : angle initial en radians
    initial_omega : vitesse angulaire initiale (rad/s)
    """
    theta = initial_theta
    omega = initial_omega
    
    # Listes pour stocker les données
    history_t = []
    history_theta = []

    while True:
        history_t.append(env.now)
        history_theta.append(theta)
        
        # Calcul de l'accélération angulaire (alpha)
        # Formule : alpha = -(g / L) * sin(theta)
        alpha = -(g / L) * sin(theta)
        
        # Intégration numérique (Méthode d'Euler)

aider :
https://github.com/Aider-AI/aider

c'est pour coder, ça gère git, on se met avec le terminal dans le bon dossier (il peut pas modifier plus haut dans la racine par construction) on demande et il modifie avec la git. j'ai pas encore bien pu le tester mais ça m'a l'air vraiment pas mal.

le "thinking" ne marchait pas avec deepseek et qwen, mais ça a l'air ok avec gemma. à priori je l'enlève, ça ralenti pour pas grand chose (surtout quand ça plante)

en plus voici la réponse au premier message dans la liste du forum (derniers messages) dont j'ai demandé un reformatage en bbcodes (pour tout dire j'ai changé 4 "**" par "/b", il m'ouvrait en bbcode et fermait en markdown, j'ai pas vérifié ce que ça dit) :
https://forum.ubuntu-fr.org/viewtopic.php?id=2095711

--------------

Voici la réponse formatée spécifiquement pour le forum **ubuntu.fr** en utilisant les balises BBCode demandées :

C'est une excellente question. Pour répondre directement à votre question : Oui, l'ordre des lignes a une importance cruciale, car le service sshd lit le fichier de haut en bas.

Voici les points clés pour sécuriser votre Raspberry Pi et vérifier la configuration :

1. Le problème d'ordre dans votre fichier actuel
Dans votre fichier

config.perso.conf

, vous avez deux fois la ligne concernant le mot de passe :

PasswordAuthentication yes
...
PasswordAuthentication no

Dans ce cas, c'est la dernière instruction lue qui est appliquée. Ici, c'est no qui l'emporte. Il vaut mieux supprimer la ligne inutile pour éviter toute confusion.

2. Comment restreindre à "uniquement" le réseau local ?
Votre configuration actuelle utilise :

AllowUsers iznobe@192.168.1.0/24

C'est une méthode correcte car elle limite l'accès aux utilisateurs dont l'adresse IP appartient au sous-réseau local. Une autre méthode, plus radicale pour "fermer" le service au monde extérieur, consiste à limiter les interfaces sur lesquelles SSH écoute :

Option A (Votre méthode actuelle - Recommandée) :
Gardez votre fichier tel quel (en supprimant le doublon). Elle est efficace car même si une requête arrive de l'extérieur via internet, si l'IP source ne finit pas par ".1.x", SSH rejettera la connexion.

Option B (La plus stricte) :
Dans le fichier principal `/etc/ssh/sshd_config`, vous pouvez modifier la ligne ListenAddress :

ListenAddress 192.168.1.0/24

*Note : Cela force SSH à n'écouter que sur l'interface réseau correspondant à ce masque.*

3. Comment vérifier que c'est "effectivement" le cas ?
Il existe trois façons de vérifier votre configuration :

A. La vérification "Logique" (La plus simple) :
Depuis votre Pi, essayez de vous connecter avec un utilisateur qui n'est pas dans la liste AllowUsers. Si l'accès est refusé, la règle fonctionne.

B. La vérification "Réseau" (La plus fiable pour internet) :
Utilisez un outil comme CanYouHost ou faites un scan de port avec `nmap` depuis une connexion mobile (en 4G/5G, pas en Wi-Fi). Si le port 22 ne répond pas sur votre IP publique, votre accès est bien "local".

C. La vérification "Configuration" (La plus technique) :
Pour voir exactement ce que le service SSH a chargé en mémoire (en résolvant toutes les inclusions et ordres de lignes), utilisez la commande :

sshd -T | grep -i "allowusers"

En résumé :
Nettoyez votre fichier

config.perso.conf

pour supprimer le doublon de `PasswordAuthentication` et redémarrez le service avec :

sudo systemctl restart ssh

Votre ligne AllowUsers iznobe@192.168.1.0/24 est une excellente barrière pour garantir que seuls les appareils sur votre réseau local peuvent s'authentifier.

voilà, j'espère que ça profitera

Astrolivier · Le 11/07/2026, à 20:17

le premier prompt est pas clair et gemma m'a enlevé une partie quand j'ai demandé en bbcode. voici le prompt + réponse originale :

fais moi le code pour un jupyternotebook. je veux les équations de base d’un pendule simple avec simpy et numpy

Il est important de noter une petite nuance technique : **SimPy** est une bibliothèque de simulation à *événements discrets* (souvent utilisée pour la logistique ou les files d'attente), alors que le pendule est un système physique continu.
Pour simuler un pendule avec SimPy, nous allons traiter le temps comme des pas discrets ($\Delta t$). Pour résoudre l'équation différentielle, nous utiliserons une méthode numérique (Euler) à l'intérieur de la boucle SimPy.
Voici le code structez pour un Jupyter Notebook.
### Structure du notebook suggérée :
---
#### Cellule 1 : Importations et Paramètres
Dans cette cellule, on définit les constantes physiques et les paramètres de simulation.
```python
import numpy as np
import simpy
import matplotlib.pyplot as plt
from math import sin, pi
# Constantes Physiques
g = 9.81 # Accélération de la pesanteur (m/s^2)
L = 2.0 # Longueur du pendule (m)
m = 1.0 # Masse (kg) - n'impacte pas le mouvement simple, mais utile pour la physique
# Paramètres de simulation
dt = 0.01 # Pas de temps (secondes)
t_max = 20 # Durée totale (secondes)
```
#### Cellule 2 : Modélisation du Pendule avec SimPy
Ici, nous définissons la logique de mouvement. L'équation de base est :
$$\frac{d^2\theta}{dt^2} + \frac{g}{L}\sin(\theta) = 0$$
```python
def pendulum_process(env, initial_theta, initial_omega):
"""
Simule le mouvement du pendule.
initial_theta : angle initial en radians
initial_omega : vitesse angulaire initiale (rad/s)
"""
theta = initial_theta
omega = initial_omega

# Listes pour stocker les données pour le tracé
history_t = []
history_theta = []
while True:
# Enregistrement des données actuelles
history_t.append(env.now)
history_theta.append(theta)

# Calcul de l'accélération angulaire (alpha)
# Formule : alpha = -(g / L) * sin(theta)
alpha = -(g / L) * sin(theta)

# Intégration numérique simple (Méthode d'Euler)
# On met à jour la vitesse angulaire
omega += alpha * dt
# On met à jour l'angle
theta += omega * dt

# On avance le temps dans SimPy
yield env.timeout(dt)

return history_t, history_theta
# Configuration de l'environnement SimPy
env = simpy.Environment()
# Initialisation : Pendule à 45 degrés (pi/4) avec une vitesse initiale nulle
# On lance le processus
results = env.process(pendulum_process(env, pi/4, 0))
# Lancement de la simulation
env.run(until=t_max)
```
#### Cellule 3 : Visualisation des résultats
Affichons les graphiques pour vérifier que le pendule oscille bien.
*Note: Comme `pendulum_process` est un générateur, pour récupérer les données dans SimPy on peut soit utiliser une classe de stockage ou simplement stocker les variables globalement.*
```python
# Pour récupérer les données proprement si vous avez utilisé la structure ci-dessus :
# (Si vous voulez simplifier le code, créez une liste globale pour collecter les données)
# Voici une version simplifiée pour capturer les données facilement dans Jupyter :
t_data = []
theta_data = []
def simple_pendulum_sim(env, theta, omega):
while True:
t_data.append(env.now)
theta_data.append(theta)

alpha = -(g / L) * sin(theta)
omega += alpha * dt
theta += omega * dt

yield env.timeout(dt)
# Relancer la simulation pour le graphique
env = simpy.Environment()
simpy.Environment().process(simple_pendulum_sim(env, pi/4, 0))
env.run(until=t_max)
# Affichage
plt.figure(figsize=(10, 5))
plt.plot(t_data, theta_data, label="Angle (rad)")
plt.title("Simulation du Pendule Simple")
plt.xlabel("Temps (s)")
plt.ylabel("Angle $\\theta$ (rad)")
plt.grid(True)
plt.legend()
plt.show()
```
---
### Explications des équations utilisées :
1. **L'accélération angulaire ($\alpha$)** :
$$\alpha = \frac{d^2\theta}{dt^2} = -\frac{g}{L}\sin(\theta)$$
* $\frac{g}{L}$ représente la force de rappel gravitationnelle divisée par la longueur.
* Le $\sin(\theta)$ rend le système non-linéaire (ce qui permet au pendule d'être précis même pour de grands angles).
2. **La méthode d'Euler** :
Puisque SimPy traite des pas de temps, on convertit les dérivées en mises à jour discrètes :
* $\omega_{t+1} = \omega_t + \alpha \cdot \Delta t$
* $\theta_{t+1} = \theta_t + \omega \cdot \Delta t$
### Pourquoi utiliser SimPy ici ?
Bien que `scipy.integrate.solve_ivp` soit plus standard pour la physique pure, l'utilisation de **SimPy** est très utile si vous voulez ajouter des "événements" :
* *Exemple :* Ajouter un frein brusque à $t=10s$ ou une impulsion externe (une force supplémentaire) qui arrive seulement à un moment précis du cycle.

Blakesnake · Le 22/07/2026, à 22:15

J'essaie de faire tourner open-webui en docker avec ollama, mais chez moi c'est la recherche web qui merde. Pas d'acces à web_search malgré que tout soit configuré pour ça. Vous y arrivez vous ?

Nuliel · Le 23/07/2026, à 14:53

Bonjour,
Pour ma part j'avais constaté que openwebui avec ollama bundled + cuda ça tournait vraiment lentement dans docker. Maintenant j'ai ollama directement sur mon système (sans docker), je trouve que c'est bien plus réactif, mais je n'ai plus d'interface dédiée (j'ai juste l'extension vscode "continue" mais c'est pour le dev)
Aucune idée pour la recherche web, pour ma part je laisse pas d'ia accéder à internet

Dernière modification par Nuliel (Le 23/07/2026, à 14:53)

Astrolivier · Le 24/07/2026, à 13:00

je n'ai pas essayé la web search

openweb ui est en docker, ollama est installé "normalement" avec les services systemd

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 11/07/2026, à 19:53

26.04 + ollama, gemma4, openwebui

#2 Le 11/07/2026, à 20:17

Re : 26.04 + ollama, gemma4, openwebui

#3 Le 22/07/2026, à 22:15

Re : 26.04 + ollama, gemma4, openwebui

#4 Le 23/07/2026, à 14:53

Re : 26.04 + ollama, gemma4, openwebui

#5 Le 24/07/2026, à 13:00

Re : 26.04 + ollama, gemma4, openwebui

Pied de page des forums