Les conducteurs électriques permettent de transporter l’électricité d’un émetteur vers un récepteur. Ceux-ci doivent être les moins résistant possible au passage du courant afin d’éviter une perte de tension préjudiciable au bon fonctionnement des récepteurs surtout si ce sont des moteurs et aussi afin de limiter l’échauffement des câbles par effet Joule.
Pour éviter ce genre de problème les câbles d’une installation doivent être correctement dimensionnés.
Les trois paramètres qui influencent le dimensionnement des câbles
La nature du conducteur, meilleure est sa conductivité moins sa résistance est importante
La longueur, plus un conducteur est long plus sa résistance est grande ;
Le diamètre, la résistance d’un conducteur est inversement proportionnel au carré de son diamètre.
Les meilleurs conducteurs électriques sont l’argent, le cuivre, l’or et l’aluminium.
Estimation par le calcul
S= r * L * I / V
r : Résistivité du cuivre soit 0,021 ohms L : Longueur totale en mètre I : Courant en A (Ampère) V :Chute de tension
Abaques de section de câble (240/400 Volts)
Une abaque est un tableau sous forme graphique permettant de synthétiser différents calculs numériques avec plus ou moins de précision.
"Un abaque permet une estimation rapide, ne prend pas en compte les cas particuliers, le mode de pose, l’environnement..etc."
Les tableaux suivants sont valables pour un courant monophasé 240 V et triphasé 400 V, 240 V, le cos phi(φ) est de 0,8 (moteur électrique).
Conducteur cuivre avec une chute de tension de 3 % environ (à partir d’un réseau de distribution public à basse tension).
P : signifie puissance consommée en kilowatt (kW) I : intensité du courant en ampères (A).
Chiffres donnés à titre indicatif, doit être vérifié par le calcul.
class INA3221: def __init__(self, scl=22, sda=21, CHen="111"): # Définir les broches SCL et SDA pour le bus I2C pscl = Pin(scl) psda = Pin(sda) self.i2c = SoftI2C(scl=pscl, sda=psda, freq=400000) self.config(CHen[0],CHen[1],CHen[2])
def scan(self): # Scanner le bus I2C et afficher les adresses trouvées adresses_trouvees = self.i2c.scan() print("Adresses I2C trouvées :") for adresse in adresses_trouvees: print(f" - Adresse décimale : {adresse}") print(f" - Adresse hexadécimale : {hex(adresse)}")
def bin_to_int(self,strbin): sum = 0 puis = len(strbin)-1 for i,c in enumerate(strbin): #print(i,c) sum+= 2**(puis-i)*int(c) #a=hex(sum) #print(a) return sum
def voltmeter(self, channel=1): """Returns the channel's bus voltage in Volts""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" value_reg = self.i2c.readfrom_mem(INA3221_ADDR, BUS_VOLTAGE_CH[channel] , 2) bus_voltage = int.from_bytes(value_reg, 'big') >> 3 # Conversion en 13 bits #print(bus_voltage) # convert to volts - LSB = 8mV return bus_voltage * BUS_ADC_LSB
ina = INA3221(CHen="101") #ina.scan() #ina.read_config() while True: v1 = ina.voltmeter(3) print(v1) sleep(1) break
# Constants for manufacturer and device ID C_MANUFACTURER_ID = const(0x5449) # "TI" C_DIE_ID = const(0x3220)
# General constants C_BUS_ADC_LSB = 0.008 # VBus ADC LSB is 8mV C_SHUNT_ADC_LSB = 0.00004 # VShunt ADC LSB is 40µV
class INA3221: """Driver class for Texas Instruments INA3221 3 channel current sensor device"""
IS_FULL_API = True
@staticmethod def _to_signed(val): if val > 32767: return val - 65536 return val
@staticmethod def _to_unsigned(val): if val < 0: return val + 65536 return val
def write(self, reg, value): """Write value in device register""" seq = bytearray([reg, (value >> 8) & 0xFF, value & 0xFF]) print(reg,value,seq) self.i2c_device.write(seq)
def read(self, reg): """Return value from device register""" buf = bytearray(3) buf[0] = reg self.write_then_readinto(buf, buf, out_end=1, in_start=1) value = (buf[1] << 8) | (buf[2]) return value
def update(self, reg, mask, value): """Read-modify-write value in register""" regvalue = self.read(reg) regvalue &= ~mask value &= mask self.write(reg, regvalue | value)
def writeto_then_readfrom( self, address, buffer_out, buffer_in, *, out_start=0, out_end=None, in_start=0, in_end=None, stop=False ): """Write data from buffer_out to an address and then read data from an address and into buffer_in """ if out_end: self.i2c_device.writeto(address, buffer_out[out_start:out_end], stop) else: self.i2c_device.writeto(address, buffer_out[out_start:], stop)
if not in_end: in_end = len(buffer_in) read_buffer = memoryview(buffer_in)[in_start:in_end] self.i2c_device.readfrom_into(address, read_buffer, stop)
def write_then_readinto( self, out_buffer, in_buffer, *, out_start=0, out_end=None, in_start=0, in_end=None ): """ Write the bytes from ``out_buffer`` to the device, then immediately reads into ``in_buffer`` from the device. The number of bytes read will be the length of ``in_buffer``.
If ``out_start`` or ``out_end`` is provided, then the output buffer will be sliced as if ``out_buffer[out_start:out_end]``. This will not cause an allocation like ``buffer[out_start:out_end]`` will so it saves memory.
If ``in_start`` or ``in_end`` is provided, then the input buffer will be sliced as if ``in_buffer[in_start:in_end]``. This will not cause an allocation like ``in_buffer[in_start:in_end]`` will so it saves memory.
:param bytearray out_buffer: buffer containing the bytes to write :param bytearray in_buffer: buffer containing the bytes to read into :param int out_start: Index to start writing from :param int out_end: Index to read up to but not include; if None, use ``len(out_buffer)`` :param int in_start: Index to start writing at :param int in_end: Index to write up to but not include; if None, use ``len(in_buffer)`` """ if out_end is None: out_end = len(out_buffer) if in_end is None: in_end = len(in_buffer)
def is_channel_enabled(self, channel=1): """Returns if a given channel is enabled or not""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" bit = C_ENABLE_CH[channel] return self.read(C_REG_CONFIG) & bit != 0
def enable_channel(self, channel=1, enable=True): """Enables or disable a given channel""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" bit = C_ENABLE_CH[channel] value = 0 if enable: value = bit self.update(C_REG_CONFIG, bit, value)
def shunt_voltage(self, channel=1): """Returns the channel's shunt voltage in Volts""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" value = self._to_signed(self.read(C_REG_SHUNT_VOLTAGE_CH[channel])) / 8.0 # convert to volts - LSB = 40uV return value * C_SHUNT_ADC_LSB
def current(self, channel=1): """Return's the channel current in Amps""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" return self.shunt_voltage(channel) / self.shunt_resistor[channel-1]
def bus_voltage(self, channel=1): """Returns the channel's bus voltage in Volts""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" value = self._to_signed(self.read(C_REG_BUS_VOLTAGE_CH[channel])) / 8 # convert to volts - LSB = 8mV return value * C_BUS_ADC_LSB
def shunt_critical_alert_limit(self, channel=1): """Returns the channel's shunt voltage critical alert limit in Volts""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" value = self._to_signed(self.read(C_REG_CRITICAL_ALERT_LIMIT_CH[channel])) / 8 # convert to volts - LSB = 40uV return value * C_SHUNT_ADC_LSB
def set_shunt_critical_alert_limit(self, channel, voltage): """Sets the channel's shunt voltage critical alert limit in Volts""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" value = self._to_unsigned(round(voltage * C_SHUNT_ADC_LSB) * 8) self.write(C_REG_CRITICAL_ALERT_LIMIT_CH[channel], value)
def shunt_warning_alert_limit(self, channel=1): """Returns the channel's shunt voltage warning alert limit in Volts""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" value = self._to_signed(self.read(C_REG_WARNING_ALERT_LIMIT_CH[channel])) / 8 # convert to volts - LSB = 40uV return value * C_SHUNT_ADC_LSB
def set_shunt_warning_alert_limit(self, channel, voltage): """Sets the channel's shunt voltage warning alert limit in Volts""" assert 1 <= channel <= 3, "channel argument must be 1, 2, or 3" value = self._to_unsigned(round(voltage * C_SHUNT_ADC_LSB) * 8) self.write(C_REG_WARNING_ALERT_LIMIT_CH[channel], value)
@property def is_ready(self): """Returns the CVRF (ConVersion Ready Flag) from the mask/enable register """ regvalue = self.read(C_REG_MASK_ENABLE) print(regvalue) test = (regvalue & C_CONV_READY_FLAG) != 0x0 print(test) return test
while True: # Lecture de la tension de bus du canal 1 bus_voltage_raw = i2c.readfrom_mem(INA3221_ADDR, BUS_VOLTAGE_REG_CH1, 2) reg = int.from_bytes(bus_voltage_raw, 'big') print(reg) binary = int_to_binary(reg) print(binary) binary = binary[:-3] print(binary) volt = bin_to_int(binary) print(volt) print(volt*0.008)
## Module INA3221 (WCMCU 3221) : Moniteur de tension et de courant 3 canaux avec interface I2C
Le module INA3221 (WCMCU 3221) est un moniteur de tension et de courant polyvalent qui offre une interface I2C compatible SMBUS pour une communication facile avec les microcontrôleurs et autres systèmes embarqués. Il dispose de trois canaux indépendants pour mesurer simultanément la tension et le courant sur plusieurs charges ou alimentations.
**Fonctionnalités principales:**
* **Mesure précise de la tension et du courant :** Le INA3221 peut mesurer la tension sur les shunts de courant (In+ et In-) et la tension de bus (Vin-) pour chaque canal, permettant des calculs précis du courant et de la puissance consommés. * **Large plage de mesure :** Le module peut mesurer des tensions de bus allant de 0 V à 26 V et des courants jusqu'à 3 A (limités par la résistance de shunt). * **Interface I2C flexible :** L'interface I2C permet une communication simple et efficace avec les microcontrôleurs, offrant quatre adresses programmables (0x40, 0x41, 0x44 et 0x45) pour une configuration aisée. * **Alertes programmables :** Le INA3221 dispose de sorties d'alertes configurables (PV, CRI, WAR et TC) pour signaler les conditions hors plage et protéger vos systèmes contre les dommages. * **Consommation d'énergie optimisée :** Le module consomme un faible courant de 350 µA typiques, le rendant idéal pour les applications alimentées par batterie.
**Applications:**
* Surveillance de la consommation d'énergie dans les ordinateurs, les équipements de télécommunication, les chargeurs de batterie et les alimentations * Gestion de l'alimentation des systèmes embarqués et des circuits électroniques * Détection de pannes et protection des circuits * Test et mesure d'équipements électroniques
**Spécifications techniques:**
* Alimentation du circuit de contrôle : 2,7 V à 5,5 V * Alimentation de la charge : 0 V à 26 V * Type de sortie : Numérique * Interface de communication : I2C, compatible SMBUS * Adresses programmables : 4 (via des cavaliers) * Résistance de shunt : 0,1 Ω 1% 1 W (limite le courant maximum à moins de 3 A)
**Connexions:**
* CH1 : Sortie pour charge 1 * CH2 : Sortie pour charge 2 * CH3 : Sortie pour charge 3 * GND : Masse commune des alimentations * POW : Entrée d'alimentation pour la charge * VPU : Tension d'alimentation pull-up pour polariser les sorties * VS : Alimentation du circuit de contrôle (2,7 V à 5,5 V) * SCL : Horloge I2C * SDA : Données I2C * PV : Sortie d'alerte de tension valide (drain ouvert) * CRI : Sortie d'alerte critique (drain ouvert) * WAR : Sortie d'alerte d'avertissement (drain ouvert) * TC : Sortie d'alerte de séquence de conversion (drain ouvert)
Le module INA3221 (WCMCU 3221) offre une solution complète et économique pour la mesure précise de la tension et du courant dans une large gamme d'applications. Sa simplicité d'utilisation, sa flexibilité et sa fiabilité en font un choix idéal pour les concepteurs de systèmes embarqués et les amateurs.
L'ESP32 est une carte de développement polyvalente qui révolutionne les projets IoT et électroniques. Ce guide complet vous présente comment débuter avec cette plateforme puissante et économique.
Matériel nécessaire
Pour commencer votre aventure avec l'ESP32, vous aurez besoin de :
Une carte ESP32 ou ESP32S3
Un câble USB A/micro USB B
Un ordinateur sous Windows, Linux ou macOS
Présentation générale
L'ESP32 est une carte de développement compacte basée sur l'ESP32, fabriquée par Espressif. La majorité des broches d'entrée/sortie sont accessibles via les connecteurs situés de chaque côté, facilitant les connexions. Les développeurs peuvent soit connecter des périphériques à l'aide de fils de liaison, soit monter l'ESP32-DevKitC V4 sur une plaque d'essai.
Pour répondre à un large éventail de besoins, plusieurs versions de l'ESP32-DevKitC V4 sont disponibles :
Différents modules ESP32
ESP32
ESP32S3
ESP32C3
ESP32C6
ESP32-WROOM-32U
ESP32-SOLO-1
ESP32-WROVER-E
ESP32-WROVER-IE
Ces versions sont disponibles avec des connecteurs mâles ou femelles. Pour plus de détails, consultez le Sélecteur de Produits ESP.
Description fonctionnelle
Voici les principaux composants, interfaces et contrôles de la carte ESP32-DevKitC V4 :
Composants essentiels
ESP32-WROOM-32 : Un module avec l'ESP32 comme cœur. Pour plus d'informations, consultez la fiche technique ESP32-WROOM-32.
EN : Bouton de réinitialisation.
Boot : Bouton de téléchargement. Maintenir Boot enfoncé puis appuyer sur EN active le mode de téléchargement du firmware via le port série.
Pont USB-UART : Une puce pont USB-UART unique offrant des taux de transfert jusqu'à 3 Mbps.
Port Micro USB : Interface USB servant à la fois d'alimentation pour la carte et d'interface de communication entre un ordinateur et le module ESP32-WROOM-32.
LED d'alimentation 5V : S'allume lorsque l'USB ou une alimentation externe 5V est connectée à la carte.
E/S : La plupart des broches du module ESP sont accessibles via les connecteurs de la carte. Vous pouvez programmer l'ESP32 pour activer de multiples fonctions comme PWM, ADC, DAC, I2C, I2S, SPI, etc.
Options d'alimentation
Il existe trois façons mutuellement exclusives d'alimenter la carte :
Port Micro USB (alimentation par défaut)
Broches d'alimentation 5V et GND
Broches d'alimentation 3V3 et GND
Attention : L'alimentation doit être fournie en utilisant une seule de ces options, sinon la carte et/ou la source d'alimentation risquent d'être endommagées.
Utilisation des broches d'E/S
Les broches d'E/S sont disposées des deux côtés de la carte, chacune avec sa propre fonction spécifique. Consultez la documentation technique pour connaître le nom et la fonction de chaque broche.
Pourquoi choisir l'ESP32-DevKitC V4 pour vos projets ?
L'ESP32-DevKitC V4 se distingue par sa flexibilité, sa puissance de calcul et son prix abordable. Que vous soyez un débutant ou un expert en électronique, cette carte vous offre toutes les fonctionnalités nécessaires pour développer des applications IoT innovantes, des systèmes domotiques ou des projets de robotique.
Conclusion
L'ESP32-DevKitC V4 représente un excellent choix pour les développeurs cherchant une plateforme fiable et performante.
ESP32-DevKitC V4 is a small-sized ESP32-based development board produced by Espressif. Most of the I/O pins are broken out to the pin headers on both sides for easy interfacing. Developers can either connect peripherals with jumper wires or mount ESP32-DevKitC V4 on a breadboard.
To cover a wide range of user requirements, the following versions of ESP32-DevKitC V4 are available:
Download button. Holding down Boot and then pressing EN initiates Firmware Download mode for downloading firmware through the serial port.
USB-to-UART Bridge
Single USB-UART bridge chip provides transfer rates of up to 3 Mbps.
Micro USB Port
USB interface. Power supply for the board as well as the communication interface between a computer and the ESP32-WROOM-32 module.
5V Power On LED
Turns on when the USB or an external 5V power supply is connected to the board. For details see the schematics in Related Documents.
I/O
Most of the pins on the ESP module are broken out to the pin headers on the board. You can program ESP32 to enable multiple functions such as PWM, ADC, DAC, I2C, I2S, SPI, etc.
The pins D0, D1, D2, D3, CMD and CLK are used internally for communication between ESP32 and SPI flash memory. They are grouped on both sides near the USB connector. Avoid using these pins, as it may disrupt access to the SPI flash memory/SPI RAM.
The pins GPIO16 and GPIO17 are available for use only on the boards with the modules ESP32-WROOM and ESP32-SOLO-1. The boards with ESP32-WROVER modules have the pins reserved for internal use.
LangChain est bien plus qu'un simple framework ; c'est un écosystème complet composé de plusieurs éléments indissociables.
Tout d'abord, il y a les bibliothèques LangChain, disponibles en Python et en JavaScript. Ces bibliothèques sont la colonne vertébrale de LangChain, offrant des interfaces et des intégrations pour divers composants. Elles fournissent un environnement d'exécution de base pour combiner ces composants en chaînes et agents cohérents, ainsi que des implémentations prêtes à l'emploi pour une utilisation immédiate.
Ensuite, nous avons les modèles LangChain. Il s'agit d'un ensemble d'architectures de référence déployables et adaptées à un large éventail de tâches. Que vous construisiez un chatbot ou un outil d'analyse complexe, ces modèles offrent un point de départ solide.
LangServe intervient comme une bibliothèque polyvalente pour le déploiement des chaînes LangChain en tant qu'API REST. Cet outil est essentiel pour transformer vos projets LangChain en services Web accessibles et évolutifs.
Enfin, LangSmith sert de plate-forme de développement. Il est conçu pour déboguer, tester, évaluer et surveiller les chaînes construites sur n'importe quel framework LLM. L'intégration transparente avec LangChain en fait un outil indispensable pour les développeurs qui souhaitent affiner et perfectionner leurs applications.
Ensemble, ces composants vous permettent de développer, de mettre en production et de déployer des applications en toute simplicité. Avec LangChain, vous commencez par écrire vos applications à l'aide des bibliothèques, en vous référant aux modèles pour vous guider. LangSmith vous aide ensuite à inspecter, tester et surveiller vos chaînes, en garantissant que vos applications s'améliorent constamment et sont prêtes à être déployées. Enfin, avec LangServe, vous pouvez facilement transformer n'importe quelle chaîne en une API, ce qui rend le déploiement simple.
Dans les prochaines sections, nous approfondirons la configuration de LangChain et votre voyage vers la création d'applications intelligentes basées sur des modèles de langage.
Installation et configuration
Prêt à plonger dans l'univers de LangChain ? La configuration est simple, et ce guide vous guidera pas à pas.
La première étape de votre voyage LangChain consiste à l'installer. Vous pouvez le faire facilement en utilisant pip ou conda. Exécutez la commande suivante dans votre terminal :
``` pip install langchain ```
Pour ceux qui préfèrent les fonctionnalités les plus récentes et sont à l'aise avec un peu plus d'aventure, vous pouvez installer LangChain directement à partir de la source. Clonez le dépôt et naviguez vers le répertoire `langchain/libs/langchain`. Ensuite, lancez :
``` pip install -e . ```
Pour les fonctionnalités expérimentales, envisagez d'installer `langchain-experimental`. Il s'agit d'un package qui contient du code de pointe et est destiné à la recherche et à l'expérimentation. Installez-le en utilisant :
``` pip install langchain-experimental ```
L'interface de ligne de commande (CLI) de LangChain est un outil pratique pour travailler avec les modèles LangChain et les projets LangServe. Pour installer la CLI LangChain, utilisez :
``` pip install langchain-cli ```
LangServe est essentiel pour déployer vos chaînes LangChain en tant qu'API REST. Il est installé en même temps que la CLI LangChain.
LangChain nécessite souvent des intégrations avec des fournisseurs de modèles, des magasins de données, des API, etc. Dans cet exemple, nous utiliserons les API de modèles d'OpenAI. Installez le package Python OpenAI en utilisant :
``` pip install openai ```
Pour accéder à l'API, définissez votre clé API OpenAI en tant que variable d'environnement :
``` export OPENAI_API_KEY="votre_clé_api" ```
Vous pouvez également passer la clé directement dans votre environnement Python :
```python import os os.environ['OPENAI_API_KEY'] = 'votre_clé_api' ```
LangChain permet la création d'applications de modèles de langage via des modules. Ces modules peuvent être autonomes ou composés pour des cas d'utilisation complexes. Ces modules sont :
* **E/S de modèle** : Facilite l'interaction avec divers modèles de langage, en gérant efficacement leurs entrées et sorties. * **Récupération** : Permet l'accès et l'interaction avec des données spécifiques à l'application, cruciales pour l'utilisation dynamique des données. * **Agents** : Permet aux applications de sélectionner les outils appropriés en fonction de directives de haut niveau, améliorant ainsi les capacités de prise de décision. * **Chaînes** : Offre des compositions prédéfinies et réutilisables qui servent de blocs de construction pour le développement d'applications. * **Mémoire** : Maintient l'état de l'application sur plusieurs exécutions de chaîne, essentiel pour les interactions sensibles au contexte.
Chaque module répond à des besoins de développement spécifiques, faisant de LangChain une boîte à outils complète pour la création d'applications avancées de modèles de langage.
En plus des composants ci-dessus, nous disposons également du LangChain Expression Language (LCEL), qui est un moyen déclaratif de composer facilement des modules ensemble, et cela permet d'enchaîner des composants à l'aide d'une interface Runnable universelle.
Le LCEL ressemble à ceci :
```python from langchain.chat_models import ChatOpenAI from langchain.prompts import ChatPromptTemplate from langchain.schema import BaseOutputParser
# Exemple de chaîne chain = ChatPromptTemplate() | ChatOpenAI() | CustomOutputParser() ```
Maintenant que nous avons couvert les bases, nous allons continuer à :
* Approfondir chaque module Langchain en détail. * Apprendre à utiliser LangChain Expression Language. * Explorer les cas d'utilisation courants et les implémenter. * Déployer une application de bout en bout avec LangServe. * Découvrir LangSmith pour le débogage, les tests et la surveillance.
Commençons !
Module I : E/S de modèle
Dans LangChain, l'élément central de toute application est le modèle de langage. Ce module fournit les éléments de base essentiels pour interagir efficacement avec n'importe quel modèle de langage, garantissant une intégration et une communication fluides.
## Composants clés de l'E/S de modèle
**MLL et modèles de discussion (utilisés de manière interchangeable):**
* **MLL** : Définition : Modèles de complétion de texte brut. * Entrée/Sortie : Prendre une chaîne de texte en entrée et renvoyer une chaîne de texte en sortie. * **Modèles de discussion** : Définition : Modèles qui utilisent un modèle de langage comme base, mais diffèrent des formats d'entrée et de sortie. * Entrée/Sortie : Accepter une liste de messages de discussion en entrée et renvoyer un message de discussion.
**Paramètres:** Modéliser, sélectionner dynamiquement et gérer les entrées du modèle. Permet la création d'invites flexibles et contextuelles qui guident les réponses du modèle de langage.
**Analyseurs de sortie:** Extraire et formater les informations des sorties du modèle. Utile pour convertir la sortie brute des modèles de langage en données structurées ou en formats spécifiques nécessaires à l'application.
Intégration de LangChain avec les MLL**
L'intégration de LangChain avec les grands modèles de langage (MLL) comme OpenAI, Cohere et Hugging Face est un aspect fondamental de sa fonctionnalité. LangChain lui-même n'héberge pas de MLL, mais offre une interface uniforme pour interagir avec divers MLL.
Cette section donne un aperçu de l'utilisation de l'encapsuleur OpenAI LLM dans LangChain, applicable également à d'autres types de MLL. Nous l'avons déjà installé dans la section "Démarrage". Initialisons le MLL.
python from langchain.llms import OpenAI llm = OpenAI() ```
# LLMs implémentent l'interface Runnable, l'élément de base du LangChain Expression Language (LCEL). Cela signifie qu'ils prennent en charge les appels `invoke`, `ainvoke`, `stream`, `astream`, `batch`, `abatch`, `astream_log`.
# Les MLL acceptent des chaînes de caractères en entrée, ou des objets qui peuvent être transformés en chaînes d'invite, y compris `List[BaseMessage]` et `PromptValue` (plus de détails plus tard).
# Voyons quelques exemples.
response = llm.invoke("Lister les sept merveilles du monde.") print(response)
# Vous pouvez également appeler la méthode `stream` pour diffuser la réponse textuelle en continu.
for chunk in llm.stream("Où se sont tenus les Jeux olympiques de 2012 ?"): print(chunk, end="", flush=True)
3.2. Modèles de discussion
L'intégration de LangChain avec les modèles de discussion, une variante spécialisée des modèles de langage, est essentielle pour la création d'applications de chat interactives. Bien qu'ils utilisent des modèles de langage en interne, les modèles de discussion présentent une interface distincte centrée sur les messages de chat comme entrées et sorties. Cette section fournit un aperçu détaillé de l'utilisation du modèle de discussion OpenAI dans LangChain.
python
from langchain_community.chat_models import ChatOllama
chat = ChatOllama(model=model_name)
Les modèles de discussion dans LangChain fonctionnent avec différents types de messages tels que AIMessage, HumanMessage, SystemMessage, FunctionMessage et ChatMessage (avec un paramètre de rôle arbitraire). En général, HumanMessage, AIMessage et SystemMessage sont les plus fréquemment utilisés.
Les modèles de discussion acceptent principalement des listes de `BaseMessage` en entrée. Les chaînes de caractères peuvent être converties en `HumanMessage`, et `PromptValue` est également pris en charge.
python from langchain.schema.messages import HumanMessage, SystemMessage messages = [ SystemMessage(content="Vous êtes Micheal Jordan."), HumanMessage(content="À quel fabricant de chaussures êtes-vous associé ?"), ] response = chat.invoke(messages) print(response.content)
3.3. Prompts : Invite de commandes
Les invites de commande sont essentielles pour guider les modèles de langage vers la génération de sorties pertinentes et cohérentes. Elles peuvent aller de simples instructions à des exemples complexes à quelques coups. Dans LangChain, la gestion des invites de commande peut être un processus très rationalisé grâce à plusieurs classes et fonctions dédiées.
La classe `PromptTemplate` de LangChain est un outil polyvalent pour créer des invites de commande sous forme de chaîne de caractères. Elle utilise la syntaxe `str.format` de Python, permettant la génération dynamique d'invites de commande. Vous pouvez définir un modèle avec des espaces réservés et les remplir avec des valeurs spécifiques selon vos besoins.
```python from langchain.prompts import PromptTemplate
# Invite de commande simple avec des espaces réservés prompt_template = PromptTemplate.from_template( "Raconte-moi une blague {adjective} sur {content}." )
# Remplir les espaces réservés pour créer une invite de commande filled_prompt = prompt_template.format(adjective="drôle", content="robots") print(filled_prompt) ```
Pour les modèles de chat, les invites de commande sont plus structurées et impliquent des messages avec des rôles spécifiques. LangChain propose `ChatPromptTemplate` à cet effet.
```python from langchain.prompts import ChatPromptTemplate
# Définition d'une invite de commande de chat avec différents rôles chat_template = ChatPromptTemplate.from_messages( [ ("système", "Vous êtes un assistant AI serviable. Votre nom est {name}."), ("humain", "Bonjour, comment allez-vous ?"), ("ia", "Je vais bien, merci !"), ("humain", "{user_input}"), ] )
# Formatage de l'invite de commande de chat formatted_messages = chat_template.format_messages(name="Bob", user_input="Quel est votre nom ?") for message in formatted_messages: print(message) ```
Cette approche permet la création de chatbots interactifs et engageants avec des réponses dynamiques.
`PromptTemplate` et `ChatPromptTemplate` s'intègrent parfaitement au LangChain Expression Language (LCEL), ce qui leur permet de faire partie de workflows plus vastes et complexes. Nous en discuterons plus en détail plus tard.
Des modèles d'invite de commande personnalisés sont parfois essentiels pour des tâches nécessitant un formatage unique ou des instructions spécifiques. La création d'un modèle d'invite de commande personnalisé implique la définition de variables d'entrée et d'une méthode de formatage personnalisée. Cette flexibilité permet à LangChain de répondre à un large éventail d'exigences spécifiques aux applications. En savoir plus ici: link to LangChain documentation about custom prompt templates.
LangChain prend également en charge les invites de commande à quelques coups, permettant au modèle d'apprendre à partir d'exemples. Cette fonction est essentielle pour les tâches nécessitant une compréhension contextuelle ou des modèles spécifiques. Les modèles d'invite de commande à quelques coups peuvent être construits à partir d'un ensemble d'exemples ou en utilisant un objet `ExampleSelector`. En savoir plus ici: link to LangChain documentation about few-shot prompting.
**Analyseurs de sortie**
Les analyseurs de sortie jouent un rôle crucial dans Langchain, permettant aux utilisateurs de structurer les réponses générées par les modèles de langage. Dans cette section, nous explorerons le concept d'analyseurs de sortie et fournirons des exemples de code en utilisant `PydanticOutputParser`, `SimpleJsonOutputParser`, `CommaSeparatedListOutputParser`, `DatetimeOutputParser` et `XMLOutputParser` de LangChain.
3.4. PydanticOutputParser : Parseur de sortie Pydantic
Langchain fournit le `PydanticOutputParser` pour analyser les réponses en structures de données Pydantic. Voici un exemple pas à pas de son utilisation :
python from typing import List from langchain_community.llms import Ollama from langchain.output_parsers import PydanticOutputParser from langchain.prompts import PromptTemplate from langchain.pydantic_v1 import BaseModel, Field, validator
# Initialize the language model model = Ollama(model = model_name, temperature=0)
# Define your desired data structure using Pydantic class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke")
@validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field
# Set up a PydanticOutputParser parser = PydanticOutputParser(pydantic_object=Joke)
# Create a prompt with format instructions prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, )
# Define a query to prompt the language model query = "Tell me a joke."
# Combine prompt, model, and parser to get structured output prompt_and_model = prompt | model output = prompt_and_model.invoke({"query": query})
# Parse the output using the parser parsed_result = parser.invoke(output)
# The result is a structured object print(parsed_result)
**Sortie attendue :**
... (résultat de l'impression de l'objet `parsed_result`)
3.5 SimpleJsonOutputParser en français
Le `SimpleJsonOutputParser` de Langchain est utilisé lorsque vous souhaitez analyser des sorties de type JSON. Voici un exemple :
```python
from langchain.output_parsers.json import SimpleJsonOutputParser from langchain_community.llms import Ollama
model = Ollama(model = model_name, temperature=0)
# Create a JSON prompt json_prompt = PromptTemplate.from_template( "Return a JSON object with `birthdate` and `birthplace` key that answers the following question: {question}" )
# Initialize the JSON parser json_parser = SimpleJsonOutputParser()
# Create a chain with the prompt, model, and parser json_chain = json_prompt | model | json_parser
# Stream through the results result_list = list(json_chain.stream({"question": "When and where was Elon Musk born?"}))
# The result is a list of JSON-like dictionaries print(result_list)
```
**Explications techniques:**
* Le code utilise la bibliothèque Langchain et son analyseur `SimpleJsonOutputParser` pour traiter des sorties en format JSON. * Un modèle `json_prompt` est créé pour spécifier la structure de la sortie JSON souhaitée, incluant les clés "date_de_naissance" et "lieu_de_naissance". * L'analyseur `json_parser` est initialisé pour traiter les sorties JSON. * Une chaîne est construite en reliant le modèle, le modèle de langage (représenté par "model") et l'analyseur. * La méthode `stream` est utilisée pour parcourir les résultats de la chaîne, en fournissant la question "Quand et où est né Elon Musk ?" comme entrée. * Le résultat final est une liste de dictionnaires contenant les informations demandées, au format JSON.
3.6. CommaSeparatedListOutputParser en français
Le `CommaSeparatedListOutputParser` de Langchain est pratique pour extraire des listes séparées par des virgules des réponses des modèles de langage. Voici un exemple :
```python from langchain.output_parsers import CommaSeparatedListOutputParser from langchain.prompts import PromptTemplate from langchain.llms import OpenAI (remplacer par le modèle de langage que vous utilisez)
# Obtenir les instructions de formatage de l'analyseur instructions_formatage = analyseur_liste_virgule.get_format_instructions()
# Créer un modèle demandant une liste modele = PromptTemplate( modèle="Lister cinq {sujet}.\n{instructions_formatage}", variables_entrantes=["sujet"], variables_partielles={"instructions_formatage": instructions_formatage} )
# Définir une requête pour le modèle requete = "Equipes de Premier League anglaise"
# Générer la sortie sortie = model(modele.format(sujet=requete))
# Analyser la sortie à l'aide de l'analyseur resultat_analyse = analyseur_liste_virgule.parse(sortie)
# Le résultat est une liste d'éléments print(resultat_analyse) ```
**Explications techniques:**
* Le code utilise la bibliothèque Langchain et son analyseur `CommaSeparatedListOutputParser` pour extraire des listes séparées par des virgules des réponses d'un modèle de langage. * Un modèle `modele` est créé pour formuler la requête demandant une liste au modèle, en incluant les instructions de formatage fournies par l'analyseur. * L'analyseur `analyseur_liste_virgule` est initialisé pour traiter les sorties contenant des listes séparées par des virgules. * Une requête "Equipes de Premier League anglaise" est définie pour être fournie au modèle. * La méthode `model` (remplacez par le modèle de langage que vous utilisez) génère la sortie en réponse à la requête et au modèle. * La sortie est ensuite analysée par `analyseur_liste_virgule.parse` pour extraire la liste des éléments. * Le résultat final est une liste contenant les éléments extraits de la réponse du modèle.
3.7. DatetimeOutputParser
Le `DatetimeOutputParser` de Langchain est conçu pour analyser les informations de date et d'heure. Voici comment l'utiliser :
```python from langchain.prompts import PromptTemplate from langchain.output_parsers import DatetimeOutputParser from langchain.chains import LLMChain from langchain.llms import OpenAI (remplacer par le modèle de langage que vous utilisez)
# Initialiser le DatetimeOutputParser analyseur_datetime = DatetimeOutputParser()
# Créer un modèle avec des instructions de formatage modele = PromptTemplate.from_template( modele=""" Répondez à la question de l'utilisateur : {question} {instructions_formatage} """, variables_partielles={"instructions_formatage": analyseur_datetime.get_format_instructions()}, )
# Créer une chaîne avec le modèle et le modèle de langage chaine = LLMChain(prompt=modele, llm=OpenAI()) # Remplacer 'OpenAI' par le modèle à utiliser
# Définir une requête pour interroger le modèle requete = "Quand Neil Armstrong a-t-il atterri sur la Lune en termes de GMT ?"
# Exécuter la chaîne sortie = chaine.run(requete)
# Analyser la sortie à l'aide de l'analyseur datetime resultat_analyse = analyseur_datetime.parse(sortie)
# Le résultat est un objet datetime print(resultat_analyse) ```
**Explications techniques:**
* Le code utilise la bibliothèque Langchain et son analyseur `DatetimeOutputParser` pour extraire des informations de date et d'heure des réponses d'un modèle de langage. * Un modèle `modele` est créé pour formuler la requête demandant une information de date et d'heure au modèle, en incluant les instructions de formatage fournies par l'analyseur. * L'analyseur `analyseur_datetime` est initialisé pour traiter les sorties contenant des informations de date et d'heure. * Une requête "Quand Neil Armstrong a-t-il atterri sur la Lune en termes de GMT ?" est définie pour interroger le modèle. * La chaîne `chaine` exécute le modèle avec la requête et génère la sortie. * La sortie est ensuite analysée par `analyseur_datetime.parse` pour extraire l'objet datetime. * Le résultat final est un objet datetime représentant la date et l'heure extraites de la réponse du modèle.
**Conclusion**
Ces exemples illustrent comment les analyseurs de sortie de Langchain peuvent être utilisés pour structurer différents types de réponses de modèles, les rendant adaptés à différentes applications et formats. Les analyseurs de sortie sont un outil précieux pour améliorer la convivialité et l'interprétabilité des sorties de modèles de langage dans Langchain.
**Nanonets : Automatisation des tâches et workflows avec l'IA**
Nanonets propose un outil de création de workflows basé sur l'IA, conçu pour automatiser les tâches manuelles et les workflows au sein de vos équipes. Pour en savoir plus, vous pouvez consulter la documentation ou demander une démonstration.
En poursuivant votre navigation sur mon site,
vous acceptez l’utilisation des Cookies et autres traceurs
pour réaliser des statistiques de visites et enregistrer
sur votre machine vos activités pédagogiques.En savoir plus.
