Il capitolo numero 11 tratta di mnemotecnica, la disciplina che studia il modo di memorizzare lunghe sequenze di numeri, e tratta del metodo di Pierre Hérigone, che può essere riassunto nel seguente modo:

1. Associa le cifre del numero che vuoi memorizzare a delle consonanti secondo una tabella nota; ad esempio la temperatura di ebollizione del mercurio, 357°C, diverrebbe mlk;
2. Trova una parola che contenga quelle consonanti in quell’ordine (senza altre ‘consonanti di disturbo in mezzo’); ad esempio per mlk andrebbe benissimo milk, mentre non andrebbe bene multik;
3. Associa la parola appena trovata ad una frase che in qualche modo leghi con il significato originario della cifra, possibilmente in modo che la frase risultante contenga uno stimolo visuale; ad esempio si può immaginare un allevatore stupito dal fatto che le sue mucche producano mercurio invece che latte.
4. Se la cifra dovesse essere molto lunga utilizza una sequenza di più parole seguendo lo schema appena descritto.

Nel tempo libero stò cercando di trasporre questi quattro semplici passaggi all’interno di una gemma: abacus, della quale ho rilasciato giusto oggi la versione 0.0.1; vediamo come si usa:

>> require 'abacus'
=> true
>> include Abacus
=> Object
>> number = HerigoneNumber.find_by_number(357)
=> #<Abacus::HerigoneNumber id: 19081, system: "default", number: 357>
>> number.article_keys.map{|article_key| article_key.the_key}
=> ["hemlock", "milk", "milky"]

Per poter funzionare Abacus utilizza un database sqllite che crea all’interno della cartella home dell’utente (il percorso in realtà è configurabile, ma per questi dettagli vi rimando alle note di installazione su github) e nel quale struttura il/i dizionari di riferimento.

Abacus implementa un parser (molto base ad oggi) XDXF, un formato open per la memorizzazione di dizionari: esistono già parecchie opere convertite più o meno bene in questo formato che possono essere scaricate gratuitamente, io ad esempio ho utilizzato questo dizionario base di inglese:

# da shell:
sudo gem install abacus
wget http://downloads.sourceforge.net/xdxf/comn_sdict05_eng_eng_main.tar.bz2
tar -xjvf comn_sdict05_eng_eng_main.tar.bz2
abacus db:create
abacus db:xdxf:import  eng_eng_main/dict.xdxf
abacus db:herigone:generate

La sfida più interessante di questo piccolo progetto è stata mantenere delle performances adeguate durante la sessione di traduzione numero -> parola, per fare questo in fase di import (con il comando db:herigone:generate) la gemma traduce ogni lemma del dizionario nel suo corrispettivo numerico rendendo la fase di ricerca una semplice SELECT su di un campo indicizzato.

In futuro vorrei estendere questo piccolo progetto aggiungendo due funzionalità di aggregazione semantica: in caso di sequenze di cifre lunghe mi piacerebbe infatti includere un generatore di linguaggio naturale con l’obiettivo creare una frase che almento nell’apparenza manifesti una certa correttezza (sarebbe bellissimo tradurre le prima 1000 cifre del PI in uno strampalato poema no?). Sarebbe inoltre interessante utilizzare wordnet per ridurre la variabilità semantica delle singole parole trovate a quanto di più vicino ad una parola che serva da ‘rappresentante logico’ per la cifra in ingresso (ad esempio per 357 il rappresentante logico sarebbe ‘mercurio’).

Nel frattempo, per chiunque fosse interessato, i sorgenti della gemma sono disponibili sul mio account di GitHub.

Il prossimo giovedì (4 febbraio 2010) terrò un Lightning Talk al Ruby Social Club su alcuni strumenti interessanti che orbitano attorno al concetto di Natural Language Generation/Parsing. In particolare vedremo due librerie che consentono di interfacciarsi con  WordNet e Link-Grammar.

Non voglio svelare nulla dello speech in questo post (anche se sicuramente venerdi farò un update allegando le slide della presentazione) ma solamente fornire a coloro che lo ritengano utile le istruzioni su come installare tali librerie sul proprio Mac.

WordNet

Update, 05/02/10: mi segnalano Words, un wrapper analogo a quello che presento nelle prossime righe ma decisamente più aggiornato, it worths a look.

Partiamo da WordNet; la prima cosa da fare è installare la gemma BerkleyDB, il che comporta in primis l’installazione dello stesso BDB, quindi il primo comando è:

sudo port install db47

Fatto questo scarichiamo la versione vecchia della gemma BDB (quella su GitHub non va bene, hanno cambiato i nomi alle costanti), decomprimiamola e modifichiamo la chiamata alla funzione ‘have_library’ nel file src/extconf.rb (riga 72 e riga 79) come segue:

have_library("db-#{with_ver}", db_version)

lanciamo infine la compilazione e l’installazione della libreria con i comandi (da eseguire all’interno della cartella di BDB):

sudo env ARCHFLAGS="-arch x86_64" ruby extconf.rb  -- --with-db-include=/opt/local/include/db46 --with-db-lib=/opt/local/lib/db46 --with-db-version=4.6
make
sudo make install

Ok, ora installiamo la gemma di wordnet:

sudo gem install wordnet

modifichiamo quindi il file ‘lib/wordnet/lexicon.rb’ all’interno della gemma impostando alla riga 68 un path assoluto come ad esempio:

DEFAULT_DB_ENV = File::join( '/Library/Ruby/Gems/1.8/gems/wordnet-0.0.5/ruby-wordnet' )

A questo punto non ci resta che scaricare e convertire il database di wordnet nel formato BDB richiesto dalla gemma, per fare questo recuperiamo l’ultima versione di wordnet disponibile e decomprimiamola. Poi eseguiamo da linea di comando lo script presente nella cartella della gemma ‘convertdb.db’ e, quando ci viene chiesto, inseriamo il percorso assoluto alla cartella ‘dict’ all’interno dell’archivio di wordnet appena decompresso.
Testiamo il funzionamento del tutto eseguendo questo semplice script:

require 'rubygems'
require 'wordnet'
include WordNet::Constants

lex     = WordNet::Lexicon::new
origins = lex.lookup_synsets( "house", Noun )
puts "#{(o=origins.first).words}: #{o.lex_info}"
[:meronyms,:hypernyms,:derivations,:hyponyms].each do |m|
  puts "#{m}: #{o.send(m).map{|s| s.words}.flatten.uniq.join(",")}"
end

Link Grammar

Installiamo link grammar usando i MacPort:

sudo port install link-grammar

quindi scarichiamo il sorgente della gemma che fungerà da wrapper e decomprimiamolo in una cartella a nostro piacimento. Dall’interno di questa cartella compiliamo ed installiamo la gemma con questi comandi:

ARCHFLAGS="-arch x86_64" rake --  --with-link-grammar-include=/opt/local/include/link-grammar --with-link-grammar-lib=/opt/local/lib
sudo rake install

Testiamo anche questa installazione eseguendo questo piccolo script:

require 'rubygems'
require 'linkparser'

dict = LinkParser::Dictionary.new('en')
sent = dict.parse( "People use Ruby for all kinds of nifty things." )

puts sent.subject
puts sent.verb
puts sent.object

Linguistic

Questa gemma funziona un pò da meta-wrapper raggruppando le funzionalità delle due gemme finora installate in un unico e omogeneo set di API. Installiamola con rubygems:

sudo gem install linguistics

quindi modifichiamo il file ‘lib/linguistics/en/linkparser.rb’ all’interno della cartella dove risiede la gemma sistemando la riga 90 come segue:

return @lp_dict ||= LinkParser::Dictionary.new('en', :verbosity => 0 )

Eseguiamo quindi un piccolo script di prova per sancirne la riuscita installazione:

require 'rubygems'
require 'linguistics'

Linguistics::use( :en )
frase = "the cat chased a snake"

puts <<-EOS
  Sogg:        #{frase.en.sentence.subject}
  Verbo:       #{frase.en.sentence.verb}
  Comp.ogg:    #{frase.en.sentence.object}
  Verbo (inf): #{frase.en.sentence.verb.en.infinitive}
EOS

Lo script si compone di tre parti, una (classica) funzione di inizializzazione,  una funzione che effettua il GeoCoding della località della quale si vuole calcolare l’isocrono e la funzione chiave, che cicla su ognuno dei raggi (il numero di raggi è impostabile, di default 10) della circonferenza costruita intorno a tale località e per ogni raggio si muove verso l’esterno misurando la distanza in minuti dal centro, quando trova un punto che sorpassa il tempo limite dato lo script mette un marker.

Lo script passa al raggio successivo quando rileva una misurazione che supera del 50% il tempo limite dato.

    function crawlpoint(px,py,mins){
        var point      = new GPoint(px,py);
        var destpoint  = new GPoint(px + x,py + y);   

        directions.loadFromWaypoints(new Array(point.y + "," + point.x ,destpoint.y + "," + destpoint.x),{preserveViewport:true});
        x = x + (inc_x * Math.sin(start_s));
        y = y + (inc_y * Math.cos(start_s));
        m = m + 1;

        if (directions.getNumRoutes() > 0){
            document.getElementById('txt1').value = 'y' + document.getElementById('txt1').value
            var curr_meas = directions.getDuration().seconds/60;
            if (prev_meas <= mins && curr_meas > mins ){
                map.addOverlay(new GMarker(prev_dest,{title:'Distance: ' + directions.getDuration().html}));
                found     = 1;
            }else{
                prev_dest = destpoint;
                prev_meas = curr_meas;
            }

            if(curr_meas > (mins + (mins * 0.4)) || (m > 20 && found ==1) || m > 50){
                points.push(new GLatLng(prev_dest.y, prev_dest.x));
                start_s = start_s + slice;
                x = inc_x;
                y = inc_y;
                m = 0;
                found = 0;
                prev_meas = 0;
                curr_meas = 0;
                prev_dest = point;
                directions.clear();

                if(start_s >= (2*Math.PI)){
                    start_s = 0;
                    $('#loader').hide();
                    clearInterval(intval);
                }
            }

        }else{
            document.getElementById('txt1').value = 'n' + document.getElementById('txt1').value
        }
    }

Possiamo spezzare la funzione in tre punti distinti, la prima parte invoca le Directions API, per calcolare la distanza tra il centro e un punto (destpoint) posizionato sul raggio attivo (il cui angolo è memorizzato in start_s, inizialmente a 0) ad una distanza espressa da due variabili x e y. Una volta calcolato il percorso x e y vengono incrementate in modo che al prossimo giro puntino ad un punto sullo stesso raggio un poco più avanti.

La seconda parte aggiunge un marker se tra la durata del percorso attuale supera per la prima volta il limite di tempo inserito.

La terza parte resetta tutti i contatori e avanza al raggio successivo se la misurazione temporale corrente eccede del 50% il tempo limite inserito o se sono state effettuate più di venti misurazioni con l’identificazione di un marker o più di 50 misurazioni.

Trovate il codice nella sua interezza sul mio account di github, potete inoltre testare il tutto su di una pagina di demo.

PS: credo che l’algoritmo sia altamente perfezionabile, ad esempio introducendo alcuni concetti di reinforcement learning per la ricerca degli zeri della funzione T(R(p1,p2)) – t dove T(R(p1,p2)) è il tempo di percorrenza del percorso tra p1 e p2 e t è il tempo limite dell’isocrono.

Non mi dilungo oltre ne nella descrizione ne nelle procedure di installazione in quanto è tutto specificato sulla homepage del progetto (c’è anche un video e una demo live se il vostro browser supporta WebGL, testato con Webkit); vorrei invece spendere questo post nello spiegare un paio di funzioni che ho scritto e che potrebbero IMHO rivelarsi utili a qualche lettore, ecco la prima:

function createTextureFromCanvas(ctx, canvas_imagedata) {

    var pixels = new WebGLUnsignedByteArray(canvas_imagedata.data);
    var texture = ctx.createTexture();
    ctx.bindTexture(ctx.TEXTURE_2D, texture);
    ctx.texParameteri(ctx.TEXTURE_2D, ctx.TEXTURE_WRAP_S, ctx.CLAMP_TO_EDGE);
    ctx.texParameteri(ctx.TEXTURE_2D, ctx.TEXTURE_WRAP_T, ctx.CLAMP_TO_EDGE);
    ctx.texParameteri(ctx.TEXTURE_2D, ctx.TEXTURE_MIN_FILTER, ctx.NEAREST);
    ctx.texParameteri(ctx.TEXTURE_2D, ctx.TEXTURE_MAG_FILTER, ctx.NEAREST);
    ctx.pixelStorei(ctx.UNPACK_ALIGNMENT, 1);
    ctx.texImage2D(ctx.TEXTURE_2D, 0, ctx.RGBA, canvas_imagedata.width, canvas_imagedata.height, 0, ctx.RGBA, ctx.UNSIGNED_BYTE, pixels);
    ctx.generateMipmap(ctx.TEXTURE_2D)
    ctx.bindTexture(ctx.TEXTURE_2D, null);

    return texture;
}

In questa funzione si concentra il cuore dello slideshow, non tanto dal punto di vista operativo, quanto di mio personale sforzo concettuale; il principale problema che ho incontrato nello sviluppo di questo script infatti riguardava la necessità di mappare immagini di dimensioni potenzialmente diverse su di un cubo (le cui facce devono essere tutte uguali). Ecco quindi il passaggio forzato attraverso dei canvas bidimensionali di appoggio, sui quali effettuare le operazioni di resize delle immagini prima di passarle come textures sul cubo. Questi canvas sono anche serviti per gestire i margini neri che venivano a crearsi naturalmente in quanto la proporzione tra le dimensioni delle fotografie non è sempre 1:1.

Ma una volta ottenuto questi canvas contenenti le immagini normalizzate come procedere per metterle su di una texture ? Dopo aver seguito senza successo un gist sul tema mi sono imbattuto nel salvifico esempio ‘Texture test‘ che contiene una funzione che disegna 4 pixel su di una texture:

function createCheckerboardTexture() {
    var pixels = new WebGLUnsignedByteArray([255, 255, 255,
                                             0,   0,   0,
                                             0,   0,   0,
                                             255, 255, 255]);
    var texture = gl.createTexture();
    gl.bindTexture(gl.TEXTURE_2D, texture);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    //  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
    //  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, 2, 2, 0, gl.RGB, gl.UNSIGNED_BYTE, pixels);
    return texture;
}

Da qui è stato facile; al posto che specificare i singoli bit dell’immagine ho passato nella variabile pixels il contenuto dei miei canvas di appoggio e, con un paio di altre modifiche sono riuscito ad ottenere l’effetto desiderato.

La seconda funzione di cui vorrei far menzione è invece quella che recupera un immagine e la mappa, centrata, su di un canvas 2d, per scrivere queste righe ho utilizzato il metodo drawImage del context 2D in un modo che non conoscevo (suggeritomi da qui), cioè con 5 parametri:

• Canvas di destinazione;
• Posizione x e y da cui disgnare l’immagine sul canvas di destinazione;
• Dimensioni dell’immagine sul canvas di destinazione (width e height).

Ecco la funzione, in ingresso riceve l’<img> da adattare al canvas:

function initTexture(e)
{
  var textureWidth  = 500;

  if($(e).width() > $(e).height()){
     var magnitude = textureWidth/$(e).width();
  } else {
     var magnitude = textureWidth/$(e).height();
  }

  var new_width  = Math.floor($(e).width()*magnitude);
  var new_height = Math.floor($(e).height()*magnitude);
  var textureCanvas     = document.createElement("canvas");
  textureCanvas.width   = textureCanvas.height = textureWidth;
  var textureContext    = textureCanvas.getContext("2d");
  textureContext.drawImage(e,Math.floor((textureWidth-new_width)/2.0),Math.floor((textureWidth-new_height)/2.0),new_width,new_height); 

  return textureCanvas;
}

Se la cosa vi interessa sappiate che tutto il progetto è, come al solito, disponibile sul mio account di github.

Per ulteriori dettagli vi rimando al post su RailsOnWave contenente l’annuncio ufficiale.

Per tutta una serie di impegni/dimenticanze/ritardi/… non sono più riuscito ad avvicinarmi a Gosu anche se le sue potenzialità sembravano quantomeno interessanti; oggi approfittando del piovoso ponte lavorativo mi sono cimentato nella stesura di  una piccolissima applicazione (non la si può nemmeno chiamare gioco) che gestisca, su un unico schermo, una moltitudine di client associando ad ognuno di essi uno sprite e consentendogli di pilotarlo con dei semplici comandi.

In questa proof-of-concept ogni client può connettersi alla porta 8888 del server e dialogando in TCP può pilotare il proprio areo da caccia sullo schermo dell’applicazione; la sintassi del messaggio è semplicissima:

codice_client|comando

I comandi supportati sono, al momento, solo ‘left’, ‘right’, ‘close’ e ‘welcome’ ma ben presto introdurrò almeno ’shot’ per consentire all’areo di difendersi dai (futuri) nemici. L’intera implementazione è come al solito presente sul mio account di github; a seguire invece uno screenshot dell’applicazione con due client connessi:

Ogni aereo è controllato da un client diverso

Non mi dilungo oltre e lascio gli interessati alla lettura della prima parte dell’articolo.

Scaricando il primo esempio e dandogli una veloce occhiata mi è sembrato tutto abbastanza lineare e comprensibile, dopo pochissimo sono riuscito senza particolari problemi ad individuare il punto di loading della texture e a modificarlo come segue:

Ora stò importando JQuery, il prossimo passo è utilizzare questa famosissima libreria per recuperare alcune immagini dalla mia gallery di Flickr e mostrarle sul cubo.

Stay Tuned.

Senza aggiungere altri spoiler rimando, a chi è interessato, alla lettura dei due scritti.