PyTorch, le framework chouchou des bidouilleurs d’IA, vient de nous pondre un petit truc cool : Torchtune ! 💎 Cette nouvelle bibliothèque native, encore en phase alpha mais déjà disponible en open-source sur GitHub, va vous permettre de fine-tuner les gros modèles de langage (LLM) comme un pro, sans vous prendre la tête.

Torchtune est donc une boîte à outils hyper flexible et modulaire qui va vous permettre de vous éclater à customiser des modèles pour vos propres besoins, le tout avec des recettes mémoire efficaces qui tournent même sur une bête carte graphique de gamer, comme les NVidia 3090/4090.

Son secret ?

Une architecture bien pensée qui mise sur l’interopérabilité avec l’écosystème des LLM, qu’ils soient open-source ou non. Concrètement, ça veut dire que vous allez pouvoir brancher Torchtune à tout un tas d’outils et de frameworks que vous adorez déjà, comme Hugging Face 🤗, PyTorch FSDP 🪢, Weights & Biases 📈, et plein d’autres.

Grâce à des recettes simples et bien documentées pour les modèles populaires comme Llama 3, Mistral ou Gemma 7B, même les débutants vont pouvoir se lancer dans l’aventure sans flipper. Bon OK, il faudra quand même un peu de bagage en PyTorch et en LLM, mais rien d’insurmontable ! Et si vous êtes un pro, vous allez pouvoir hacker le code à volonté pour l’adapter à vos besoins spécifiques.

Alors comment on met les mains dans le cambouis avec Torchtune ?

Rien de plus simple, mon cher Watson ! Il vous suffit d’installer la dernière version stable de PyTorch (2.2.2 au moment où j’écris ces lignes), puis de télécharger Torchtune depuis PyPI avec un petit

pip install torchtune

Et voilà, vous êtes prêt à en découdre avec les LLM !

Pour vous faire les dents, je vous conseille de jeter un œil au tutoriel sur le fine-tuning de Llama2 7B. C’est le parfait point de départ pour comprendre comment Torchtune fonctionne et comment l’utiliser pour vos propres projets.

En gros, ça se passe en 4 étapes :

1. Téléchargez le modèle pré-entraîné et le tokenizer depuis Hugging Face Hub avec tune download.
2. Choisissez une recette de fine-tuning (LoRA, QLoRA, full…) et customisez-la avec un fichier de config en YAML.
3. Lancez l’entraînement avec tune run en précisant votre recette et votre config. Vous pouvez même faire du multi-GPU avec torchrun !
4. Admirez le résultat et testez votre modèle fine-tuné avec une inférence locale. Si tout se passe bien, exportez-le avec ExecuTorch pour le déployer en prod, ou utilisez les API de quantification de Torchao pour l’exporter en int4 ou int8 et l’utiliser sur mobile ou en edge.

Facile, non ? 😄

Bon OK, j’avoue, j’ai un peu simplifié. En vrai, il y a pas mal de subtilités et de paramètres à régler pour obtenir les meilleurs résultats, comme le learning rate, le nombre d’époques, la taille du batch, le ratio de LoRA, et tout un tas d’autres trucs, mais c’est justement sa flexibilité qui vous permet d’expérimenter à l’infini pour trouver la combinaison parfaite.

Bref, si vous êtes dev et que vous aimez jouer avec les LLM c’est à tester.

Source

Vous pensiez qu’Apple se contentait de suivre les autres géants de la tech en matière d’intelligence artificielle ? Détrompez-vous ! La firme de Cupertino vient de dévoiler les secrets de son nouveau modèle d’IA baptisé MM1, et croyez-moi, ça décoiffe grave !

Alors que Google mise sur son modèle Gemini pour booster les fonctionnalités IA d’iOS 18, Apple a décidé de tracer sa propre route avec MM1. L’idée de génie ? Utiliser un dataset diversifié qui mélange allègrement du texte et des images pour entraîner cette IA nouvelle génération.

Résultat, MM1 est capable de générer des légendes pour des images de manière hyper précises, de répondre à des questions posées sur des images et même d’inférer du langage naturel à partir d’indices linguistiques et visuels. Une vraie bête de compétition !

En combinant différentes méthodes d’entraînement issues d’autres IA avec ses propres techniques maison, Apple espère ainsi rattraper son retard sur des mastodontes comme Google ou OpenAI. Et vu le niveau de performances annoncé, y a de quoi être optimiste !

Alors comment ça fonctionne ?

Et bien si vous montrez une photo de votre chat à MM1, non seulement il sera capable de le reconnaître et de le décrire avec une précision redoutable, mais il pourra aussi répondre à des questions du genre « De quelle couleur est son collier ? » ou « A-t-il l’air joueur ou paresseux sur cette image ?« .

Dans l’exemple réel ci-dessous, on lui demande combien il devra payer pour les bières (photo 1) d’après le menu (photo 2). Et c’est le seul à répondre correctement, et précisemment.

Bluffant, non ?

Et ce n’est qu’un exemple parmi d’autres. Apple étant Apple, on peut s’attendre à ce que MM1 révolutionne notre façon d’interagir avec nos devices. Pourquoi pas imaginer une app qui génère automatiquement la description textulle d’une scène que vous auriez photographié ? Ou un mode « sous-titres » universel qui retranscrirait en temps réel tout ce que votre iPhone voit et entend ? Les possibilités sont infinies dès que l’IA est embarquée !

Bien sûr, tout cela n’est encore qu’à l’état de recherche pour le moment. Mais connaissant Apple, on peut parier que la firme mettra rapidement en application les promesses de MM1 dans ses futurs produits et services. iOS 19 propulsé par une IA multimodale surpuissante, ça envoie du rêve, je ne vous le cache pas.

Avec MM1, Apple prouve une fois de plus sa capacité à innover. Pendant que les autres géants de la Silicon Valley se contentent d’améliorer leurs modèles existants, la marque à la pomme préfère partir d’une feuille blanche pour inventer l’IA de demain. Comme dirait l’autre, « think different », ça a du bon ! 😎

Alors, vous en pensez quoi de ce MM1 ? Hâte de voir ce qu’Apple nous réserve pour la suite.

Perso, j’ai déjà hâte de discuter avec mon iPhone comme s’il était mon meilleur pote. Au moins, j’aurais un pote ^^.

Source

Imaginez un monde merveilleux où les secrets enfermés dans les binaires compilés ne seraient plus inaccessibles aux simples mortels que nous sommes…

C’est exactement ce que LLM4Decompile, le premier LLM (Large Language Model) open-source dédié à la décompilation, promet de réaliser. Fruit d’un travail de recherche innovant mené par une équipe de chercheurs passionnés, ce modèle révolutionnaire ouvre de nouvelles perspectives dans le domaine du reverse engineering.

Jusqu’à présent, la décompilation, c’est-à-dire le processus qui consiste à retrouver le code source à partir d’un exécutable compilé, restait un défi de taille. Les outils existants peinaient à produire un code lisible et compréhensible par les humains, ce qui est logique puisqu’il y a une grosse perte d’informations lors de la compilation. Mais ça, c’était avant l’arrivée de LLM4Decompile !

Entraîné sur un énorme dataset de 4 milliards de tokens de code C et d’assembleur x86, ce modèle de langage surpuissant a appris à décoder les secrets des binaires. Grâce à son architecture basée sur les Transformers et ses milliards de paramètres, il est donc capable de capturer les patterns et la sémantique du code à un niveau inédit.

Mais les chercheurs ne se sont pas arrêtés là. Ils ont aussi développé le premier benchmark standardisé pour la décompilation baptisé Decompile-Eval. Basé sur des problèmes de programmation réels, il permet d’évaluer la capacité des modèles à regénérer un code recompilable et ré-exécutable. Exit les métriques de similarité de tokens, place à des critères solides et pertinents ! LLM4Decompile parvient à recompiler 90% des binaires décompilés (oui oui, je me suis pas trompé) !

Mieux encore, 21% du code re-généré réussit tous les tests unitaires, démontrant une préservation de la logique du programme. C’est 50% de plus que GPT-4, pourtant considéré comme l’état de l’art.

Cerise sur le gâteau, LLM4Decompile est entièrement open-source. Les modèles pré-entraînés de 1,3 à 33 milliards de paramètres sont disponibles sur Hugging Face, prêts à être utilisés et améliorés par la communauté. Le code, les données d’entraînement et le benchmark sont aussi accessibles sur GitHub.

Bien sûr, LLM4Decompile n’est qu’un premier pas vers la décompilation par l’IA. Il reste limité au langage C et à l’assembleur x86, et ne gère pour l’instant que des fonctions isolées. Mais les perspectives sont immenses ! On peut imaginer étendre son champ d’action à d’autres langages et architectures, voire carrément l’utiliser pour transpiler automatiquement du code entre différents langages.

Les applications potentielles sont nombreuses : reverse engineering de logiciels legacy (ça veut dire obsolète mais encore utilisé.. .argh !), analyse de malware, portage de vieux jeux vidéos, etc. Même les vieux binaires qui sentent la naphtaline n’auront bientôt plus de secrets pour nous !

Bonne nouvelle, Ollama vient tout juste d’annoncer un truc qui devrait vous faire plaisir : le support des cartes graphiques AMD en preview ! Cela signifie que toutes les fonctionnalités d’Ollama peuvent maintenant être accélérées par les cartes graphiques AMD, que ce soit sur Linux ou Windows.

Mais au fait, c’est quoi Ollama ? Pour les deux du fond qui suivent pas, je vous refais un topo vite fait. Ollama, c’est un outil hyper pratique qui permet de faire tourner des grands modèles de langage open-source directement sur votre machine locale. Genre Mistral, Llama 2 et toute la clique.

Alors, quelles sont les cartes AMD compatibles ?

Pas de panique, je vous ai préparé une petite liste bien détaillée. Dans la famille des Radeon RX, on retrouve les monstres comme les 7900 XTX, 7900 XT, 7800 XT, 6900 XT et compagnie. Pour les pros, la gamme Radeon PRO est aussi de la partie avec les W7900, W6800X Duo, Vega II… Bref, y a du beau monde au rendez-vous. Et si vous êtes un fan des cartes Instinct, pas de jaloux, les MI300X, MI250, MI100 et autres sont aussi supportées.

Ollama promet également que d’autres modèles de cartes graphiques suivront. Alors on croise les doigts et on surveille les annonces comme le lait sur le feu. En attendant, si vous voulez vous lancer dans l’aventure Ollama avec votre carte AMD, c’est simple comme bonjour.

Téléchargez Ollama pour Linux ou Windows, installez le bouzin et hop, vous voilà parés pour faire chauffer votre GPU AMD ! C’est pas beau la vie ? Je vous ai même fait un tutoriel ici !

Allez, je vous laisse, j’ai un rendez-vous urgent avec mon Llama2 uncensored qui me fait de l’œil.

Source

Connaissez-vous la pratique du port knocking ?

Il s’agit d’une bonne pratique de sécurité informatique qui permet de contrôler l’accès à un serveur en utilisant une séquence de tentatives de connexion à des ports fermés. Cette technique est souvent utilisée pour masquer aux yeux des scanners de ports, des services comme SSH. les services tels que SSH (Secure Shell) des scanners de port automatiques et des attaquants potentiels.

Cette méthode ajoute une couche de sécurité supplémentaire, car les ports nécessaires pour accéder à votre serveur, ne sont pas constamment ouverts et donc visibles.

Si vous voulez mettre ça en place, il y a différentes méthodes, mais l’une des plus faciles, c’est d’utiliser Knockr, un script écrit en Go qui s’installe comme ceci :

go install github.com/solutionroute/knockr@v0.2.0

Ou comme ceci :

git clone https://github.com/solutionroute/knockr.git
cd knockr
go install

Et qui va vous permettre de spécifier les ports à surveiller ainsi que la durée d’attente entre chaque frappe, le protocole réseau utilisé ou le temps d’attente avant l’émission d’une nouvelle séquence.

Frapper sur trois ports différents

Le comportement par défaut de l’outil knockr est de frapper sur les ports spécifiés en utilisant le protocole TCP avec un délai de 100 millisecondes entre les frappes et un délai d’expiration de 1,5 seconde pour chaque frappe. Pour frapper sur trois ports, 1234, 8923 et 1233, vous utiliseriez la commande suivante, en remplaçant hostname par le nom réseau de votre machine :

knockr hostname 1234,8923,1233

Cette commande enverra un paquet TCP SYN à chacun des ports spécifiés, en attendant une réponse avant d’envoyer le paquet suivant. Si une réponse n’est pas reçue dans les 1,5 secondes, la frappe est considérée comme infructueuse.

Frapper sur une chaîne de ports avec un protocole et un délai spécifiés

Pour spécifier un protocole et un délai différents entre les frappes, vous pouvez utiliser les options -n et -d, respectivement. Par exemple, pour frapper sur le port 22 (SSH) en utilisant le protocole UDP avec un délai de 200 millisecondes entre les frappes, vous utiliseriez la commande suivante :

knockr hostname 22 -n udp -d 200ms

Frapper sur une chaîne de ports avec un protocole, un délai et un mode silencieux spécifiés

Pour supprimer tout sauf la sortie d’erreur, vous pouvez utiliser l’option -s. Par exemple, pour frapper sur le port 22 (SSH) en utilisant le protocole TCP avec un délai de 200 millisecondes et supprimer toute sortie sauf la sortie d’erreur, vous utiliseriez la commande suivante :

knockr hostname 22 -n tcp -d 200ms -s

Il est recommandé d’inclure le ou les ports que vous vous attendez à être déverrouillés en premier et en dernier dans la chaîne pour observer leur statut avant et après le processus de frappe. Par exemple, si vous avez l’intention de déverrouiller le port 22 (SSH) sur un hôte spécifique, vous pouvez utiliser la commande suivante :

knockr hostname 22,1234,18923,1233,22

Cette commande frappera sur le port 22, attendra la réponse attendue, frappera ensuite sur les ports restants, puis vérifiera à nouveau le statut du port 22. Cela permet de garantir que les ports spécifiés sont bien déverrouillés après le processus de frappe.

Vous l’aurez compris grâce aux exemples :

• L’option -d spécifie le délai en millisecondes entre les frappes. La valeur par défaut est de 100 millisecondes.
• L’option -n spécifie le protocole à utiliser pour les frappes. Les valeurs possibles sont tcp et udp. La valeur par défaut est tcp.
• L’option -s met l’outil en mode silencieux. Cela signifie que seules les sorties d’erreur seront affichées.

À découvrir ici et bonne chance dans vos aventures de port-knocking !

On fait quand même de belles choses avec l’IA. J’en veux pour preuve ce projet open source encore au stade expérimental qui utilise un système d’IA multi agents vous permettant de poster des questions à une base PostgreSQL en langage naturel.

Propulsé par OpenAI, AutoGen, Postgres, Guidance, Aider, Poetry et Python, c’est l’un des premiers de son genre capable d’utiliser des LLMs (Large Language Modèles) pour faire de la prise de décision avec des consignes réduites ou peu explicites.

Pour vous former à cet outil nommé pompeusement « Multi-Agent Postgres Data Analytics« , son créateur a réalisé une série de vidéos que voici (c’est une playlist)…

Vous pourrez ensuite vous positionner sur une branche du projet qui correspond à une vidéo.

Pour ce faire, clonez le dépôt :

git clone https://github.com/disler/multi-agent-postgres-data-analytics.git

Puis lancez

git branch -a 

pour voir toutes les branches correspondant chacune à une vidéo de la playlist.

Faites alors un :

git checkout <nom de la branche>

pour vous positionner sur la branche de votre choix.

Puis lancez la commande :

poetry install
cp .env.sample .env 

Editez le fichier .env en y mettant l’URL de Postgres et votre clé OpenAI

Vous pourrez alors lancer un prompt sur votre base de données comme ceci :

poetry run start --prompt "<posez la question de votre choix à l'agent IA>"

Commencez par des questions simples pour prendre la température, puis montez progressivement en complexité.

Il s’agit là de construire des systèmes qui prennent des décisions comme nous le ferions, mais évidemment, tout n’est pas rose au royaume des systèmes multi-agents IA. C’est un art de bien définir les rôles et la fonction de vos agents et ça peut vite coûter cher, surtout en phase de test… donc allez y molo mais vous ne serez pas déçu.

Avec tout ce qui se passe côté OpenAI en ce moment, je suis en train de chercher des alternatives libres pour re-brancher sur mes scripts existants qui ne demandent pas trop de réécriture. C’est simplement un principe de précaution pour ne pas être pris au dépourvu si la qualité de service baisse côté ChatGPT.

Et pour ça, j’ai besoin d’un modèle de langage et d’un outil qui permette de transformer ce modèle en API que je peux appeler dans mon code.

Pour l’instant, tout ceci est en phase de R&D mais je me suis dit qu’un petit retour, ça vous ferait plaisir. Je suis donc parti sur un modèle OpenChat censé être aussi performant qu’un ChatGPT 3.5. Jusque là rien de compliqué.

J’ai donc fait tourner ce modèle dans llamacpp sans souci en mode discussion. Puis je suis parti en quête d’un bridge pour avoir des API. Je suis donc tombé sur Llama-cpp-python avec son option Server qui malheureusement n’a jamais voulu correctement fonctionner chez moi pour de sombres incompatibilités x64 / ARM64 même dans pyenv. Bref…

N’ayant pas le temps d’y passer des semaines, on m’a ensuite gentiment rappelé durant mon live Twitch, que je pouvais faire ça avec Ollama, ce que j’avais complètement zappé alors que j’ai fait une vidéo pour les Patreons à ce sujet (arf).

Puis Thoxy et LePopeye, lecteurs de Korben.info, m’ont recommandé un outil baptisé LM Studio dont je vais vous parler dans cet article.

LM Studio est un outil fonctionnant sous macOS, Windows et Linux qui permet très simplement de télécharger des LLMs (Large Language Models) et de les faire tourner en local. Ainsi vous pouvez discuter avec ces modèles via un chat comme vous le feriez avec ChatGPT.

Mais ce n’est pas tout puisque l’outil offre des tas de possibilités de réglages (y compris du support pour les Mac Silicon) pour optimiser le modèle. Et bien sûr, la fonctionnalité qui m’a le plus intéressé, c’est la possibilité de faire tourner un serveur local qui sert une API identique à celle de ChatGPT.

Cela permet, sans énormément de modifs dans votre code, de basculer des services d’OpenAI à une IA locale de manière transparente ou presque pour peut que vous utilisiez la lib OpenAI 0.28.1

pip install openai==0.28.1

Voici un code d’exemple qui montre comment l’appeler en Python :

import os
import openai

openai.api_base = "http://localhost:1234/v1" 
openai.api_key = "" 

completion = openai.ChatCompletion.create(
  model="local-model",
  messages=[
    {"role": "system", "content": "Always answer in rhymes."},
    {"role": "user", "content": "Introduce yourself."}
  ]
)

print(completion.choices[0].message)

Pas besoin de clé API donc. Et pas besoin de casser tout votre code. Suffit de migrer vers LM Studio. Puis c’est gratuit 🙂

Bref, j’ai fait mes tests comme ça et malheureusement pour le moment, c’est pas super concluant. L’outil répond correctement en version « chat » mais son paramétrage un peu différent en version serveur. Donc faut encore que je gratte un peu pour trouver le dressage optimale de mon IA. Mais j’y suis presque.

Si ça vous branche de tester LM Studio, c’est par ici que ça se passe.