# NeuralNetwork. Build a bayesian Self-Organizing Map. Example II
from jhplot import *
from java.awt import Color
from java.util import Random
c1 = HPlot("Canvas")
c1.setGTitle("Bayesian Self-Organizing Map")
c1.visible()
c1.setAutoRange()
h1 = H1D("Data", 20, -100.0, 300.0)
r = Random()
for i in range(2000):
h1.fill(100 + r.nextGaussian() * 100)
p1d = P1D(h1, 0, 0)
p1d.setErrToZero(1)
bs = HBsom()
bs.setNPoints(30)
bs.setData(p1d)
bs.run()
result = bs.getResult()
result.setStyle("pl")
result.setColor(Color.blue)
c1.draw(p1d)
c1.draw(result)
Commandline parameter(s):
first parameter must be the ARFF file
"""
# check commandline parameters
if (not (len(sys.argv) == 2)):
print "Usage: supervised.py <ARFF-file>"
sys.exit()
# load data file
print "Loading data..."
datafile = FileReader(sys.argv[1] + ".arff")
data = Instances(datafile)
rand = Random() # seed from the system time
data.randomize(rand) # randomize data with number generator
# open output files
bufsize=0
datafile = "data/plot/" + str(os.path.splitext(os.path.basename(__file__))[0]) + "_" + \
str(os.path.splitext(os.path.basename(sys.argv[1]))[0]) + "_rmse.csv"
file=open(datafile, 'w', bufsize) # open a file for rmse data
file.write("iterations,rmse\n")
wallfile = "data/plot/" + str(os.path.splitext(os.path.basename(__file__))[0]) + "_" + \
str(os.path.splitext(os.path.basename(sys.argv[1]))[0]) + "_wall.csv"
filewall=open(wallfile, 'w', bufsize) # open a file for wall clock time
filewall.write("epochs,seconds\n")
from java.lang import Math
from java.util import Random
rnd = Random()
# Active le mode verbeux
debug = 1
##################################################################
class Own:
def __init__(this):
this._target = None
this._base = 0
this._direction_ttl = 0
this._dest_x = None
this._dest_y = None
def toggleSens(this):
this.sens *= -1
def getSens(this):
return this.sens
def getTeam(this):
return self.getTeam()
def setTarget(this, x, y):
if this._target:
this._target.seen(x, y)
else:
import opt.RandomizedHillClimbing as RandomizedHillClimbing
import opt.GenericHillClimbingProblem as GenericHillClimbingProblem
import dist.DiscretePermutationDistribution as DiscretePermutationDistribution
import dist.DiscreteUniformDistribution as DiscreteUniformDistribution
import dist.DiscreteDependencyTree as DiscreteDependencyTree
import java.util.Random as Random
import time
from array import array
from itertools import product
from time import clock
# Adapted from https://github.com/JonathanTay/CS-7641-assignment-2/blob/master/tsp.py
# set N value. This is the number of points
N = 100
random = Random()
maxIters = 3001
numTrials = 5
OUTPUT_DIRECTORY = './output'
base.make_dirs(OUTPUT_DIRECTORY)
points = [[0 for x in xrange(2)] for x in xrange(N)]
for i in range(0, len(points)):
points[i][0] = random.nextDouble()
points[i][1] = random.nextDouble()
outfile = OUTPUT_DIRECTORY + '/TSP/TSP_{}_{}_LOG.csv'
ef = TravelingSalesmanRouteEvaluationFunction(points)
odd = DiscretePermutationDistribution(N)
nf = SwapNeighbor()
def knapsackfunc(NUM_ITEMS, iterations):
rhcMult = 600
saMult = 600
gaMult = 4
mimicMult = 3
# Random number generator */
random = Random()
# The number of items
#NUM_ITEMS = 40
# The number of copies each
COPIES_EACH = 4
# The maximum weight for a single element
MAX_WEIGHT = 50
# The maximum volume for a single element
MAX_VOLUME = 50
# The volume of the knapsack
KNAPSACK_VOLUME = MAX_VOLUME * NUM_ITEMS * COPIES_EACH * .4
# create copies
fill = [COPIES_EACH] * NUM_ITEMS
copies = array('i', fill)
# create weights and volumes
fill = [0] * NUM_ITEMS
weights = array('d', fill)
volumes = array('d', fill)
for i in range(0, NUM_ITEMS):
weights[i] = random.nextDouble() * MAX_WEIGHT
volumes[i] = random.nextDouble() * MAX_VOLUME
# create range
fill = [COPIES_EACH + 1] * NUM_ITEMS
ranges = array('i', fill)
ef = KnapsackEvaluationFunction(weights, volumes, KNAPSACK_VOLUME, copies)
odd = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
mf = DiscreteChangeOneMutation(ranges)
cf = UniformCrossOver()
df = DiscreteDependencyTree(.1, ranges)
hcp = GenericHillClimbingProblem(ef, odd, nf)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
pop = GenericProbabilisticOptimizationProblem(ef, odd, df)
optimalOut = []
timeOut = []
evalsOut = []
for niter in iterations:
iterOptimalOut = [NUM_ITEMS, niter]
iterTimeOut = [NUM_ITEMS, niter]
iterEvals = [NUM_ITEMS, niter]
start = time.time()
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, niter*rhcMult)
fit.train()
end = time.time()
rhcOptimal = ef.value(rhc.getOptimal())
rhcTime = end-start
print "RHC optimum: " + str(rhcOptimal)
print "RHC time: " + str(rhcTime)
iterOptimalOut.append(rhcOptimal)
iterTimeOut.append(rhcTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
sa = SimulatedAnnealing(100, .95, hcp)
fit = FixedIterationTrainer(sa, niter*saMult)
fit.train()
end = time.time()
saOptimal = ef.value(sa.getOptimal())
saTime = end-start
print "SA optimum: " + str(saOptimal)
print "SA time: " + str(saTime)
iterOptimalOut.append(saOptimal)
iterTimeOut.append(saTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
ga = StandardGeneticAlgorithm(200, 150, 25, gap)
fit = FixedIterationTrainer(ga, niter*gaMult)
fit.train()
end = time.time()
gaOptimal = ef.value(ga.getOptimal())
gaTime = end - start
print "GA optimum: " + str(gaOptimal)
print "GA time: " + str(gaTime)
iterOptimalOut.append(gaOptimal)
iterTimeOut.append(gaTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
mimic = MIMIC(200, 100, pop)
fit = FixedIterationTrainer(mimic, niter*mimicMult)
fit.train()
end = time.time()
mimicOptimal = ef.value(mimic.getOptimal())
mimicTime = end - start
print "MIMIC optimum: " + str(mimicOptimal)
print "MIMIC time: " + str(mimicTime)
iterOptimalOut.append(mimicOptimal)
iterTimeOut.append(mimicTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
optimalOut.append(iterOptimalOut)
timeOut.append(iterTimeOut)
evalsOut.append(iterEvals)
return [optimalOut, timeOut, evalsOut]
for t in self.obstacles.items():
if (t[0].getDistance() < n.getDistance()):
n = t[0]
def nearest_foe():
n = self.attackers.items()[0][0]
for t in self.attackers.items():
if (t[0].getDistance() < n.getDistance()):
n = t[0]
# (1) Workaround pour un bug qui n'existe peut-être plus
def _ennemy_count(self):
return (len(self.attackers), len(self.explorers), len(self.homes))
rnd = Random() # Generateur aleatoire
groupName = 'sAMetmAX-' + self.getTeam()
#journaliser les messages : 0/1
log = 1
#println sur la console : 0/1
console = 1
#cette globale est initialisee a chaque tour a
#une liste de percepts vus par l'agent
percepts = PerceptBag(self.getTeam())
#celle ci contient ce qu'il faut pour calculer
#le mouvement courant
#methode qui filtre l'affichage
def toterm(msg):
def _longRandomPrime():
BigInteger prime = BigInteger.probablePrime(31, new Random())
return prime.longValue()
fp.setColor(50) # membrane
fp.setLineWidth(3)
for roi in rois:
fp.draw(roi)
fp.setColor(90) # oblique membrane
fp.setLineWidth(5)
roi_oblique = OvalRoi(w / 2 + w / 8, h / 2 + h / 8, w / 4, h / 4)
fp.draw(roi_oblique)
# Add noise
# 1. Vesicles
fp.setLineWidth(1)
random = Random(67779)
for i in xrange(150):
x = random.nextFloat() * (w - 1)
y = random.nextFloat() * (h - 1)
fp.draw(OvalRoi(x, y, 4, 4))
fp.setRoi(None)
# 2. blur
sigma = 1.0
GaussianBlur().blurFloat(fp, sigma, sigma, 0.02)
# 3. shot noise
fp.noise(25.0)
fp.setMinAndMax(0, 255)
imp.show()
// User has not entered a valid input. Prompt again.
return getMove();
}
public boolean playAgain() {
System.out.print("Do you want to play again? ");
String userInput = inputScanner.nextLine();
userInput = userInput.toUpperCase();
return userInput.charAt(0) == 'Y';
}
}
private class Computer {
public Move getMove() {
Move[] moves = Move.values();
Random random = new Random();
int index = random.nextInt(moves.length);
return moves[index];
}
}
public RockPaperScissors() {
user = new User();
computer = new Computer();
userScore = 0;
computerScore = 0;
numberOfGames = 0;
}
public void startGame() {
System.out.println("ROCK, PAPER, SCISSORS!");
