Recent posts (max 10) - Browse or Archive for more

# Update: Problems with the Windows 10 Creators Update

The issue related to the bluescreen on Windows 10 Creators Update is caused by a high nesting of controls (stackoverflow, microsoft support). Previously, exceeding the maximum nesting level was rarely encountered and a warning was issued in the worst case. Since the Windows 10 Creators Update, the maximum nesting level is much lower and exceeding the maximum immediately results in a bluescreen.

To avoid exceeding the maximum nesting level, HeuristicLab can intercept further nesting, by opening a new Tab instead, as soon as a defined nesting threshold is reached. This threshold can be changed by selecting View -> Change Nesting Level... in the menu bar of HeuristicLab (implemented in #2788). For users that have the Windows 10 Creators Update installed, we recommend a maximum nesting of 25. Additionally, HeuristicLab now detects whether the Creators Update is installed and issues a warning if the nesting threshold is too high.

# Problems with the Windows 10 Creators Update

There seem to be problems with the so called "Creators Update" for Windows 10. Several users are experiencing blue screens after they have upgraded their Windows installation. The blue screen may occur simply by clicking around in the parameters' text boxes. We are not yet sure what is the sudden cause for these problems.

HeuristicLab still works fine with the Anniversary Update (build version 1607). At this point, if you want to use HeuristicLab we think it is best to postpone installing the Creators Update until this problem has been resolved.

You can check which version of Windows you have if you press Windows-R and type "winver" without quotes in the box. If it reads "1703" you have the Creators Update installed.

# Modeling scheduling problems with HeuristicLab

HeuristicLab makes it very easy to model scheduling problems. HeuristicLab comes included with the simulation framework Sim#, a port of SimPy to C#. With Sim# writing process-based simulation models requires little effort. Here, I demonstrate in only a few lines of code how to implement a permutation flow shop problem using a Programmable Problem (single-objective). You can create this problem in the GUI from the New Item dialog and paste following code into the editor pane, then hit compile. You can optimize solutions after you dragged it to the Problem tab of an algorithm that can handle programmable permutation-based problems (e.g. Genetic Algorithm).

using System;
using System.Linq;
using System.Collections.Generic;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.PermutationEncoding;
using HeuristicLab.Optimization;
using IRandom = HeuristicLab.Core.IRandom;
using SimSharp;
using SysEnv = System.Environment;
using SimEnv = SimSharp.Environment;

namespace HeuristicLab.Problems.Programmable {
public class FlowShopProblemDefinition : CompiledProblemDefinition,
ISingleObjectiveProblemDefinition {
private static readonly string[] machineSep = new [] { SysEnv.NewLine };
private static readonly string[] jobSep = new [] { " ", "\t" };
// from http://mistic.heig-vd.ch/taillard/problemes.dir/ordonnancement.dir/flowshop.dir/tai20_5.txt
private static readonly string instance = @"
54 83 15 71 77 36 53 38 27 87 76 91 14 29 12 77 32 87 68 94
79  3 11 99 56 70 99 60  5 56  3 61 73 75 47 14 21 86  5 77
16 89 49 15 89 45 60 23 57 64  7  1 63 41 63 47 26 75 77 40
66 58 31 68 78 91 13 59 49 85 85  9 39 41 56 40 54 77 51 31
58 56 20 85 53 35 53 41 69 13 86 72  8 49 47 87 58 18 68 28
";
private int M, J; // number of machines, jobs
private List<List<int>> pij; // processing times per machine, job

// objective is to minimize makespan
public bool Maximization { get { return false; } }

public override void Initialize() {
// processing times are parsed from the instance
pij = instance.Split(machineSep, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Split(jobSep, StringSplitOptions.RemoveEmptyEntries)
.Select(y => int.Parse(y)).ToList()).ToList();
M = pij.Count;
J = pij[0].Count;
// encoding is created
Encoding = new PermutationEncoding("p", length: J,
type: PermutationTypes.Absolute);
}

public double Evaluate(Individual ind, IRandom random) {
// create a new Sim# environment
var env = new SimEnv();
// create the M machines
var machines = Enumerable.Range(0, M).Select(x => new Resource(env)).ToArray();
// add the jobs in order given by the permutation
foreach (var o in ind.Permutation("p"))
env.Process(Job(env, o, machines));
// run the simulation
env.Run();
// return the current simulation time (last finish time)
return env.NowD;
}

private IEnumerable<Event> Job(SimEnv env, int j, Resource[] machines) {
// for each of the M machines in order from 0 to M-1
for (var m = 0; m < M; m++) {
// create a new request for the next machine
// the machine is freed after the using block
using (var req = machines[m].Request()) {
// wait upon obtaining the machine
yield return req;
// process the job j on machine m
yield return env.TimeoutD(pij[m][j]);
}
}
}

public void Analyze(Individual[] individuals, double[] qualities,
ResultCollection results, IRandom random) { }

// for move-based algorithms, all possible swap2 neighbors are returned
public IEnumerable<Individual> GetNeighbors(Individual ind, IRandom random) {
var p = ind.Permutation("p");
foreach (var move in ExhaustiveSwap2MoveGenerator.Apply(p)) {
var neighbor = ind.Copy();
var perm = neighbor.Permutation("p");
Swap2Manipulator.Apply(perm, move.Index1, move.Index2);
yield return neighbor;
}
}
}
}


This includes a "simple" 5 machine / 20 job problem instance from Taillard's instances.

# HeuristicLab 3.3.14 "Denver" Release

We are happy to announce the release of HeuristicLab 3.3.14, which we finished at this year's Genetic and Evolutionary Computation Conference (GECCO) in Denver, CO, USA.

HeuristicLab 3.3.14 "Denver" contains the following new features:

• New problems:
• Bin Packing
• Probabilistic TSP
• Multi-Objective Testfunctions
• New data analysis algorithms:
• Nonlinear Regression
• Elastic-Net

For a full list of all changes have a look at the ChangeLog.

Go to the Download page or click on the image below to get HeuristicLab 3.3.14 "Denver" now!

# Run-Length Distribution Analysis with HeuristicLab

We have included in our trunk today new analyzers for measuring algorithm performance. The analyzers are called QualityPerEvaluationsAnalyzer and QualityPerClockAnalyzer. They record the convergence graph in each run and add it as a result. A new run analyzer called "Run-length Distribution View" can be used to build, so called, ECDFs out of the convergence graphs in the individual runs using a single or multiple targets. This allows plotting the cumulative success probability of reaching a certain fitness value given a certain effort (measured in evaluated solutions or elapsed wall-clock time). These plots can be used to compare the run-length distributions of algorithm instances applied to one or many problem instances.

The run-length distribution view can cope with runs of different length such that it would not simple plot the number of hits divided by the total number of runs in the experiment. Instead, the denominator is decreased whenever a run missed the target and terminated prematurly. Thus one can use shorter runs to obtain more accurate ECDFs for lower amounts of function evaluations. In order to visualize missed runs, we plot a shaded area for every curve that represents the min and max bounds for the ECDF. The minimum level is pessimistic and assumes that all prematurely missed runs would have not hit the target later on. The upper level is optimistic and assumes that all prematurely missed runs would have immediately found the target right afterwards. The line that is based purely on the observed hits is thus in-between these two.

Together with the other run analyzers this one provides another means for algorithm developers to test and compare their instances. Currently, this feature is part of the main development trunk.

# HeuristicLab 3.3.13 "Windischgarsten" Release

Right before our annual HeuristicLab retreat (this time in Windischgarsten, Austria), we are proud to announce the release of HeuristicLab 3.3.13 "Windischgarsten" with the following new features:

• New Algorithms:
• Age-layered Population Structure (ALPS)
• Offspring Selection Evolution Strategy (OSES)
• New Problems:
• Multi-objective external evaluation problem
• Gentic programming for code generation (Robocode)
• Further genetic programming problems: Even Parity, Multiplexer, Koza-style symbolic regression
• Additional accuracy metrics for classification models (and comparison to baseline algorithms)
• Quantile Regression based on Gradient Boosted Trees
• Mathematica export for symbolic regression/classification solutions
• Improved complexity measures for multi-objective symbolic regression
• Improved persistence of data-analysis models (SVM, Gaussian Process, GBT, Random Forest)
• Hive Statistics: A new WebApp that shows information about running jobs and available resources in HeuristicLab Hive

For a full list of all changes have a look at the ChangeLog. Go to the Download page or click on the image below to get HeuristicLab 3.3.13 "Windischgarsten" now!

# In memoriam John H. Holland 1929-2015

We're sorry to hear that the inventor of the genetic algorithm, John H. Holland, has passed away at 86. He was a pioneer in the study of complex adaptive systems and an inspirational source for many researchers including our research group. The importance of his work cannot be emphasized enough and it will certainly continue to influence generations of researchers that are yet to come.

• Posted: 2015-08-11 15:42
• Author: abeham
• Categories: (none)

Following our conference-oriented release schedule, we are happy to announce the release of HeuristicLab 3.3.12 "Madrid" from this year's Genetic and Evolutionary Computation Conference (GECCO).

HeuristicLab 3.3.12 "Madrid" contains the following new features:

• New problem: NK[P,Q] landscapes
• New problem: Orienteering
• New data analysis algorithm: Gradient boosted trees
• New optimizer: TimeLimitRun limits algorithm execution by wall-clock time and can take snapshots at predefined points
• Integration of the Sim# simulation framework as external library (Sim# at GitHub)
• Hive status page is replaced by a modular WebApp
• Improved and searchable "New Item" dialogue
• C# code formatter for symbolic regression/classification
• The symbolic expression tree encoding can now be used with Programmable/Basic problems
• Kernel density estimation for the histogram control

For a full list of all changes have a look at the ChangeLog. Go to the Download page or click on the image below to get HeuristicLab 3.3.12 "Madrid" now!

# HeuristicLab 3.3.11 "Beach Bar" Release

As with every EuroCAST conference, the HeuristicLab development team is proud to announce the release of HeuristicLab 3.3.11 "Beach Bar".

Among others, HeuristicLab 3.3.11 "Beach Bar" contains the following new features:

• New algorithm: parameter-less population pyramid (P3). Thanks to Brian Goldman from the BEACON Center for the Study of Evolution in Action.
• New binary test problems:
• Deceptive trap problem
• Deceptive trap step problem
• HIFF problem
• New views for statistical testing and analysis of run collections
• New UI for C# scripts based on AvalonEdit
• New problem type: Programmable problem
• New APIs that make it easier to implement algorithms and problems

For a full list of all changes in HeuristicLab 3.3.11 "Beach Bar" have a look at the ChangeLog.

Go to the Download page or click on the image below to get HeuristicLab 3.3.11 "Beach Bar" now!

# HeuristicLab moves to .NET 4.5

After staying on the .NET 4 platform for 4 years we have decided to upgrade to .NET 4.5. At the moment this only affects the trunk version of HL, but in the future also the stable branch and the next release (3.3.11) will be built on .NET 4.5. The main reason for this decision is that we are going to use new features from .NET 4.5 (async/await and System.IO.Compression.ZipArchive).

For you as a user or developer this means the following:

• Running HeuristicLab now requires .NET 4.5
• Windows XP is not supported anymore because .NET 4.5 requires at least Windows Vista SP2 or Windows Server 2008 SP2/R2 SP1
• If you have written plugins for HeuristicLab or applications that use HL assemblies you have to update your projects to .NET 4.5