To archive this result I used FFI: the Ruby snippet used to map the native C function look like this:

module Hunspell
  module Wrapper
    extend FFI::Library
    ffi_lib(LIBRARY_PATH)
    attach_function :create,  :Hunspell_create, [:string,  :string], :pointer
    attach_function :spell,   :Hunspell_spell,  [:pointer, :string], :int
    attach_function :suggest, :Hunspell_suggest,[:pointer, :pointer, :string], :int;
  end
end

where LIBRARY_PATH is the path to the compiled hunspell library.

Then the next step was to create a Hunspell class which wraps this module creating a nice ruby-sh interface to the library:

module Hunspell
  class Hunspell

    # initialize the class and the anonymus module acting as a wrapper to
    # hunspell
    def initialize(config_obj = nil)
      @dicts = bootstrap(config_obj || CONFIGURATION)
      respawn_handler('default')
    end

    def respawn_handler(dictionary)
      # create the hunspell library object
      @hunspell = FFI::MemoryPointer.new :pointer
      @hunspell = Wrapper.create(
        @dicts[dictionary]['aff'],@dicts[dictionary]['dic']
      )
    end

    # returns true if words is not correct, false otherwise
    def spelled_correctly?(word)
      Wrapper.spell(@hunspell,word) != 0
    end

    # returns an array with suggested words of a given word ([] if no
    # suggestions)
    def suggest(word)
      suggestions = FFI::MemoryPointer.new :pointer, 1
      suggestions_number = Wrapper.suggest(@hunspell,suggestions, word)
      suggestion_pointer = suggestions.read_pointer
      if (suggestion_pointer.null?)
        []
      else
        suggestion_pointer.get_array_of_string(0,suggestions_number).compact
      end
    end

    private

    # get lib directory and default dictionary path
    def bootstrap(config_obj)
      if config_obj.nil?
        raise BootstrapError.new("No configuration info supplied to Hunspell" +
            "constructor and no default configuration file available")
      end
      return config_obj['dictionaries'].merge({
          'default' => config_obj['dictionaries'][
                          config_obj['dictionaries']['default']]
      })
    end

  end
end

Well, it’s almost all here, except for some configuration details that let you choose which language dictionary files to load. The path of these files (a pair of .dic and .aff) can be specified in a .yml file and then sent to the constructor method in a way like this:

YAML (config.yml)

dictionaries:
  default: en
  en:
    aff: '/Users/sandropaganotti/RMU/hunspell/hunspell_en_dict/en_US.aff'
    dic: '/Users/sandropaganotti/RMU/hunspell/hunspell_en_dict/en_US.dic'
  it:
    aff: '/Users/sandropaganotti/RMU/hunspell/hunspell_it_dict/it_IT.aff'
    dic: '/Users/sandropaganotti/RMU/hunspell/hunspell_it_dict/it_IT.dic'

Usage Example

module Hunspell
    LIBRARY_PATH = '/path/to/your/hunspell.lib'
end
require 'yaml'
require 'lib/hunspell'
hunspell = Hunspell::Hunspell.new(Yaml.load(File.read('config.yml')))
require 'lib/hunspell'
hunspell.respawn_handler 'it'
hunspell.suggest 'spagtti'
=> ["spaghetti", "spaginati", "spagliati", "spaghetto"]

And that’s it! You can find the source code of this library on my github account; hope it may be useful!

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

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

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.

Negli ultimi mesi sono emerse le prime applicazioni che fanno uso di algoritmi di riconoscimento oggetti e, più specificatamente, volti. Cito, ad esempio, Picasa ed il filtro per visionare solo le facce in Google Images ma la lista di chi ha deciso di incorporare al suo interno questa funzionalità è decisamente più lunga.

Mi sono interessato subito al lato tecnico di questa nuova feature (grazie anche ad un ottimo speech ascoltato all’Erukuo 2009) imbattendomi in un particolare classificatore chiamato ‘cascade of boosted classifiers working with haar-like features’ che funziona nel seguente modo:

1. Attraverso un training set viene generato un descrittore delle variazioni  di contrasto più comuni per un particolare oggetto (contrasto e orientamento);
2. Tale descrittore, che intrinsecamente ha una sua dimensione (quella delle immagini con le quali è stato creato), viene fatto scorrere sull’imagine da identificare ridimensionandolo ad ogni passaggio (in modo da ‘intercettare’ possibili oggetti anche di dimensioni diverse rispetto a quelle del training set);
3. Il descrittore presenta a sua volta una struttura ‘incrementale’ nella quale esso è composto da una sequenza di filtri che vengono verificati in sequenza sulla regione di interesse finche un filtro non fallisce o tutti i filtri passano, certificando in questo modo il match.
4. Ogni filtro è, concludendo, creato da una serie di operazioni basilari, che vengono anch’esse applicate in sequenza sulla regione di interesse; il risultato in questo caso è misurato pesando i risultati delle singole operazioni.

Sfruttando un esempio creato da Cory Forsyth ho costruito un face detector ‘seriale’, capace di applicare più descrittori su più immagini, creando in output una pagina html che evidenzi, per ogni immagine, le aree riconosciute come appartenenti ad un oggetto.

Ecco il codice:

require 'rubygems'
require 'opencv'

face_detectors = %w(
  /usr/local/share/opencv/haarcascades/haarcascade_frontalface_default.xml
  # inserire qui l'elenco dei descrittori da utilizzare
).collect { |fd| OpenCV::CvHaarClassifierCascade::load(fd) }

file_names =  Dir.glob(ARGV[0] || "/Users/sandro/Ruby/image_labs/lib/facer/euruko2/*.jpg") 

file_names.each_with_index do |file_name,i|

  face_rectangles = []
  opencv_load = OpenCV::IplImage.load(file_name)
  face_detectors.each_with_index do |face_detector,k|
    face_detector.detect_objects(opencv_load).each do |rect|
      face_rectangles << [
        rect.top_left.x,      rect.top_left.y,
        rect.top_right.x    - rect.top_left.x,
        rect.bottom_left.y  - rect.top_left.y
      ]
    end
  end

  File.open("#{File.basename(file_name)}.html","w") do |file|
    file.write <<-HTML
      <html>
         <body style="margin:0px; background: url('file://#{file_name}') no-repeat top left;">
          #{  face_rectangles.collect do |(x,y,w,h)|
                " <div class=\"face\" style=\"position: absolute; left: #{x}px;
                  top: #{y}px; width: #{w}px; height: #{h}px; border: 2px solid red; \"></div>"
              end.join("\n") }
         </body>
       </html>
    HTML
  end

  puts "End #{file_name}"

end

Unico requisito per il corretto funzionamento del tutto è l’installazione di OpenCV, una libreria opensource che contiene una serie di strumenti dedicati alla ‘real time computer vision’, tra i quali figurano anche algoritmi di Face Recognition. Installare OpenCV ed i necessari binding per Ruby non è esattamente una procedura semplicissima, l’intera sequenza è però ottimamente illustrata in questo how-to.

Chiudo questo post con un link ad una pagina html generata utilizzando il programmino di cui sopra, potete notare come seppur il risultato in termini di riconoscimento sia ottimo vi siano pure dei falsi positivi. Una possibile tecnica di rimozione potrebbe essere modificare l’elenco dei descrittori, magari riducendolo,  in questo modo però si incorre nella possibilità di non individuare correttamente alcuni volti.

Playlist.com
Questo sito utilizza un motore di ricerca interno per indicizzare i file mp3 che trova nella rete, tali file vengono poi categorizzati utilizzando le informazioni disponibili (tag mp3, ecc..). Utilizzando una form di ricerca è possibile ricercare tra i file indicizzati, ascoltarli e costruirsi una propria playlist che si può poi condividere con altre persone.

NabazTag
Il nabaztag è un gadget elettronico, dalla forma di un coniglio, capace di connettersi alla rete wireless domestica di intrattenere ospiti e residenti con tutta una serie di servizi vocali (text-to-speech, podcast, lettura di messaggi, email ed RSS, ecc.. ). Violet, la casa produttrice, ha ben pensato di mettere a disposizione di eventuali sviluppatori interessati delle API con le quali interagire col coniglio.

Nabaztag Command Line Tool
Ho creato (e caricato su github) uno script in Ruby che, dato l’identificativo di una playlist di playlist.com, si interfaccia con le API del nabaztag e, utilizzando apposite funzioni, fa in modo che il coniglio esegua l’intera playlist selezionata.

Fulcro di questo piccolissimo programma è una bellissima libreria di cui ho sentito parlare poco tempo fa: Scrubyt. Scrubyt serve essenzialmente ad interagire con il web, questo comprende parsing di pagine HTML ma anche compilazione di form e click su link.

Per darvi un assaggio delle potenzialità di questa libreria vi allego il codice che ho usato per recupeare le informazioni sull’url dei vari file mp3, questi sono i passi:

1. recuperare il file xml dall’indirizzo view.playlist.com/[id_playlist]/asx
2. estrarre per ogni nodo ‘entry’ l’attributo href del tag ref

      playlist = Scrubyt::Extractor.define do
          fetch "http://view.playlist.com/#{params[0]}/asx"
          ele "//entry//ref" do
            mp3 "href", :type=>:attribute
          end
      end

A questo punto nella variabile ‘playlist’ avrò un elenco di hash ognuno di essi nella forma :mp3 => ‘url’.

Per rendere il tutto più utilizzabile ho inoltre allegato alla libreria anche un esempio: un piccolo programma che usando la matrice di costrizione spiegata nell’articolo di due settimane fa è capace di risolvere un Sudoku.

Potete trovare questo programma all’interno del mio repository di GitHub, nella sottocartella examples/sudoku; per eseguirlo lanciate il file sudoku.rb.

La settimana prossima proporrò un tutorial nel quale utilizzeremo questa libreria per risolvere  il famosissimo problema delle otto regine.