Soprattutto quando si parla di Java sappiamo che è molto comodo utilizzare Eclipse. In questo articolo parlerò infatti di come poter configurare quest’ultimo per poter lavorare con PeerSim. Ho deciso di scriverlo dopo aver letto uno dei pochi post che tratta dell’argomento, e che risolve la cosa in un modo alquanto bizzarro.

Download di PeerSim

Per prima cosa occorre scaricare il pacchetto messo a disposizione da Sourceforge.

Configurazione del progetto

Per prima cosa create il vostro progetto andando su File -> New -> Java Project.

Una volta creato tale progetto, cliccate con il tasto destro sul nome del vostro progetto che c’è nella lista (Package Explorer) di tutti i progetti del vostro Workspace. Successivamente andate sulle sue proprietà. Una volta aperta la relativa finestra, andate su Java Build Path, e poi su Libraries. In questo modo potete includere le librerie di PeerSim.

Per fare ciò, cliccate su Add External JARs, navigate fino a giungere nella cartella di PeerSim che avete estratto precedentemente e selezionate quindi le seguenti librerie:

• peersim-1.0.5.jar
• jep-2.3.0.jar
• djep-1.0.0.jar

Adesso importate la documentazione, espandendo per prima cosa la voce relativa alla libreria di PeerSim.

Configurare un Run

Per configurare PeerSim in modo da avviare una simulazione, aprite la finestra di configurazione dei Run, andando su Run -> Run Configurations..., cliccate poi con il tasto destro la voce del menu chiamata “Java Application” e create una nuova configurazione. Assegnategli il titolo che volete.

Nella parte relativa alla Main Class, cliccate su Search, e selezionate la voce “Simulator – peersim”, che è la main class di PeerSim (essa si trova nella libreria che avete importato nel punto precedente).

Per configurare invece gli argomenti per avviare la simulazione, in modo da poter specificare a PeerSim i propri file di configurazione, potrete specificarli andando nella voce Arguments e cambiando il campo chiamato “Program Arguments”.

Per fare una prima prova potrete creare una cartella chiamata “configs” all’interno del vostro progetto, e copiare al suo interno il file “example/config-example1.txt” che trovate all’interno della cartella di PeerSim. Dopo potete modificare il campo “Program Arguments” inserendo “configs/config-example1.txt”.

In questo post cercherò solamente di valutare brevemente alcuni metodi per poter realizzare un algoritmo di questo tipo. Sicuramente scriverò altri articoli che tratteranno di temi più specifici in futuro. I test che vedrete in seguito sono stati eseguiti con algoritmi scritti in C, ed su un MacBook Pro con processore Intel Core i5 da 2.3 Ghz; altre implementazioni potranno quindi riportare risultati differenti, anche se mi aspetto che il rapporto tra di esse sia identico.

Algoritmi

Il nostro dizionario (consideriamo quello italiano), è composto di circa 600.000 parole. Essendo la nostra matrice fissa a 4×4, in realtà abbiamo una prima osservazione da fare, dal punto di vista asintotico stiamo parlando di un problema O(1). Nonostante questo, non possiamo dire che in qualunque modo lo facciamo vada comunque bene, teoria e pratica sono cose diverse.

Full Enumeration

Supponiamo che questo insieme sia memorizzato su una hashmap. Come sappiamo, questo tipo di struttura dati ci fornisce una funzione lookup che, nel caso medio, richiede tempo O(1). Visto che il nostro dizionario è statico, possiamo anche assumere che la nostra hashmap sia semplicemente un vettore abbastanza grande per contenere tutte le nostre parole, e che la funzione di hash sia perfetta (ovvero iniettiva); in questo modo riusciamo ad avere sempre tempo O(1). Quest’ultima struttura dati in realtà è già nota e viene comunemente chiamata Direct Access Table.

Il primo algoritmo che può venire in mente avendo questo tipo di struttura è quello di cercare tutte le possibili combinazioni presenti nella griglia, e per ognuna di esse vedere se è presente o meno nel dizionario.

Per calcolare la complessità di un simile algoritmo supponiamo di avere una griglia con tutte lettere distinte. In questo modo però non contiamo più volte le parole che possono essere formate in modi diversi (questo comunque influisce in maniera minima).

Per prima cosa dobbiamo scegliere una delle 16 celle, questa formerà la prima lettera della nostra parola. Adesso dobbiamo scegliere una cella vicina per continuare. Ogni cella centrale ha 8 vicini, quelle negli angoli 3, mentre quelle negli spigoli 5. In media quindi abbiamo (8*4+5*8+3*4)/16 = 5,25 vicini. Le possibili parole di due lettere che si possono formare sono quindi 16 * 5,25 = 84. Da questo punto in poi ogni vicino ne avrà almeno un’altro già visitato, facendo scendere la nostra media a 4,25. Le possibili parole di tre lettere che si possono formare sono quindi 16*5,25*4,25 = 357. Ovviamente la media del numero dei vicini tenderà a diminuire sempre di più all’aumentare del numero delle lettere. Con questo ragionamento, con parole di al massimo 7 lettere il numero di combinazioni supera già il milione.

Con un semplice algoritmo ricorsivo, sulla falsa riga di quello del solver, possiamo determinare con esattezza il numero di combinazioni della griglia: 12.029.624.

Un simile algoritmo ha pertanto bisogno di circa dodici milioni di lookup al dizionario. L’algoritmo più semplice che calcola solamente il numero di combinazioni viene eseguito in circa 2.5 secondi.

Active Dictionary

Visto il numero eccessivo calcolato precedentemente in realtà viene in mente un’altro algoritmo, che capovolge il ruolo del dizionario: da passivo ad attivo.

Supponiamo di avere il nostro dizionario e leggiamo una parola alla volta, per ognuna verifichiamo se è presente o meno nella griglia.

Quest’ultima verifica è in realtà abbastanza veloce. La parola guida la strada escludendo i percorsi sbagliati. Le operazioni da fare sono poi dei semplici confronti tra le lettere della parola in esame e quelle della matrice. Inoltre, in questo caso, non dobbiamo neanche costruire l’hashmap, possiamo leggere il nostro file del dizionario in maniera sequenziale, confrontando una parola dopo l’altra.

Infatti in questo caso, il tempo medio per trovare tutte le parole presenti nella matrice è di 150 millisecondi.

Branch and Bound

Riguardando il primo metodo però osserviamo qualcosa. Se abbiamo costruito la parola “attr”, questa fallirà nel lookup, ma ciò non vuol dire che che dobbiamo arrestare la nostra ricerca, infatti proseguendo nella costruzione di parole più grandi possiamo costruire parole come “attrito” che invece sono parole presenti nel dizionario.

Se non fosse già chiaro dalle considerazioni fatte prima, anche osservando il grafico, notiamo che il numero di possibili parole cresce esponenzialmente; ma il vero incremento lo notiamo dalla quinta lettera in poi. Per velocizzare la ricerca, sarebbe utile sapere già dalle prime lettere che la parola non è prefisso di nessuna parola tra quelle presenti nel dizionario, in modo da fermarci in tempo. Ad esempio, con “xts” è inutile continuare a cercare parole più grandi di quella, non troveremo mai nulla.

Abbiamo bisogno allora di un “hashmap” un po’ più intelligente, alla quale possiamo chiedere anche se esiste, nel dizionario, una parola che inizia per “attr”; ed allo stesso modo che non esiste nessuna parola che inizi per “xts”. Questo tipo di strutture dati in realtà è molto utilizzato, come ad esempio in information retrieval, nella correzione ortografica del testo o nel word completition.

Con questo algoritmo ci aspettiamo che il tempo sia molto poco, poiché l’enumerazione delle possibili parole viene rigorosamente guidata, escludendo percorsi sbagliati, ed utilizzando un lookup decisamente veloce. Per testare questo algoritmo, ho implementato una versione abbastanza ottimizzata dei Trie, risaputi essere onerosi in termini di memoria. Ricordo che esistono comunque strutture dati più efficienti in termini di memoria.

Questo algoritmo richiede, in media, meno di 1ms per calcolare tutte le parole presenti nella griglia

Conclusioni

Abbiamo visto tre metodi generali per risolvere questo problema, ognuno con i propri pregi e difetti. Ecco una piccola tabella riassuntiva.

Il secondo, nonostante il suo tempo di calcolo di 150ms, è molto pratico, non è infatti richiesto di memorizzare il dizionario in una qualche struttura dati. Infatti, il tempo richiesto dall’algoritmo che legge anche tutte le parole da un file, è abbastanza simile a quello dove tutte le parole sono già state caricate in memoria. Questo è consigliato in quei casi in cui il programma nasce e muore risolvendo solamente una configurazione.

Il terzo è sicuramente molto più veloce, ma bisogna considerare che è necessaria una fase di popolazione della struttura dati che può essere lunga, e che la memoria necessaria per la sua memorizzazione può essere consistente. E’ sicuramente consigliato in tutti quei casi dove possiamo far partire il programma, lasciandolo in esecuzione in attesa di risolvere qualcosa. Inoltre, la memoria necessaria per questo algoritmo si può ridurre utilizzando altre strutture dati.

Le Markov Decision Process sono una struttura matematica che ci aiuta a costruire queste policy in ambienti stocastici dove si conoscono le probabilità che si verifichino determinati risultati.

In questo post, io vi darò una brevissima introduzione e poi vi mostrerò le parti essenziali della mia implementazione, in python, dei più importanti algoritmi che vi possono aiutare per trovare le policy in ambienti stocastici. Potete trovare una più dettagliata descrizione delle Markov Decision Process nelle mie slide che ho preparato per un seminario nella mia università.

Per spiegarvi cosa siano, utilizziamo lo stesso esempio del libro “Artificial Intelligence: A Modern Approach (3rd ed.)“. Questo ambiente viene chiamato dagli autori: Grid World, una semplice griglia dove le possibili azioni sono NORTH, SOUTH, EAST, WEST. Questo ambiente non è deterministico, ma stocastico; assumiamo però delle probabilità ben definite. La probabilità di compiere l’azione che abbiamo deciso di intraprendere è dello 0.8, mentre la probabilità di andare nella cella di sinistra e nella cella di destra sono dello 0.1. Ad esempio se ci troviamo nella cella (2,1) e vogliamo fare l’azione NORTH, i possibili risultati potrebbero essere rappresentati in questo modo:

Abbiamo bisogno anche di un goal, il grid world ha infatti un uscita con un reward positivo di +1. Inoltre, ci sono alcuni fossi che hanno un reward negativo di -1. Sia l’uscita che il fosso sono stati finali, cioè non possiamo fare nessuna azione partendo da quello stato. Non possiamo uscire fuori dalla griglia e possiamo avere altre limitazioni spaziali avendo delle celle che fungono da muro; in questo modo possiamo creare dei percorsi di lunghezza diversa per arrivare al nostro goal.

Per costruire la policy, abbiamo bisogno di una stima delle utility di ogni cella. Possiamo calcolare queste utility usando un metodo simile a minimax: questo metodo viene chiamato expectiminimax. Ma per la maggior parte delle applicazioni questo metodo è infattibile, per esempio perché non ci sono stati terminali o perché memorizzare tutto l’albero richiede moltissima memoria.

Le Markov Decision Process ci aiutano a calcolare queste utility con metodi più performanti.

Pochi mesi fa, ho scritto un plugin per WordPress che mostrava il Photostream di Flickr in una griglia giustificata. Adesso, ho deciso di fare un plugin più astratto (jQuery) che potesse essere utilizzato ovunque!

Lo script ha due opzioni:

• -s: mostra tutti i dati Exif
• -m: rimuove i dati Exif, lasciando solamente quelli importanti

Per esempio, puoi modificare una jpg con questo comando: ./ExifRemover.sh -m MyImg.jpg

Questo è lo script:

#! /bin/bash

function usage {
	echo "usage: $0 -ms path_of_file"
	echo "	-m to remove useless exif entries"
	echo "	-s to show current exit entries"
	exit -1
}

if [ $# != 2 ]; then
	usage
fi

OP=$1
SRC=$2

if [ ! -f $SRC ]; then
	echo "error: file not found"
	exit -2
fi

if [ $OP = "-m" ]; then 

	cp "$SRC" "$SRC"."_tmp"
	exiftool -all= "$SRC"
	exiftool -overwrite_original \
			-TagsFromFile "$SRC"."_tmp" \
			-ExposureTime \
			-FNumber \
			-ExposureProgram \
			-ISO \
			-DateTimeOriginal \
			-CreateDate \
			-ExposureCompensation \
			-MaxApertureValue \
			-MeteringMode \
			-LightSource \
			-Flash \
			-FocalLength \
			-SubSecTime \
			-SubSecTimeOriginal \
			-SubSecTimeDigitized \
			-ColorSpace \
			-ExifImageWidth \
			-ExifImageHeight \
			-SensingMethod \
			-CustomRendered \
			-ExposureMode \
			-WhiteBalance \
			-DigitalZoomRatio \
			-FocalLengthIn35mmFormat \
			-SceneCaptureType \
			-GainControl \
			-Contrast \
			-Saturation \
			-Sharpness \
			-SubjectDistanceRange \
			-GPSVersionID \
			-GPSLatitudeRef \
			-GPSLatitude \
			-GPSLongitudeRef \
			-GPSLongitude \
			-Make \
			-Model \
		"$SRC"

	exiftool -delete_original! "$SRC"
	rm -f "$SRC"."_tmp"

else 
	if [ $OP = "-s" ]; then
		exiftool "$SRC"
	else
		usage
	fi
fi

Download: ExifRemover.sh

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Net;
using System.Net.Sockets;


public class NoServerFoundException : System.Exception {
	public NoServerFoundException() : base() { }
	public NoServerFoundException(string message) : base(message) { }
	public NoServerFoundException(string message, 
			System.Exception inner) : base(message, inner) { }
	protected NoServerFoundException(SerializationInfo info,
		System.Runtime.Serialization.StreamingContext context) { }
}

class NetworkTime {
	/* For more info, see:
	 *	NTP (RFC-2030) 
	 *	http://tools.ietf.org/html/rfc2030
	 */

	private const int requestTimeout = 3000;
	private const int timesForEachServer = 5;
	private const byte offTime = 40; //Transmit Time (see RFC-2030)
	private uint lastSrv;

	//NIST Servers
	public static string[] srvs = {
		"time.nist.gov",
		"pool.ntp.org",
		"europe.pool.ntp.org",
		"asia.pool.ntp.org",
		"oceania.pool.ntp.org",
		"north-america.pool.ntp.org",
		"south-america.pool.ntp.org",
		"africa.pool.ntp.org",
		"ntp1.inrim.it",
		"ntp2.inrim.it"
	};

	public NetworkTime() {
		Random rnd = new Random(DateTime.Now.Millisecond);
		lastSrv = (uint)rnd.Next(0, srvs.Length);
	}

	private IPAddress getServer() {
		lastSrv = (uint)((lastSrv + 1) % srvs.Length);
		IPAddress[] address = Dns.GetHostEntry(srvs[lastSrv]).AddressList;
		if (address == null || address.Length == 0) 
			throw new NoServerFoundException("no ip found");
		return address[0];
	}

	public DateTime GetDateTime() { return GetDateTime(false); }
	public DateTime GetDateTime(bool utc) {	
		//Examine all servers until we find a server that responds
		for (int st = 0; st < srvs.Length * timesForEachServer; st++) {
			try {
				IPAddress ip = getServer();
				IPEndPoint ipEndP = new IPEndPoint(ip, 123);

				Socket sk = new Socket(AddressFamily.InterNetwork, 
									  SocketType.Dgram, 
									  ProtocolType.Udp);
				sk.ReceiveTimeout = requestTimeout;

				sk.Connect(ipEndP);

				/* Request
				 * VN: 4 = NTP/SNTP version 4
				 * Mode: 3 = client
				 */
				byte[] data = new byte[48];
				data[0] = 0x23;
				for (int i = 1; i < 48; i++) data[i] = 0;
				sk.Send(data);

				/* Response
				 * we read the integer part and fraction part
				 * of transmit time (see RFC-2030)
				 */
				sk.Receive(data);
				byte[] integerPart = new byte[4];
				integerPart[0] = data[offTime + 3];
				integerPart[1] = data[offTime + 2];
				integerPart[2] = data[offTime + 1];
				integerPart[3] = data[offTime + 0];
				byte[] fractPart = new byte[4];
				fractPart[0] = data[offTime + 7];
				fractPart[1] = data[offTime + 6];
				fractPart[2] = data[offTime + 5];
				fractPart[3] = data[offTime + 4];
				long ms = (long)(
							(ulong)BitConverter.ToUInt32(integerPart, 0) * 1000
						 + ((ulong)BitConverter.ToUInt32(fractPart, 0) * 1000) 
							/ 0x100000000L);
				sk.Close();

				/* DateTime*/
				DateTime date = new DateTime(1900, 1, 1);
				date += TimeSpan.FromTicks(ms * TimeSpan.TicksPerMillisecond);
				
				return utc ? date : date.ToLocalTime();

			} catch (Exception ex) { }
		}

		throw new NoServerFoundException("no working server has been found");
	}
}

Download: NetworkTime.cs

Una libreria C++ che analizza delle espressioni matematiche, traducendole da stringhe a strutture facilmente manipolabili. La libreria è stata realizzata utilizzando bison e flex. La valutazione viene fatta attraverso un Abstract Syntax Tree, navigandolo ricorsivamente. Se si necessita di valutare più volte la stessa espressione, ad esempio per disegnare una funzione cambiando solamente il valore di una variabile, Si può anche compilare l’espressione in bytecode; quest’ultimo utilizza una pila per valutare l’espressione, risultando molto performante. La libreria supporta le variabili e funzioni parametriche con un qualunque numero di parametri. Si possono definire funzioni con stesso nome ma con numero diverso di parametri, lasciando al parser il compito di gestire l’overloading delle funzioni. Inoltre supporta le moltiplicazioni implicite, permettendo di scrivere espressioni in maniera naturale come: “-3xy^2″. Mette anche a disposizione un set di funzioni standard prese dalla libreria math.h.

Guarda la pagina ufficiale

Ecco il codice:

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

static class ExitWindows {

	private struct LUID {
		public int LowPart;
		public int HighPart;
	}
	private struct LUID_AND_ATTRIBUTES {
		public LUID pLuid;
		public int Attributes;
	}
	private struct TOKEN_PRIVILEGES {
		public int PrivilegeCount;
		public LUID_AND_ATTRIBUTES Privileges;
	}

	[DllImport("advapi32.dll")]
	static extern int OpenProcessToken(IntPtr ProcessHandle,
		int DesiredAccess, out IntPtr TokenHandle);

	[DllImport("advapi32.dll", SetLastError = true)]
	[return: MarshalAs(UnmanagedType.Bool)]
	static extern bool AdjustTokenPrivileges(IntPtr TokenHandle,
		[MarshalAs(UnmanagedType.Bool)]bool DisableAllPrivileges,
		ref TOKEN_PRIVILEGES NewState,
		UInt32 BufferLength,
		IntPtr PreviousState,
		IntPtr ReturnLength);

	[DllImport("advapi32.dll")]
	static extern int LookupPrivilegeValue(string lpSystemName,
		string lpName, out LUID lpLuid);

	[DllImport("user32.dll", SetLastError = true)]
	static extern int ExitWindowsEx(uint uFlags, uint dwReason);

	const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";
	const short SE_PRIVILEGE_ENABLED = 2;
	const short TOKEN_ADJUST_PRIVILEGES = 32;
	const short TOKEN_QUERY = 8;

	const ushort EWX_LOGOFF = 0;
	const ushort EWX_POWEROFF = 0x00000008;
	const ushort EWX_REBOOT = 0x00000002;
	const ushort EWX_RESTARTAPPS = 0x00000040;
	const ushort EWX_SHUTDOWN = 0x00000001;
	const ushort EWX_FORCE = 0x00000004;

	private static void getPrivileges() {
		IntPtr hToken;
		TOKEN_PRIVILEGES tkp;

		OpenProcessToken(Process.GetCurrentProcess().Handle,
			TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, out hToken);
		tkp.PrivilegeCount = 1;
		tkp.Privileges.Attributes = SE_PRIVILEGE_ENABLED;
		LookupPrivilegeValue("", SE_SHUTDOWN_NAME,
			out tkp.Privileges.pLuid);
		AdjustTokenPrivileges(hToken, false, ref tkp,
			0U, IntPtr.Zero, IntPtr.Zero);
	}

	public static void Shutdown() { Shutdown(false); }
	public static void Shutdown(bool force) {
		getPrivileges();
		ExitWindowsEx(EWX_SHUTDOWN |
			(uint)(force? EWX_FORCE : 0) | EWX_POWEROFF, 0);
	}

	public static void Reboot() { Reboot(false); }
	public static void Reboot(bool force) {
		getPrivileges();
		ExitWindowsEx(EWX_REBOOT |
			(uint)(force ? EWX_FORCE : 0), 0);
	}

	public static void LogOff() { LogOff(false); }
	public static void LogOff(bool force) {
		getPrivileges();
		ExitWindowsEx(EWX_LOGOFF |
			(uint)(force ? EWX_FORCE : 0), 0);
	}
}

Download: ExitWindows.cs