Nous utilisons des cookies pour vous garantir la meilleure expérience sur notre site. Si vous continuez à utiliser ce dernier, nous considèrerons que vous acceptez l'utilisation des cookies. J'ai compris ! ou En savoir plus !.
Un Planet est un site Web dynamique qui agrège le plus souvent sur une seule page, le contenu de notes, d'articles ou de billets publiés sur des blogs ou sites Web afin d'accentuer leur visibilité et de faire ressortir des contenus pertinents aux multiples formats (texte, audio, vidéo, Podcast). C'est un agrégateur de flux RSS. Il s'apparente à un portail web.
Vous pouvez lire le billet sur le blog La Minute pour plus d'informations sur les RSS !
  • Canaux
  • Categories
  • Tags

    • Canaux

    2801 éléments (130 non lus) dans 55 canaux

    Dans la presse Dans la presse

    Neogeo Technologies (4 non lus)

    • 29 April 2024

    • sur Découvrez les Réseaux de Neurones – Le Cerveau de l’IA

      Publié: 29 April 2024, 9:10am CEST par admin

      Mais, bien plus encore, ces réseaux de neurones sont également utilisés pour classifier des données ou bien effectuer des prévisions. Ils sont également très utilisés dans le domaine du traitement du langage ou bien celui de la vision par ordinateur, notamment en robotique. Les réseaux de neurones sont donc présents partout autour de nous.

      Cependant, vous ne savez peut-être pas ce qui se cache derrière ces réseaux qui peuvent paraître très obscurs et complexes. Si vous souhaitez comprendre et utiliser ces systèmes de détection, classification et prédiction, il vous faudra d’abord appréhender la notion de réseaux de neurones. Pour cela, nous allons développer un exemple concret.

      Exemple concret – Classification d’une image

      Un réseau de neurones peut par exemple être utilisé pour classer une image dans telle ou telle catégorie. Un exemple concret pourrait être l’application de cette technologie à la détection et la classification des sols sur des images satellites.

      L’idée est donc de donner une image en entrée du réseau de neurones et que celui-ci classe cette image dans la catégorie “urbain” ou bien « rural” par exemple. Le problème revient donc à se poser la question suivante : « Mon image représente-t-elle une zone urbaine ? »

      Si l’on crée le réseau et qu’on donne tout de suite notre image en entrée, on aura un résultat aléatoire, aberrant et très peu exact. Il faut donc entraîner notre réseau avec un jeu de données pour lui apprendre à bien classifier les images. On lui donne donc beaucoup d’images de zones urbaines et rurales pour lui apprendre à les différencier correctement.

      Il existe différentes méthodes d’apprentissage mais la plus répandue (et simple à la compréhension) est l’apprentissage supervisé. Cela consiste à donner le résultat attendu en même temps que la donnée d’entrée. Plus concrètement, chaque image est annotée avec la catégorie “urbain” ou “rural” afin que le réseau puisse confirmer ses résultats et ainsi apprendre de ses erreurs. C’est cette méthode d’apprentissage qui sera expliquée par la suite.

      Un réseau de neurones est basé sur le fonctionnement du cerveau humain. Il est donc composé de plusieurs neurones reliés entre eux de la façon suivante :

      Comme on peut le voir, les neurones sont divisés en 3 familles :

      – les entrées : inputs

      – les neurones des couches cachées : hidden layers

      – les sorties : outputs

      Dans notre réseau nous avons : 2 inputs, 1 hidden layer avec 3 neurones et 1 output.

      Il est cependant possible d’avoir autant de neurones que l’on veut dans chaque famille ; on peut également avoir plusieurs couches cachées.

      Une fois le réseau créé, on peut maintenant s’intéresser à son fonctionnement qui consiste en deux phases : la phase de feed forward et celle de back propagation.

      La phase de feed forward consiste à introduire les données en entrée du réseau et de les propager à travers celui-ci. Pour résumer, à chaque couche on calcule la somme pondérée des entrées puis cette valeur est transmise via une fonction d’activation. On reproduit ensuite le processus jusqu’à la couche de sortie. Cette phase est donc celle de prédiction et est utilisée pour l’inférence.

      La phase de back propagation arrive une fois la prédiction effectuée. On calcule alors l’erreur entre la sortie prédite et la sortie réelle. Puis cette dernière est propagée dans le réseau et les poids sont ajustés au fur et à mesure pour minimiser cette erreur.

      L’apprentissage consiste donc en une multitude de cycles : feed forward + back propagation.

      Nous allons maintenant observer la phase de feed forward plus en détails. Cette étape commence par donner une première fois des données en entrée de notre réseau. Chaque neurone de la couche inputs se voit donc affecté d’une valeur. Dans notre cas “Mon image représente-t-elle une zone urbaine ?” on aura des valeurs numériques entre 0 et 1 (probabilité que l’image présente une zone rurale) :

      Les valeurs sont ensuite transmises aux neurones de la couche suivante par les connexions :

      Les neurones de la deuxième couche fusionnent donc les valeurs des neurones de la couche précédente. La valeur fusionnée obtenue peut ensuite être modifiée en interne par le neurone :

      Puis les neurones de la deuxième couche transmettent à leur tour la valeur modifiée à la couche suivante :

      De la même façon, le(s) neurone(s) de la couche finale (outputs), peu(ven)t modifier en interne la valeur reçue avant de la retourner :

      Une fois la valeur finale obtenue, on a fini la passe de feed forward.

      En réalité, la transmission des valeurs est un peu plus complexe. C’est ce qu’on va détailler par la suite. Pour bien comprendre la transmission, on va se limiter à 3 neurones.

      La transmission des valeurs va dépendre de « l’épaisseur » du lien entre les neurones. Plus le lien est épais, plus la valeur passe dans son intégralité et inversement. Cette épaisseur est appelée poids ou weight et est différente pour chaque lien, comme visible sur l’image suivante :

      Ainsi, chaque neurone n’a pas le même poids / la même importance dans le réseau.

      On va maintenant voir comment le neurone peut changer en interne la valeur qu’il reçoit avant de la transmettre. Concrètement, le neurone possède une fonction, dite fonction d’activation, qui sert à déterminer si la valeur doit ou non passer au prochain neurone. Si le résultat de la fonction est proche de 1, la valeur passera et s’il est proche de 0, la valeur ne passera pas.

      Il existe une multitude de fonctions d’activation mais les plus utilisées sont :

      – Sigmoid

      – Unité linéaire rectifiée (Rectified Linear Unit : ReLU)

      – Tangente Hyperbolique (tanh)

      – Linear

      Le neurone a également la possibilité d’ajouter un biais en entrée de la fonction d’activation, ce qui permet au neurone d’avoir de l’influence sur l’activation :

      Pour résumer :

      – on a un ensemble de neurones

      – on entre les données dans les neurones inputs

      – on lie les couches de neurones avec un certain poids

      – on ajoute des biais, qui sont multipliés par leur propre poids

      – on ajoute les valeurs pour avoir les nouvelles valeurs

      – on fait passer les nouvelles valeurs dans la fonction d’activation

      – on récapitule pour le dernier neurone

      On obtient finalement le résultat.

      Cependant, comme on initialise les biais et les poids aléatoirement, il y a peu de chance pour que le réseau soit performant.

      On va alors passer notre résultat dans une fonction d’erreur. Cette fonction prend en entrée notre résultat et la valeur attendue. Cela nous permet de déterminer la précision de notre réseau.

      On va ensuite réaliser la deuxième étape : la passe de back propagation. De manière très simple, cette étape consiste à déterminer comment on doit modifier les poids de notre réseau pour faire diminuer au maximum notre erreur. Dans la pratique, on modifie un poids à la fois et très peu pour déterminer l’influence de chaque poids sur notre réseau en fonction de son impact sur l’erreur. Cette étape est réalisée par les dérivées de tous les calculs fait lors de la phase de feed forward.

      Conclusion

      Nous avons découvert ce qui se cache derrière un réseau de neurones, son fonctionnement basique ainsi que ses applications diverses. Les réseaux de neurones offrent de nombreuses possibilités pour le domaine de la géomatique avec l’analyse et l’interprétation des données spatiales. La capacité de ces derniers à apprendre à partir de données brutes en fait un outil puissant pour la prédiction, la classification, et même la génération de nouvelles données géospatiales. Cependant, il est essentiel de se rappeler que, malgré leur potentiel, les réseaux de neurones ne sont pas une solution miracle et peuvent présenter des défis en pratique. Il est notamment important de rappeler que la qualité et la quantité des données sont primordiales afin d’obtenir des résultats fiables et significatifs. Finalement, il est également essentiel de noter que l’utilisation efficace des réseaux de neurones nécessite souvent des capacités de calcul élevées et des ensembles de données volumineux.

      Rédactrice : Mathilde POMMIER

    • 04 April 2024

    • sur Votre application est-elle compatible avec la licence Affero GPL 3.0??? 

      Publié: 4 April 2024, 9:00am CEST par admin

      Lors du changement de licence sur OneGeo Suite, il est important d’examiner la compatibilité des dépendances avec Affero GPL. Au vu des implications qui en découlent, est-il surtout possible de vérifier que nos dépendances aient toujours une licence conforme ? 

      La compatibilité entre les licences? 

      La compatibilité de licences inclut deux éléments clé à prendre en compte :  

      • Le projet en lui-même (ex : un module Python, une bibliothèque de fonctions, etc.) ; 
      • Un travail dérivé (ex : un logiciel complet comme FireFox). Les travaux dérivés d’un projet, quant à eux, peuvent être des modifications du code du projet ou des produits intégrant le projet. 

      Une compatibilité des licences sera possible lorsque le travail dérivé possède une licence qui n’enfreint pas les règles de la licence du projet. 

      Les licences « copyleft » obligent à redistribuer les travaux dérivés sous la même licence (ou une compatible) pour protéger les libertés du code et de l’utilisateur. A contrario, les licences permissives autorisent le changement de licence, et il est également possible de faire un produit propriétaire, en intégrant des composants sous ce type de licence. Par exemple, Sony base son système d’exploitation propriétaire de la Playstation sur FreeBSD, qui est un logiciel libre sous licence FreeBSD.? 

      Source : [https:] (Creative Commons BY-SA-3.0)? 

      Dans ce schéma, le code en domaine public est intégrable dans un produit MIT, lui-même dans un produit sous licence BSD, lui-même dans un produit licence Apache 2.0, et ainsi de suite jusqu’à la licence Affero GPL 3. 

      Deux catégories supplémentaires sont introduites par ce schéma?: 

      • Weakly protective (faiblement protectrice)?: elle implique qu’une modification du code doit être sous la même licence (donc rester libre). Néanmoins, l’intégration du projet peut se faire dans un produit sous une autre licence (même propriétaire). 
      • Network Protective (protectrice des utilisateurs réseau)?: la licence GPL protège les utilisateurs de la machine. Dans le cadre d’applications client-serveur, la partie serveur protège l’utilisateur du serveur, donc l’administrateur système. Une conformité à la GPL existe dans le cas où l’administrateur système de OneGeo Suite a accès aux sources modifiées du produit, mais pas l’utilisateur de la partie client. Les licences Network Protective permet aussi de protéger la liberté des utilisateurs du client. 

      Notez bien les versions des licences : par exemple la licence Apache 2.0 est compatible avec la licence LGPL, alors que la version 1.1 ne l’est pas. 

      Pour vous aiguiller, voici quelques incompatibilités à souligner?: 

      • Apache 1.1 ou MPL 1.1 (Mozilla Public Licence) ne sont pas compatibles avec les licences GPL, alors qu’une clause explicite de compatibilité existe dans les versions 2.0 de ces mêmes licences ; 
      • CC-BY-3.0?empêche de changer la licence, donc impossible à changer en AGPL. La version 4.0 permet explicitement de changer la licence en GPL 3.0 et donc en AGPL 3.0 ; 
      • Licence originelle BSD?: elle forçait à indiquer une notice de copyright dans la documentation du produit final, ce qui peut poser problème quand il y a de nombreux composants avec cette licence dans un produit. 
      Vérifier la conformité

      En pratique, la conformité de licence peut se vérifier grâce au DevOps.  

      Pour illustrer nos projets, essentiellement en Python et Javascript, nous vous présentons deux outils simples qui pourront vous aider. Dans ces exemples, nous nous en servirons en ligne de commande, afin de comparer les licences des dépendances avec une liste validée de licences.? 

      Vérification des licences en Python? 

      L’outil « pylic » analyse tous les modules Python installés dans l’environnement virtuel et compare leurs licences avec une section du pyproject.toml. S’il trouve un module avec une licence non validée, il sort en émettant erreur que l’on pourra exploiter dans une CI. 

      Commençons par installer le programme?:? 

      $ pip install pylic? 

      Ensuite, nous indiquons à “pylic” les licences compatibles avec notre logiciel, en lui donnant une liste de licences compatibles AGPL 3.0, dans la section tool.pylic de notre pyproject.toml : 

      $ cat << EOF >> pyproject.toml?
[tool.pylic]? 
safe_licenses = [? 
"Apache Software License", 
"BSD License",? 
"BSD",?  
"MIT License",? 
"MIT",?  
"Mozilla Public License 2.0 (MPL 2.0)",?
"GNU Library or Lesser General Public License (LGPL)",?
"GNU Lesser General Public License v3 or later (LGPLv3+)",? 
? "Python Software Foundation License",? 
"Historical Permission Notice and Disclaimer (HPND)"? 
? ]? 
EOF? 

      Vous remarquerez que ces licences ont parfois des noms très similaires. En effet, “pylic”  s’appuie sur le nom déclaré par le mainteneur du module python (dans le setup.cfg/setup.py…) qui n’est pas normalisé. Nous devons déclarer comme « safe » les deux identifiants « MIT » et « MIT License », alors que nous aurions pu utiliser les identifiants de licence SPDX dans la configuration du module Python. 

      Revenons à “pylic” et lançons une vérification : 

      $ pylic check? 
✨ All licenses ok ✨? 

      Comment peut-on faire en cas de non-conformité ?  

      En commentant la licence « Apache Software License » de pyproject.toml, nous obtenons ce message : 

      $ pylic check? 
Found unsafe licenses:?
? nltk (3.8.1): Apache Software License? 
? phonenumbers (8.13.8): Apache Software License? 
? importlib-metadata (6.1.0): Apache Software License
? bleach (6.0.0): Apache Software License? 
? cryptography (42.0.1): Apache Software License? 
? regex (2023.12.25): Apache Software License?
? django-onegeo-suite (1.0.2): Apache Software License?
? requests (2.31.0): Apache Software License? 
? packaging (23.2): Apache Software License?
? pyOpenSSL (24.0.0): Apache Software License?
? tzdata (2023.4): Apache Software License? 
? elasticsearch (7.17.9): Apache Software License?
? async-timeout (4.0.3): Apache Software License?
? josepy (1.14.0): Apache Software License? 
? django-onegeo-rproxy-mapstore2 (1.0.0b2): Apache Software License? 

      Plutôt simple, non??? 

       

      Vérification des licences en Javascript? 

      De la même façon, on peut vérifier les licences des projets javascript avec license-checker. ilIl n’est toujours pas au courant des licences qui existent donc il faudra construire la liste à la main.? 

      L’utilisation est plutôt simple?:? 

      $ npx license-checker --onlyAllow "CC-BY-4.0;ISC;Apache-2.0;BSD-3-Clause;Custom: [https:] Domain;CC0-1.0;MPL-2.0" --production?? 

      Package « @fortawesome/fontawesome-common-types@0.2.36 » is licensed under « MIT » which is not permitted by the –onlyAllow flag. Exiting.? 

      ?On obtient des erreurs pour chaque licence non autorisée.? 

      L’option «?–onlyAllow?» permet de lister les licences autorisées séparées par des point virgules «?;?». Tandis que l’option «?–production?» permet d’écarter les licences des modules de la section «?devDependencies?» du package.json.? 

      Pensez aussi à corriger la section «?license?» du package.json pour ne pas perturber l’outil?:? 

      ? "license": "AGPL-3.0-only",? 

      Je vous conseille aussi d’ajouter un script dans le package.json pour automatiser les vérifications?:? 

      cat package.json??
{? 
[...]? 
? "scripts": {?
[...]??? "lint": "vue-cli-service lint",? 
??? "license-checker": "license-checker --onlyAllow \"MIT;CC-BY-4.0;ISC;Apache-2.0;BSD-3-Clause;Custom: [https:] Domain;CC0-1.0;MPL-2.0\" --production"
? },? 

      On peut ainsi lancer simplement?:? 

      $ npm run? license-checker? 

       

      Conclusion? 

      Il existe probablement des outils plus sophistiqués pour vérifier la compatibilité des licences des bibliothèque externes utilisées par votre projet, notamment en utilisant la matrice de compatibilité des licences de l’OSADL?: [https:]] ? 

      Mais pour une utilisation légère et rapide dans une CI, ces deux outils feront l’affaire, en investissant néanmoins un peu de temps pour vérifier les nouvelles licences qui peuvent apparaître pendant la vie de votre projet.? ? 

      Sources?:? 

      [https:]] ?: image compatibilité? 

      [https:]] ?: informations sur les compatibilités avec la GPL? 

      [https:]] : compatibilité Apache 2.0 et GPL? 

      [https:]] : utilisation de license-checker? 

       

      Rédacteur : Sébastien DA ROCHA 

       

    • 26 March 2024

    • sur Le changement de licence OneGeo Suite

      Publié: 26 March 2024, 8:00am CET par admin

      Aujourd’hui, l’implication de NEOGEO dans la communauté géomatique prend une autre dimension. En adoptant la licence Affero GPL pour nos logiciels OneGeo Suite et GeoContrib, nous souhaitons renforcer cet engagement. 

      Pourquoi ce changement ? 

      À travers l’adoption de cette nouvelle licence, l’objectif est double : 

      1. Protéger les innovations : Nous souhaitons garantir que les développements réalisés par Neogeo et nos clients demeurent libres. Cette démarche permet de préserver la richesse et la valeur ajoutée de notre travail. 

      2. Partager et collaborer : Lorsqu’un acteur, issu ou non du monde de la géomatique, décide de s’appuyer sur nos travaux, ses contributions seront accessibles à toute la communauté. C’est un cercle vertueux : plus nous collaborons, plus le logiciel s’enrichit pour le bénéfice de tous. 

      Ce changement sera effectif à partir de la version OneGeo Suite 1.1 et pour la version stable GeoContrib 5.4.

      Les 4 libertés du logiciel libre : Un rappel essentiel 

      La notion de logiciel libre repose sur 4 libertés fondamentales : 

      • Le droit d’utiliser le logiciel sans restriction 
      • Le droit d’étudier le logiciel 
      • Le droit de diffuser le logiciel 
      • Le droit de modifier le logiciel et de diffuser les modifications 

      Le Copyleftt : En la matière, le copyleft est un gage d’égalité et de liberté qui vise à empêcher la restriction des droits des utilisateurs.  

      Le logiciel peut être modifié mais sa licence doit rester compatible, tout en conservant notamment le droit de copier le code source.  Le copyleft garantit donc que les logiciels libres le restent. 

      Les licences libres en un coup d’œil

      Il existe actuellement plusieurs licences libres : 

      • Apache : Une licence permissive qui autorise la modification de la licence des fichiers modifiés exclusivement. 
      • GPL : Sans doute la licence libre la plus populaire et le pilier du copyleft. Elle exige que les produits dérivés et programmes associés adoptent une licence compatible, garantissant les mêmes droits aux utilisateurs. 
      • LGPL : Une variante de la GPL, la LGPL offre plus de flexibilité sur l’intégration du code dans un produit sous une autre licence (même non libre) tout en restant compatible avec la GPL. 
      • Affero GPL : La principale différence entre la GPL et l’AGPL réside dans la façon dont elles traitent l’utilisation du logiciel sur des serveurs distants. L’AGPL a été créée pour s’assurer que les services Web basés sur des logiciels libres donnent accès au code source aux utilisateurs distants (même s’ils n’ont pas téléchargé le logiciel).
      Des licences pas si libres

      D’autres licences sont également disponibles mais plus contraignantes en matière de libertés :  

      • SSPL (Server Side Public License) : utilisée par MongoDB et ElasticSearch, la licence limite la mise à disposition d’un logiciel sur des hébergeurs Cloud. Elle vise essentiellement les géants du cloud comme AWS. La plupart des utilisateurs peuvent continuer d’utiliser MongoDB et ElasticSearch comme avant. Cette licence n’est pas reconnue par l’OSI (Open Source Initiative) comme « open source » et celle-ci est parfois critiquée pour ses exigences jugées excessives ; 
      • Freemium (ou shareware) : les logiciels sont gratuits mais le plus souvent non modifiables 
      • CLAs (Contributor License Agreements) : À l’instar d’une NDA (Non Disclosure Agreement), l’agrément doit être signé par les contributeurs afin de céder leurs droits. Cette licence permet également à l’entreprise d’utiliser les contributions d’une manière qui ne serait pas permise par la licence open source sous laquelle le logiciel est publié (ex : changer de licence). 

      Le passage des solutions sur cette nouvelle licence traduit notre volonté de renforcer la liberté, la collaboration et l’innovation dans le domaine géomatique. Nous souhaitons également que ce changement profite à toute la communauté, ainsi que les évolutions qui en découleront.   

      Rédacteur : Sébastien DA ROCHA 

    • 05 February 2024

    • sur GPT, capturez-les tous !

      Publié: 5 February 2024, 4:12pm CET par admin

      ChatGPT est un agent conversationnel qui peut vous aider au quotidien. Néanmoins, vous ne savez pas réellement ce que OpenAI, son créateur, fait de vos conversations. Il n’est, d’ailleurs, pas conseillé de lui parler de sujets confidentiels.

      Si vous souhaitez l’utiliser dans vos produits, l’API peut rapidement coûter très cher (compter environ 3 centimes pour le traitement de cet article par exemple, multiplié par le nombre de requêtes par utilisateur, multiplié par les demandes de chaque utilisateur…). Heureusement, la communauté Open Source propose petit à petit des alternatives.

      La première étape était la publication de Llama par Meta (Facebook). Il s’agit d’un modèle d’intelligence presque libre et limité à 500 millions d’utilisateurs. Au-delà, il faut les contacter pour avoir le droit de l’utiliser. Il est également possible de le récupérer sur nos ordinateurs et de s’en servir de façon strictement privée.

      Pour télécharger le modèle, il faut néanmoins montrer patte blanche en remplissant un formulaire et recevoir un lien, par mail, avec une durée de vie limité. En cas d’expérimentation, cela peut vite devenir contraignant.

      Démocratisation technique

      Les développeurs de llama.cpp (surtout Georgi GERGANOV) ont optimisé ce moteur qui vous permet de discuter avec les modèles Llama2.

      Les modèles de Llama2

      Llama2 est disponible en plusieurs tailles (nombre de paramètres) : 7B, 13B et 70B. L’unité « B » correspond à des milliards de paramètres.  

      Sachant que chaque paramètre est stocké sur 2 octets (des flottants de demi-précision), il faut au moins 16Go de RAM pour charger le petit modèle 7B. Les gros modèles sont plus pertinents, mais beaucoup plus lents. 

      Les optimisations

      Les développeurs de LLama.cpp ont travaillé sur 2 optimisations :

        • Pouvoir lancer les calculs (appelés «?inférence?») sur le CPU en utilisant au maximum ses capacités (optimisation M1, AVX-512 ou AVX2…) et en codant le moteur d’inférence en C++ et sûrement des morceaux en assembleur? ;
        • Compresser le modèle sans trop perdre de pertinence.

      Pour ce dernier point, ils ont développé un codage flottant du 4bits : q4_0 (d’autres variantes avec plus de bits existent). Nous pouvons désormais utiliser un modèle 7B avec 4Go de RAM?! À noter que l’on peut tout de même un peu perdre en pertinence.

      Le travail de llama.cpp est prodigieux mais difficile à utiliser : il arrive que le modèle réponde de manière erronée ou ne rende pas la main après la réponse.

      Ollama

      Désormais la relève existe : Ollama !

      Considéré comme le docker des LLM, il nous permet de télécharger, questionner, supprimer des modèles en une ligne de commande. Concernant les performances, Ollama est une surcouche en Go et utilise llama.cpp.

      Les instructions d’installation sont disponibles ici : [https:]

      Une fois installé, vous pouvez télécharger un modèle aussi simplement que :

      ollama pull llama2

      Une fois téléchargé, vous pouvez le questionner comme ceci :

      ollama run llama2
>>> comment faire une jointure entre 2 dataframes Pandas ?
There are several ways to join two pandas DataFrames. Here are a few methods:

1. `merge()`: This is the most common method for joining two DataFrames. It joins the two DataFrames based on a common column, called the "join key". The joined DataFrame will have the columns from both DataFrames.
"`
df_left = pd.read_csv('left_data.csv')
...

      Attention, Ollama installe aussi un service Systemd en arrière plan. Si vous préférez le lancer à la main, au hasard pour contrôler la RAM de disponible sur votre machine :

      # désactiver le démarrage auto avec la machine
sudo systemctl disable ollama.service
# Couper réellement le service 
sudo systemctl stop ollama.service
      Quel modèle ?

      Llama a apporté son lot de révolutions, mais d’autres équipes de chercheurs ont repris le flambeau, notamment Mistral AI qui a réussi à créer des petits modèles très efficaces.

      Récemment, Hugging Face (l’équivalent de Github dans la sphère IA) a encore amélioré Mistral en créant Zephyr, un petit modèle qui a de très bons résultats pour parler dans plusieurs langues.

      $ ollama run zephyr:7b
>>> comment faire une jointure entre 2 dataframes Pandas ?
Pour joindre deux DataFrames en Pandas, vous pouvez utiliser la méthode `merge()`. Ci-dessous une explication de comment utiliser cette méthode :

1. Assurez-vous que les deux DataFrames ont une colonne commune sur laquelle joindre les données. Soit df1 et df2, on appellera cette colonne 'common_column'.
...

      Zephyr n’a pas de clause de restriction à 500 millions d’utilisateurs (licence Apache 2.0), il répond en français et sera plus économe en ressources. 

      Ci-dessous, une liste de quelques modèles : 

      S’il en détecte un, Ollama va automatiquement utiliser le GPU. Sinon, il se rabat sur le CPU en essayant de tirer parti des instructions disponibles (AVX2, AVX512, NEON pour les M1/M2…)

      Docker

      Si vous utilisez l’image docker de Ollama, il faut penser à couper le service Ollama ou à changer de port TCP d’écoute dans le docker-compose.yaml.

      Voici un docker-compose minimaliste :

      ---
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama
    restart: unless-stopped

volumes:
  ollama:

      Ensuite, un petit docker compose up -d pour lancer le serveur.

      Comment pouvons-nous lancer une inférence ?

      $ docker compose exec ollama ollama run zephyr:7b
>>> Salut
Bonjour,

Je suis heureux d'aider quelqu'un aujourd'hui. Votre expression "Salut" est une forme courante de salutation en français. En France, c'est souvent utilisé entre amis ou entre personnes qui connaissent déjà l'un l'autre. Dans les 
situations où vous souhaitez être plus formel ou professionnel, vous pouvez utiliser "Bonjour" ou "Bonsoir" suivi du prénom de la personne ou simplement "Madame" ou "Monsieur" si vous ne connaissez pas le prénom.

J'espère que cela vous a été utile. Si vous avez d'autres questions, n'hésitez pas à me contacter.

Bien à vous,
[Votre nom]
>>>

      En revanche, utiliser la console de l’image n’est pas pratique, sauf si vous souhaitez télécharger une image et plus jamais y retoucher. Et surtout, nous pouvons utiliser l’API HTTP :

      $ curl -X POST [localhost:11435] -d '{ "model": "zephyr:7b", "prompt": "raconte moi une courte histoire drôle"}'
{"model":"zephyr:7b","created_at":"2024-01-11T15:27:47.516708062Z","response":"Il","done":false}
{"model":"zephyr:7b","created_at":"2024-01-11T15:27:47.534749456Z","response":" y","done":false}
...

      Pour faciliter la lecture de l’inférence, vous pouvez afficher le texte token par token dans notre app. Il est également possible de s’en servir en python. Voici un exemple de client inclut dans le dépôt :

      [https:]]

      Il est toujours possible d’utiliser le client installé précédemment ollama en ligne de commande, pour requêter le serveur à distance :

      $ OLLAMA_HOST=127.0.0.1:11435 ollama run zephyr:7b-beta-q6_K "raconte moi une courte histoire drôle"
      Docker et l’accélération avec une carte graphique Nvidia

      Vous remarquerez que l’inférence dans le docker n’est pas très rapide. En effet, docker ne laisse pas le container accéder à la carte graphique, par conséquent l’inférence se fait sur le CPU.

      Pour cela, il faut installer un paquet fourni par Nvidia afin de configurer le docker proprement :

      $ curl -fsSL [https:] | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L [https:] | \
    sed 's#deb [https:] [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] [https:] | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

$ apt update
$ apt install -y nvidia-container-toolkit

      Une fois ce paquet installé, il faut utiliser l’outil fournit pour configurer docker :

      $ nvidia-ctk runtime configure --runtime=docker

      Cela va modifier votre configuration de docker /etc/docker/daemon.json pour activer un runtime nvidia :

      {
	"runtimes": {
		"nvidia": {
			"args": [],
			"path": "nvidia-container-runtime"
		}
	}
}

      Ensuite, il suffit de redémarrer docker :

      $ systemctl restart docker

      Désormais, vous devriez pouvoir accéder à votre GPU Nvidia depuis le container :

      $ docker run --rm --runtime=nvidia --gpus all ubuntu nvidia-smi
Unable to find image 'ubuntu:latest' locally
latest: Pulling from library/ubuntu
a48641193673: Already exists 
Digest: sha256:6042500cf4b44023ea1894effe7890666b0c5c7871ed83a97c36c76ae560bb9b
Status: Downloaded newer image for ubuntu:latest
Thu Jan 11 15:46:38 2024       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 525.147.05   Driver Version: 525.147.05   CUDA Version: 12.0     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ...  On   | 00000000:2D:00.0  On |                  N/A |
| 31%   33C    P5    32W / 225W |   1778MiB /  8192MiB |      2%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
+-----------------------------------------------------------------------------+

      Une fois cela terminé, l’accès doit être donné à votre container en modifiant le docker-compose.yaml:

      ---
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11435:11434"
    volumes:
      - ollama:/root/.ollama
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: [gpu]
              count: all


volumes:
  ollama:

      Grâce au docker compose up -d, notre inférence est désormais beaucoup plus rapide.

      Conclusion

      Nous avons découvert comment utiliser les LLM libre, avec des projets comme Ollama et Zephyr, qui rendent l’IA plus démocratique et accessible à un plus grand nombre. Plus besoin de se soucier des coûts prohibitifs de l’API OpenAI, lorsque vous pouvez exploiter ces modèles de langage gratuits et Open source.

      Que vous soyez un développeur, un chercheur ou un professionnel de l’IA, Ollama offre des opportunités passionnantes pour innover, créer et résoudre des problèmes. Le monde de l’IA est désormais entre vos mains.

      Sources

      [https:]]

      [https:]]

      [https:]]

      [https:]]

      [https:]]

       

      Rédacteur : Sébastien DA ROCHA

       

    • sur GPT, capturez-les tous !

      Publié: 5 February 2024, 9:00am CET par admin

      ChatGPT est un agent conversationnel qui peut vous aider au quotidien. Néanmoins, vous ne savez pas réellement ce que OpenAI, son créateur, fait de vos conversations. Il n’est, d’ailleurs, pas conseillé de lui parler de sujets confidentiels.

      Si vous souhaitez l’utiliser dans vos produits, l’API peut rapidement coûter très cher (compter environ 3 centimes pour le traitement de cet article par exemple, multiplié par le nombre de requêtes par utilisateur, multiplié par les demandes de chaque utilisateur…). Heureusement, la communauté Open Source propose petit à petit des alternatives.

      La première étape était la publication de Llama par Meta (Facebook). Il s’agit d’un modèle d’intelligence presque libre et limité à 500 millions d’utilisateurs. Au-delà, il faut les contacter pour avoir le droit de l’utiliser. Il est également possible de le récupérer sur nos ordinateurs et de s’en servir de façon strictement privée.

      Pour télécharger le modèle, il faut néanmoins montrer patte blanche en remplissant un formulaire et recevoir un lien, par mail, avec une durée de vie limité. En cas d’expérimentation, cela peut vite devenir contraignant.

      Démocratisation technique

      Les développeurs de llama.cpp (surtout Georgi GERGANOV) ont optimisé ce moteur qui vous permet de discuter avec les modèles Llama2.

      Les modèles de Llama2

      Llama2 est disponible en plusieurs tailles (nombre de paramètres) : 7B, 13B et 70B. L’unité « B » correspond à des milliards de paramètres.

      Sachant que chaque paramètre est stocké sur 2 octets (des flottants de demi-précision), il faut au moins 16Go de RAM pour charger le petit modèle 7B. Les gros modèles sont plus pertinents, mais beaucoup plus lents.

      Les optimisations

      Les développeurs de LLama.cpp ont travaillé sur 2 optimisations :

      • Pouvoir lancer les calculs (appelés « inférence ») sur le CPU en utilisant au maximum ses capacités (optimisation M1, AVX-512 ou AVX2…) et en codant le moteur d’inférence en C++ et sûrement des morceaux en assembleur ;
      • Compresser le modèle sans trop perdre de pertinence.

      Pour ce dernier point, ils ont développé un codage flottant du 4bits : q4_0 (d’autres variantes avec plus de bits existent). Nous pouvons désormais utiliser un modèle 7B avec 4Go de RAM ! À noter que l’on peut tout de même un peu perdre en pertinence.

      Le travail de llama.cpp est prodigieux mais difficile à utiliser : il arrive que le modèle réponde de manière erronée ou ne rende pas la main après la réponse.

      Ollama

      Désormais la relève existe : Ollama !

      Considéré comme le docker des LLM, il nous permet de télécharger, questionner, supprimer des modèles en une ligne de commande. Concernant les performances, Ollama est une surcouche en Go et utilise llama.cpp.

      Les instructions d’installation sont disponibles ici : [https:]] .

      Une fois installé, vous pouvez télécharger un modèle aussi simplement que :

      ollama pull llama2

      Une fois téléchargé, vous pouvez le questionner comme ceci :

      ollama run llama2

>>> comment faire une jointure entre 2 dataframes Pandas ?

There are several ways to join two pandas DataFrames. Here are a few methods:

1. `merge()`: This is the most common method for joining two DataFrames. It joins the two DataFrames based on a common column, called the "join key". The joined DataFrame will have the columns from both DataFrames.

```

df_left = pd.read_csv('left_data.csv')

...

      Attention, Ollama installe aussi un service Systemd en arrière-plan. Si vous préférez le lancer manuellement, au hasard pour contrôler la RAM de disponible sur votre machine, vous devez :

      # désactiver le démarrage auto avec la machine

sudo systemctl disable ollama.service

# Couper réellement le service

sudo systemctl stop ollama.service
      Quel modèle ?

      Llama a apporté son lot de révolutions, mais d’autres équipes de chercheurs ont repris le flambeau, notamment Mistral AI qui a réussi à créer des petits modèles très efficaces.

      Récemment, Hugging Face (l’équivalent de Github dans la sphère IA) a encore amélioré Mistral en créant Zephyr, un petit modèle qui a de très bon résultats pour parler dans plusieurs langues.

      ollama run zephyr:7b

>>> comment faire une jointure entre 2 dataframes Pandas ?

Pour joindre deux DataFrames en Pandas, vous pouvez utiliser la méthode `merge()`. Ci-dessous une explication de comment utiliser cette méthode :

1. Assurez-vous que les deux DataFrames ont une colonne commune sur laquelle joindre les données. Soit df1 et df2, on appellera cette colonne 'common_column'.

...

      Zephyr n’a pas de clause de restriction à 500 millions d’utilisateurs (licence Apache 2.0), il répond en français et sera plus économe en ressources.

      Ci-dessous, une liste de quelques modèles :

      S’il en détecte un, Ollama va automatiquement utiliser le GPU. Sinon, il se rabat sur le CPU en essayant de tirer parti des instructions disponibles (AVX2, AVX512, NEON pour les M1/M2…)

      Docker

      Si vous utilisez l’image docker de Ollama, il faut penser à couper le service Ollama ou à changer de port TCP d’écoute dans le docker-compose.yaml.

      Voici un docker-compose minimaliste :

      ---

version: '3.8'

services:

  ollama:

    image: ollama/ollama:latest

    ports:

      - "11434:11434"

    volumes:

      - ollama:/root/.ollama

    restart: unless-stopped

volumes:
  ollama:

      Ensuite, un petit docker compose up -d pour lancer le serveur.

      Comment pouvons-nous alors lancer une inférence ?

      $ docker compose exec ollama ollama run zephyr:7b

>>> Salut

Bonjour,

Je suis heureux d'aider quelqu'un aujourd'hui. Votre expression "Salut" est une forme courante de salutation en français. En France, c'est souvent utilisé entre amis ou entre personnes qui connaissent déjà l'un l'autre. Dans les situations où vous souhaitez être plus formel ou professionnel, vous pouvez utiliser "Bonjour" ou "Bonsoir" suivi du prénom de la personne ou simplement "Madame" ou "Monsieur" si vous ne connaissez pas le prénom.

J'espère que cela vous a été utile. Si vous avez d'autres questions, n'hésitez pas à me contacter.

Bien à vous,

[Votre nom]

>>> 

      En revanche, utiliser la console de l’image n’est pas pratique, sauf si vous souhaitez télécharger une image et plus jamais y retoucher. Et surtout, nous pouvons utiliser l’API HTTP :

      curl -X POST [localhost:11435] -d '{ "model": "zephyr:7b", "prompt": "raconte moi une courte histoire drôle"}'

{"model":"zephyr:7b","created_at":"2024-01-11T15:27:47.516708062Z","response":"Il","done":false}

{"model":"zephyr:7b","created_at":"2024-01-11T15:27:47.534749456Z","response":" y","done":false}

...

      Pour faciliter la lecture de l’inférence, vous pouvez afficher le texte token par token dans notre app. Il est également possible de s’en servir en python. Voici un exemple de client inclut dans le dépôt :

      [https:]]

      Il est toujours possible d’utiliser le client installé précédemment ollama en ligne de commande, pour requêter le serveur à distance :

      OLLAMA_HOST=127.0.0.1:11435 ollama run zephyr:7b-beta-q6_K "raconte moi une courte histoire drôle"
      Docker et l’accélération avec une carte graphique Nvidia

      Vous remarquerez que l’inférence dans le docker n’est pas très rapide. En effet, docker ne laisse pas le container accéder à la carte graphique, par conséquent l’inférence se fait sur le CPU.

      Pour cela, il faut installer un paquet fourni par Nvidia afin de configurer le docker proprement :

      curl -fsSL [https:] | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \

  && curl -s -L [https:] | \

    sed 's#deb [https:] [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] [https:] | \

    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

apt update

apt install -y nvidia-container-toolkit

      Une fois ce paquet installé, il faut utiliser l’outil fournit pour configurer docker :

      sudo nvidia-ctk runtime configure --runtime=docker

      Cela va modifier votre configuration de docker /etc/docker/daemon.json pour activer un runtime nvidia :

      {

        "runtimes": {

               "nvidia": {

                       "args": [],

                       "path": "nvidia-container-runtime"

               }

        }

}

      Ensuite, il suffit de redémarrer docker :

      systemctl restart docker

      Désormais, vous devriez pouvoir accéder à votre GPU Nvidia depuis le container :

      $ docker run --rm --runtime=nvidia --gpus all ubuntu nvidia-smi

Unable to find image 'ubuntu:latest' locally

latest: Pulling from library/ubuntu

a48641193673: Already exists

Digest: sha256:6042500cf4b44023ea1894effe7890666b0c5c7871ed83a97c36c76ae560bb9b

Status: Downloaded newer image for ubuntu:latest

Thu Jan 11 15:46:38 2024      

+-----------------------------------------------------------------------------+

| NVIDIA-SMI 525.147.05   Driver Version: 525.147.05   CUDA Version: 12.0     |

|-------------------------------+----------------------+----------------------+

| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |

| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |

|                               |                      |               MIG M. |

|===============================+======================+======================|

|   0  NVIDIA GeForce ...  On   | 00000000:2D:00.0  On |                  N/A |

| 31%   33C    P5    32W / 225W |   1778MiB /  8192MiB |      2%      Default |

|                               |                      |                  N/A |

+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+

| Processes:                                                                  |

|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |

|        ID   ID                                                   Usage      |

|=============================================================================|

+-----------------------------------------------------------------------------+

      Une fois cela terminé, l’accès doit être donnée à votre container en modifiant le docker-compose.yaml:

      ---

version: '3.8'

services:

  ollama:

    image: ollama/ollama:latest

    ports:

      - "11435:11434"

    volumes:

      - ollama:/root/.ollama

    restart: unless-stopped

    deploy:

      resources:

        reservations:

          devices:

            - driver: nvidia

              capabilities: [gpu]

              count: all

volumes:

  ollama:

      Grâce au docker compose up -d, notre inférence est désormais beaucoup plus rapide.

      Conclusion

      Nous avons découvert comment utiliser les LLM libre, avec des projets comme Ollama et Zephyr, qui rendent l’IA plus démocratique et accessible à un plus grand nombre. Plus besoin de se soucier des coûts prohibitifs de l’API OpenAI, lorsque vous pouvez exploiter ces modèles de langage gratuits et Open source.

      Que vous soyez un développeur, un chercheur ou un professionnel de l’IA, Ollama offre des opportunités passionnantes pour innover, créer et résoudre des problèmes. Le monde de l’IA est désormais entre vos mains.

      Sources :

      [https:]]

      [https:]]

      [https:]]

      [https:]]

      [https:]]

      Rédacteur : Sébastien DA ROCHA 

    • 31 August 2023

    • sur Séminaire, octobre 2022

      Publié: 31 August 2023, 10:13am CEST par admin

      Brainstorming, ateliers de travail, balade en fat bike sur la plage…

      L’air marin a permis aux collaborateurs de faire émerger de nouvelles idées qui confirment la vision commune des deux entreprises.

      Retour en images sur le séminaire organisé pour les équipes de GEOFIT GROUP et de NEOGEO.

       

    • sur Atelier avec le SMEAG

      Publié: 31 August 2023, 10:13am CEST par admin

      En janvier dernier s’est déroulé un atelier avec les équipes du SMEAG – Syndicat Mixte d’Études et d’Aménagement de la Garonne.

      L’objectif était de présenter la maquette réalisée dans le cadre de la refonte de leur site internet. Le résultat a été très ???????, les personnes présentes ont approuvées le parcours utilisateur et le design associé.

      Nos équipes de production travaillent désormais sur la ????????????? et le ?????????????? du site.

       

    • sur OneGeo Suite, interview GIP ATGERI

      Publié: 31 August 2023, 10:09am CEST par admin

      Lors des Geo Data Days 2022, nous avons eu l’occasion d’interviewer AnneSAGOT Responsable du Pôle PIGMA, et Emeric PROUTEAU, Référent technique, à propos de la mise en place d’une nouvelle plateforme de données en Nouvelle-Aquitaine.

      Ce projet, porté par nos équipes et le GIP ATGeRi, s’est passé «?????? ??? ??? ????????? », malgré les contraintes et imprévus que l’on vous laisse découvrir…

       

    • sur L’Open Source

      Publié: 31 August 2023, 10:08am CEST par admin

      Chez Neogeo, nous marchons à l’Open Source ! Mais qu’est ce que l’Open Source ?
      En quelques slides, découvrez l’un de nos domaines d’expertise.

      Voir l’article

       

    ← Data and GIS tips ReLucBlog →