RAG con Ollama Gemma2 e LangChain

Aggiornamento:

Per poter avere le risposte in italiano (al posto dell'inglese di default) basta modificare il context template

 <|context|>
You are an AI assistant that follows instruction extremely well.
Please be truthful and give direct answers
Answer in italian
</s>

questa la risposta alla domanda "Descrivimi il monopoly"

Monopoly è un gioco da tavolo di strategia e fortuna.

I giocatori comprano, vendono e scambiano proprietà immobiliari sul tabellone, cercando di accumulare il maggior patrimonio possibile.  

Si lanciano i dadi per muoversi sul tabellone, acquistando le caselle che incontrano. Alcune caselle comportano pagamenti o attività specifiche, come andare in prigione o pagare tasse.  

Il gioco prosegue finché tutti tranne uno dei giocatori sono falliti a causa del debito. Il vincitore è il giocatore che rimane con denaro e proprietà alla fine.

Per la cronaca il Pdf delle istruzioni di Monopoly era in inglese 

=========================================  

 Seguendo un po' la moda del momento volevo provare a fare una applicazione RAG (Retrieval Augmented Generation) partendo dal modello  Gemma2 di Google e dandogli in pasto dei Pdf personali per il retraining. Per questa prova ho sentito le indicazioni contenute in questo notebook

Prima cosa: per usare Gemma2 la macchina deve avere almeno 9 Gb di ram liberi (giusto per la cronaca per usare il modello LLama 70b sono necessari almeno 40 Gb di ram liberi..diciamo che non se ne parla nemmeno)

Secondo: per installare i modelli la cosa piu' comodo e' utilizzare Ollama

Terzo : molti esempi si basano su API esterne come https://jina.ai/, OpenAI, ma in questo caso ci sono pacchetti gratuiti e poi si deve pagare il servizio. Cercavo di mettere in piedi una soluzione offline svincolata da servizi cloud di terze parti

Si scaricano quindi il modello ed un text encoder (in questo caso Nomic-Embed-Text)

ollama pull gemma2 

ollama pull nomic-embed-text

Si installa poi i pacchetti delle librerie (meglio in un venv)

pip install langchain chromadb langchain_community pypdf

ChromaDb e' il database in cui vengono salvati i vectorstore per garantire la persistenza dell'apprendimento. E' in pratica un Db orientato all'AI basato su sqlite; una alternativa con un vero server e' Milvus

I file PDF devono essere inseriti nel folder ./Pdf

# -*- coding: utf-8 -*-

from langchain_community.document_loaders import PyPDFDirectoryLoader

from langchain.text_splitter import CharacterTextSplitter,RecursiveCharacterTextSplitter

from langchain_community.embeddings import OllamaEmbeddings

from langchain.vectorstores import Chroma

from langchain_community.llms import Ollama

from langchain.chains import RetrievalQA, LLMChain

import pathlib

import textwrap

from IPython.display import display

from IPython.display import Markdown

def to_markdown(text):

text = text.replace('•', ' *')

return Markdown(textwrap.indent(text, '> ', predicate=lambda _: True))

loader = PyPDFDirectoryLoader("./Pdf")

docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)

chunks = text_splitter.split_documents(docs)

embeddings = OllamaEmbeddings(model="nomic-embed-text")

vectorstore = Chroma.from_documents(chunks, embeddings)

query = "who is at risk of heart disease"

search = vectorstore.similarity_search(query)

to_markdown(search[0].page_content)

"""## Retriever"""

retriever = vectorstore.as_retriever(

search_kwargs={'k': 5}

)

retriever.get_relevant_documents(query)

"""## Large Language Model - Open Source

## RAG Chain

"""

from langchain_community.llms import Ollama

llm = Ollama(model="gemma2")

from langchain.schema.runnable import RunnablePassthrough

from langchain.schema.output_parser import StrOutputParser

from langchain.prompts import ChatPromptTemplate

template = """

<|context|>

You are an AI assistant that follows instruction extremely well.

Please be truthful and give direct answers

</s>

<|user|>

{query}

</s>

<|assistant|>

"""

prompt = ChatPromptTemplate.from_template(template)

rag_chain = (

{"context": retriever, "query": RunnablePassthrough()}

| prompt

| llm

| StrOutputParser()

)

response = rag_chain.invoke("why should I care about my heart health")

to_markdown(response)

import sys

while True:

user_input = input(f"Input Prompt: ")

if user_input == 'exit':

print('Exiting')

sys.exit()

if user_input == '':

continue

result = rag_chain.invoke(user_input)

print("Answer: ",result)

Ho inserito due Pdf (regole di Monopoly e Ticket to Ride), questo un esempio di interazione

===========================================

Input Prompt: give me the rules of Monopoly
Answer:  ##  Monopoly Rules (Simplified):

**Goal:** Be the last player standing with money! Drive your opponents into bankruptcy by buying properties, building houses and hotels, and charging rent.

**Gameplay:**

1. **Roll Dice & Move:** Players roll two dice and move their piece around the board clockwise.
2. **Land on Property?**
    * **Unowned:** You can buy it for the listed price.
    * **Owned:** Pay rent to the owner based on the property's value and any buildings.
3. **Chance & Community Chest:** Draw a card and follow its instructions. These can be good or bad!
4. **Go To Jail:**  Land on "Go To Jail," draw a "Go To Jail" card, or roll doubles three times in a row. While in jail, you can't collect rent or move until you pay a fine, use a "Get Out of Jail Free" card, or roll doubles.
5. **Build Houses & Hotels:** Once you own all properties in a color group, you can start building houses and hotels. These increase rent significantly!
6. **Bankruptcy:** If you can't afford to pay your debts, you're bankrupt and out of the game.

**Key Elements:**

* **Properties:** Divided into color groups, each with different rent values.
* **Railroads & Utilities:** Pay rent based on dice rolls.
* **Taxes:**  Pay a set amount when landing on specific spaces.
* **Free Parking:** A safe space where you can collect any "Free Parking" money (rules vary).


**Variations:**

Many variations of Monopoly exist, with different rules and themes. Be sure to clarify the specific rules being used before starting a game!

Let me know if you'd like more detail on any specific aspect of the rules!

===========================================

Adesso rendiamo le cose piu' difficili...domanda in italiano e richiesta di trovare le differenze tra i due giochi. La domanda viene correttamente interpretata anche se in italiano ed in effetti la risposta fa una sintesi delle differenze tra i due giochi

===========================================

Answer:  Here are the key differences between Monopoly and Ticket to Ride:

**Monopoly:**

* **Goal:** Become the richest player by buying properties, developing them, and charging rent to other players.
* **Gameplay:**  Players roll dice, move around a board, buy properties, build houses and hotels, and collect rent from opponents who land on their spaces.
* **Emphasis:**  Strategic property acquisition, negotiation, and bankrupting opponents.

**Ticket to Ride:**

* **Goal:** Score the most points by claiming railway routes connecting cities across a map.
* **Gameplay:** Players draw colored train cards and use them to claim routes. Longer routes earn more points, and completing destination tickets (secret routes) awards bonus points.
* **Emphasis:** Route building, strategic card management, and fulfilling destination goals.


**In short:** Monopoly is about accumulating wealth and bankrupting opponents, while Ticket to Ride is about building railway networks and strategically claiming routes. 

Antitaccheggio

Mentre ero fuori per lavoro mi sono comprato un metro a nastro perche' lo avevo dimenticato....tornato a casa (e lontano qualche decina di Km) mi sono accorto che era rimasto l'antitaccheggio...tornare indietro era fuori discussione e cosi' e' partito il tentativo di rimuoverlo da solo

 

Pensavo fosse del tipo magnetico ma dopo un po' di studio ho visto che era di tipo meccanico e si doveva inserire una lama ricurva per sganciare il fermo...piu' semplice aprirlo dalla saldatura

Il sistema di ritenzione del perno e' molto semplice ma dannatamente efficace..in pratica l'ago si inserisce in una asola a coda di rondine

Nella parte allungata e' invece inserito un magnete con un avvolgimento in rame (con i due capi isolati tra di loro)

Questo e' il componente che innesca l'allarme

 

 

 

 

 

Aruco Tag con Opencv (nuova versione)

Ho riscritto per la nuova versione di OpenCV il programma di estrazione dei dati degli Aruco Tag

Il programma e' completamente parametrizzato (con valori di default) ed ha un output in csv in cui sono inserite le coordinate 2D immagine, coordinate 3D nel sistema di riferimento della camera, angoli di roll,pitch ed yaw

 

from os import listdir
from os.path import isfile, join

import numpy as np
import argparse
import cv2
import sys
import math
import os

ARUCO_DICT = {
    "DICT_4X4_50": cv2.aruco.DICT_4X4_50,
    "DICT_4X4_100": cv2.aruco.DICT_4X4_100,
    "DICT_4X4_250": cv2.aruco.DICT_4X4_250,
    "DICT_4X4_1000": cv2.aruco.DICT_4X4_1000,
    "DICT_5X5_50": cv2.aruco.DICT_5X5_50,
    "DICT_5X5_100": cv2.aruco.DICT_5X5_100,
    "DICT_5X5_250": cv2.aruco.DICT_5X5_250,
    "DICT_5X5_1000": cv2.aruco.DICT_5X5_1000,
    "DICT_6X6_50": cv2.aruco.DICT_6X6_50,
    "DICT_6X6_100": cv2.aruco.DICT_6X6_100,
    "DICT_6X6_250": cv2.aruco.DICT_6X6_250,
    "DICT_6X6_1000": cv2.aruco.DICT_6X6_1000,
    "DICT_7X7_50": cv2.aruco.DICT_7X7_50,
    "DICT_7X7_100": cv2.aruco.DICT_7X7_100,
    "DICT_7X7_250": cv2.aruco.DICT_7X7_250,
    "DICT_7X7_1000": cv2.aruco.DICT_7X7_1000,
    "DICT_ARUCO_ORIGINAL": cv2.aruco.DICT_ARUCO_ORIGINAL,
    "DICT_APRILTAG_16h5": cv2.aruco.DICT_APRILTAG_16h5,
    "DICT_APRILTAG_25h9": cv2.aruco.DICT_APRILTAG_25h9,
    "DICT_APRILTAG_36h10": cv2.aruco.DICT_APRILTAG_36h10,
    "DICT_APRILTAG_36h11": cv2.aruco.DICT_APRILTAG_36h11
}

def isRotationMatrix(R):
    Rt = np.transpose(R)
    shouldBeIdentity = np.dot(Rt, R)
    I = np.identity(3, dtype=R.dtype)
    n = np.linalg.norm(I - shouldBeIdentity)
    return n < 1e-6

def rotationMatrixToEulerAngles(R):
    assert (isRotationMatrix(R))
    sy = math.sqrt(R[0, 0] * R[0, 0] + R[1, 0] * R[1, 0])
    singular = sy < 1e-6
    if not singular:
        x = math.atan2(R[2, 1], R[2, 2])
        y = math.atan2(-R[2, 0], sy)
        z = math.atan2(R[1, 0], R[0, 0])
    else:
        x = math.atan2(-R[1, 2], R[1, 1])
        y = math.atan2(-R[2, 0], sy)
        z = 0
    return np.array([x, y, z])


def estrai_parametri(img):
    # inserire qui il ciclo per le img
    image = cv2.imread(img)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    ArucoParams = cv2.aruco.DetectorParameters()
    ArucoParams.cornerRefinementMethod = 0

    R_flip = np.zeros((3, 3), dtype=np.float32)
    R_flip[0, 0] = 1.0
    R_flip[1, 1] = -1.0
    R_flip[2, 2] = -1.0

    Adict = cv2.aruco.getPredefinedDictionary(ARUCO_DICT[args["type"]])
    detector = cv2.aruco.ArucoDetector(Adict, ArucoParams)
    corners, ids, _ = cv2.aruco.detectMarkers(image, Adict, parameters=ArucoParams)

    if len(corners) > 0:
        x_sum = corners[0][0][0][0] + corners[0][0][1][0] + corners[0][0][2][0] + corners[0][0][3][0]
        y_sum = corners[0][0][0][1] + corners[0][0][1][1] + corners[0][0][2][1] + corners[0][0][3][1]
        x_centerPixel = x_sum / 4
        y_centerPixel = y_sum / 4

        # print(corners) #posizione degli angoli del marker
        for i in range(0, len(ids)):
            rvec, tvec, markerPoints = cv2.aruco.estimatePoseSingleMarkers(corners[i], float(args["aruco_dim"]), k, d)
            # distanza dalla camera
            dist = math.sqrt(
                (tvec[0][0][0] * tvec[0][0][0]) + (tvec[0][0][1] * tvec[0][0][1]) + (tvec[0][0][2] * tvec[0][0][2]))
            str_dist = "{:4.2f}".format(dist)

            R_ct = np.matrix(cv2.Rodrigues(rvec)[0])
            R_ct = R_ct.T
            roll_marker, pitch_marker, yaw_marker = rotationMatrixToEulerAngles(R_flip * R_ct)
            str_roll = "%4.2f" % (math.degrees(roll_marker))
            str_pitch = "%4.2f" % (math.degrees(pitch_marker))
            str_yaw = "%4.2f" % (math.degrees(yaw_marker))

            if (int(args["tag"]) > 0):
                if (int(ids[i]) == int(args["tag"])):
                    f.write(str(ids[i]) + ";" + str(x_centerPixel) + ";" + str(y_centerPixel) + ";" + str(
                        tvec[0][0][0]) + ";" + str(tvec[0][0][1]) + ";" + str(tvec[0][0][2]) + ";" + os.path.basename(img) + ";" + str_roll + ";" + str_pitch + ";" + str_yaw+"\n")
            else:
                f.write(str(ids[i]) + ";" + str(x_centerPixel) + ";" + str(y_centerPixel) + ";" + str(
                    tvec[0][0][0]) + ";" + str(tvec[0][0][1]) + ";" + str(tvec[0][0][2]) + ";" + os.path.basename(img) + ";" + str_roll + ";" + str_pitch + ";" + str_yaw+"\n")



ap = argparse.ArgumentParser()
#mettere rem sulla successiva per utilizzare il ciclo sulle img
#ap.add_argument("-i", "--image", required=True, help="path to input image containing ArUCo tag")
ap.add_argument("-t", "--type", type=str, default="DICT_4X4_250", help="type of ArUCo tag to detect")
ap.add_argument("-k", "--K_Matrix", type=str,default='./calibration_matrix.npy',help="Path to calibration matrix (numpy file)")
ap.add_argument("-d", "--D_Coeff",  type=str,default='./distortion_coefficients.npy',help="Path to distortion coefficients (numpy file)")
ap.add_argument("-a", "--aruco_dim", default=25,type=int, help="ArUco tag dimension")
ap.add_argument("-g", "--tag", default=0, type=str, help="Select only one Id")
ap.add_argument("-p", "--path", default="./",  help="Path folder immagini")


#la dimensione del tag e' quella dello spigolo esterno del quadrato nero esterno, non i singoli quadrati interni

args = vars(ap.parse_args())
if ARUCO_DICT.get(args["type"], None) is None:
    print(f"ArUCo tag type '{args['type']}' is not supported")
    sys.exit(0)


calibration_matrix_path = args["K_Matrix"]
distortion_coefficients_path = args["D_Coeff"]
k = np.load(calibration_matrix_path)
d = np.load(distortion_coefficients_path)



immagini = [f for f in listdir(args["path"]) if isfile(join(args["path"], f))]

with open('aruco'+str(args["tag"])+'.csv', 'w') as f:
    f.write("Id;Xpix;Ypix;X;Y;Z;Filename;Roll;Pitch;Roll\n")
    for i in immagini:
        print(args["path"]+i)
        estrai_parametri(args["path"]+i)
f.close()

 

Passato ferrarista 156/85

Ho ritrovato una foto in cui sono "alla guida" di una F1 Ferrari 156/85 (Alboreto)

In un tempo in cui era possibile farsi una foto senza spendere un patrimonio

 

Qui la macchina con il suo leggittimo proprietario

ed un disegno che avevo fattto
 

 

 

Freecad e Windows

 Mi sono messo a studiare Freecad per fare una scatolina per LC29H da stampare in 3D ma una volta installato su windows 11 non ne voleva sapere di partire

La soluzione e' stata rinominare il file openglsw32.dll in opengl32.dll

ArduSimple Ublox F9P e QuecTel LC29H

 Ho provato i modulit Ardusimple F9P e LC29H. Si tratta di due moduli entrambi daul band con il primo in L1-L2 ed il secondo L1-L5. Entrambi sono stati stati usati con RTKNavi di RTKLIB con impostazioni simili (F9P e' stato programmato per inviare messggi UBX mentre LC29H messaggi RTCM3)

In un primo momento ho fatto la prova usando i moduli in contemporanea utilizzando l'atenna in dotazione al LC29H (solo L1-L2) ed una antenna full band per l'Ublox

In questa configurazione pero' LC29H non riusciva ad ottenere il Fix (sempre soluzioni Float). Ho quindi montato l'antenna full band su LC29H ed ho ottenuto il fix in modo corretto

Queste le impostazioni di RTKNavi per LC29H

e queste per Ublox F9P

il client NTrip ha utilizzato Euref come nel precedente post https://debiaonoldcomputers.blogspot.com/2024/08/quectel-lc29hda.html

Le impostazioni generali sono le seguenti

Il risultato finale 

Quectel LC29H antenna full band

Ublox F9P antenna full band

Come si vede dalla scala il posizionamento e' di tipo centimetrico in entrambi i casi con risultati migliori come deviazione per F9P

per confronto metto il grafico dei punti di LC29H con antenna L1-L5

Quectel LC29HDA

Cavalcando l'onda della banda 5 del GPS ho provato il Quectel LC29H DA (rover) e BS (base) che ha la possibilita' di RTK (esiste anche il rover DEA che costa un po' di piu' ed offre un campionamento a 10 Hz)

Piccola nota: per attivare l'uscita sulla UART si deve spostare il microswitch dal lato dove sono posti la porta USB ed i refori dalla porta seriale. L'alimentazione del modulo e' a 3.7 V

Il software di riferimento per questo dispositivo e' QGNSS della Quectel che ha incluso il proprio Ntrip Client. Al contrario di quanto indicato su altri siti la velocita' di default della porta e' 115200 

Come Ntrip server ho impiegato euref-ip.asi.it porta 2101 con la stazione IGMI00ITA

Si ottiene in pochi secondi RTK Fix 

Come si vede il posizionamento di prova e' sostanzialmente nelle specifiche ma si nota che i punti si distribuiscono su nuvole distinte 

La cosa curiosa con questo dispositivo e' che non funziona di default con altri software differenti da QGNSS. Il problema e' il software QGNSS di fatto non effettua nessun calcolo ma trasmette i dati dal server NTRIP verso LC29H che effettua i calcoli sul modulo e poi restituisce indietro una stringa NMEA con i dati gia' corretti

Io volevo trasmettere i dati dell'antenna via Lora verso un computer remoto e questa impostazione non e' applicabile. 

E' possibile modificare la configurazione in modo che LC29H trasmetta solo messaggi RTCM3 e non efffettui calcoli in modo poi da poter passare il calcolo ad RTKNAVI. Per fare cio' 

$PQTMRESTOREPAR*13 
$PQTMCFGRCVRMODE,W,2*29
$PQTMSAVEPAR*5A 
# reset
$PAIR432,1*22 # output RTCM3 MSM7 messages
$PAIR062,0,01*0F # Enable NMEA GGA message
$PQTMSAVEPAR*5A # save PQTM params to flash

Per la trasmissione Lora ho provato dei moduli E32 868T30D che sono compatibili con il voltaggio a 3.3 V in modo da essere alimentati direttamente da LC29H

Per programmarli ho utilizzato il modulo E15- USB-T2 spostando il jumper dell'alimentazione a 3.3 V e rimuovendo i jumper M0 ed M1 con il software RF Settings