Dieser Artikel wurde maschinell übersetzt.

Test Run

Amöbe Methodenoptimierung mit c#

James McCaffrey

Das Ziel der numerischen Optimierung ist es, eine Gleichung zu lösen. Es gibt viele Kalkül-basierte deterministische Techniken; jedoch können nicht einige schwierige Probleme, vor allem im Bereich des maschinellen Lernens und der künstlichen Intelligenz, leicht mit klassischen Optimierungstechniken gelöst werden. In solchen Situationen können Alternativen wie Amöbe Methodenoptimierung Wert sein. Amöbe Methodenoptimierung, die ich in diesem Artikel besprechen, ähnelt in gewisser Hinsicht Partikel Schwarm Optimierung, die ich in der August 2011 Ausgabe des MSDN Magazine beschrieben (msdn.microsoft.com/magazine/hh335067).

Ist des besten Weg zu verstehen, welche Amöbe Methodenoptimierung und zu sehen, wohin ich bin zu prüfen Abbildung1, die ein Demoprogramm in Aktion zeigt. Das Ziel in diesem Programm ist, finden die Werte von x und y, die eine relativ einfache standard-Benchmark-Problem Rosenbrocks-Funktion zu minimieren. Diese Funktion hat eine bekannte Lösung bei X = 1.0 und y = 1,0, wenn der Wert der Funktion 0 ist.

Abbildung 1 Amoeba-Methode Optimierung Demo

Das Demoprogramm erstellt eine virtuelle Amöbe, die drei zufällige mögliche Lösungen enthält. Das Beste aus dieser anfänglichen Lösungen ist nicht sehr gut, bei X = 0.66 und y = 5,43, woraus sich ein Funktionswert 2499.52. Das Demoprogramm Ruft eine Methode lösen und hinter den Kulissen verwendet die Amöbe-Methode iterativ bessere Lösungen zu finden. Nach 50 Iterationen gelingt es der Algorithmus die optimale Lösung zu finden.

In den folgenden Abschnitten ich präsentieren und erklären den kompletten Source-Code für den Demo-Programm. Der Code ist abrufbar unter archive.msdn.microsoft.com/mag201306TestRun. Dieser Artikel setzt voraus, dass Sie mindestens Mittelstufe mit modernen prozedurale Sprache Programmierkenntnisse. Ich die Demo mit c# codiert, aber Sie sollten nicht zu viel Mühe, die Umgestaltung der Demo in eine andere Sprache, z. B. Visual Basic .NET oder Python.

Die Amöbe-Methode-Algorithmus

Amöbe-Methode Optimierungsalgorithmus, die ich hier präsentieren basiert auf die 1965 Forschungsarbeit "A Simplex-Methode für Funktion Minimierung," von J.A. Downhill und R. Mead.

Die wichtigsten Bestandteile dieses Algorithmus sind abgebildet Abbildung 2. An irgendeinem Punkt in der Zeit gibt es mehrere mögliche Lösungen. In den meisten Fällen verwendet die Amöbe Optimierung drei Lösungen, die in der Abbildung rot gefärbt. Jede Lösung hat einen zugeordneten Zielfunktion-Wert, so gibt es eine schlechteste Lösung (die höchste Funktion Wert, denn das Ziel ist, zu minimieren), eine optimale Lösung (der kleinste Funktionswert) und andere (s).

Abbildung 2 Amoeba Optimierung Primitive Operationen

Der Algorithmus ist ein iterativer Prozess. Bei jedem Schritt versucht es, die schlechteste Lösung mit einem neuen, besseren Lösung unter drei Bewerbern zu ersetzen: eine reflektierte Punkt, erweiterte Point und einem vertraglich vereinbarten Zeitpunkt. Jeder der Kandidaten liegt entlang einer Linie vom schlechtesten Punkt durch den Schwerpunkt — ein Punkt, der in der Mitte alle Punkte außer die schlimmsten Punkt befindet. Im üblichen Fall mit drei Lösungen wird der Schwerpunkt auf halbem Weg zwischen dem besten und die anderen (Worst) Punkt liegen.

Wenn der reflektierte Punkt der erweiterten Punkt, weder noch der vertraglich vereinbarten Punkt besser als die aktuellen schlechteste Lösung ist, schrumpft die Amöbe selbst durch alle Punkte außer den besten Punkt, auf halbem Weg zu den besten hin verschieben. Einige Studien nennen diesen Prozess mehrere Kontraktion.

Wenn im Laufe der Zeit grafisch dargestellt, wenn die drei aktuellen Lösung Punkte durch eine Linie verbunden sind (wie bei der schwarz gestrichelten Linie in Abbildung 2), die Lösungen bilden ein Dreieck, und ihre Bewegung ähnelt der einer Amöbe Crawlen durch seine Umwelt. In mathematischen begriffen ist ein Dreieck auf einer Ebene ein Simplex aufgerufen, sodass diese Optimierungsalgorithmus neben der Amöben-Methode oder die Downhill-Mead-Methode aufgerufen wird manchmal die simplex-Methode aufgerufen wird.

Allgemeine Programmstruktur

Ich codiert das Amöbe-Optimierung-Demo-Programm als einzigen c#-Konsole-Appli­kation. Ich habe Visual Studio 2010 (beliebige Version von Visual Studio sollte funktionieren) und erstellt ein neues Projekt mit dem Namen Amoeba­Optimierung. Nachdem das Projekt geladen, im Fenster Projektmappen-Explorer ich benannte Datei Program.cs zu aussagekräftigeren AmoebaProgram.cs, welcher Laufwerksbuchstabe­cally umbenannt Klasse Programm. Ich löschte alle nicht benötigte Vorlage-generated using-Anweisungen außer die Anweisung, die auf den obersten Ebene System-Namespace verweist.

Die gesamte Programmstruktur mit einigen Kommentaren und WriteLine-Anweisungen entfernt, notiert Abbildung 3.

Abbildung 3 Amoeba Optimierung Programmstruktur

using System;
namespace AmoebaOptimization
{
  class AmoebaProgram
  {
    static void Main(string[] args)
    {
      try
      {
        Console.WriteLine("\nBegin amoeba method optimization demo\n");
        int dim = 2;  // problem dimension
        int amoebaSize = 3;  // number potential solutions
        double minX = -10.0;
        double maxX = 10.0;
        int maxLoop = 50;
        Console.WriteLine("Creating amoeba with size = " + amoebaSize);
        Amoeba a = new Amoeba(amoebaSize, dim, minX, maxX, maxLoop);
        Console.WriteLine("\nInitial amoeba is: \n");
        Console.WriteLine(a.ToString());
        Solution sln = a.Solve();
        Console.WriteLine("Final amoeba is: \n");
        Console.WriteLine(a.ToString());
        Console.WriteLine("\nBest solution found: \n");
        Console.WriteLine(sln.ToString());
        Console.WriteLine("\nEnd amoeba method optimization demo\n");
      }
      catch (Exception ex)
      {
        Console.WriteLine(ex.Message);
      }
    }
    public static double ObjectiveFunction(
      double[] vector, object dataSource)
  }
  public class Solution : IComparable<Solution>
  public class Amoeba
}

Die Zielfunktion

Amöbe Methodenoptimierung wird am häufigsten verwendet, um eine numerische Minimierung-Problem zu lösen. Die Funktion zu minimieren wird in der Regel eine Kostenfunktion oder Zielfunktion genannt. Das Demoprogramm in Abbildung 1 ist Problemlösung Pseudo-mathematische Benchmark Rosenbrock Funktion aufgerufen. Die Funktion hat zwei input-Variablen X und y und wird definiert als f(x,y) = 100 * (y - X ^ 2) ^ 2 > + (1 - X) ^ 2 >. Die Funktion hat eine Lösung x = 1.0, y = 1.0, die einen Wert von 0.0 gibt. Abbildung 4 zeigt ein dreidimensionales Grundstück Rosenbrock Funktion.

Abbildung 4 Funktionsgraphen Objektive

In realen Situationen ist Amöbe Optimierung verwendet, um die Lösung für Probleme zu finden, die auf Daten basieren. Z. B. genommen Sie an, Sie versuchen, die Aktienkurse vorhersagen. Vielleicht kommen Sie mit einer Liste der Faktoren, die Sie glauben sind Prädiktoren und eine Gleichung, aber Sie müssen eine Reihe von numerischen Konstanten für die Gleichung bestimmen, die den Fehler auf eine Reihe von Trainingsdaten zu minimieren, die Ergebnisse kennt.

Die Zielfunktion für die Demo-Programm ist in der Hauptprogramm-Klasse als definiert:

public static double ObjectiveFunction(
  double[] vector, object dataSource)
{
  double x = vector[0];
  double y = vector[1];
  return 100.0 * Math.Pow((y - x * x), 2) + 
    Math.Pow(1 - x, 2);
} 

Ich benutze einen Dummy-input-Parameter mit dem Namen DataSource an, dass in den meisten Fällen die Zielfunktion von einigen externen Datenquelle, z. B. eine Text-Datei oder SQL-Tabelle abhängt. Da die Funktion über die öffentlichen und static-Modifizierer deklariert wird, ist die Funktion für den gesamten Code in der Demo-Programm sichtbar.

Die Lösungsklasse

Amöbe Optimierung verwaltet eine Auflistung von möglichen Lösungen, in einer Lösungsklasse definiert:

public class Solution : IComparable<Solution>
{
  public double[] vector;
  public double value;
  static Random random = new Random(1);
  public Solution(int dim, double minX, double maxX)
  public Solution(double[] vector)
  public int CompareTo(Solution other)
  public override string ToString()
}

Die Klasse wird von der IComparable-Schnittstelle, so dass Lösung Objekte automatisch sortiert werden können. Ein Solution-Objekt hat nur zwei wichtige Felder: ist ein Array von doppelten benannte Vektor, der die numerischen Werte der Lösung enthält, und der andere ist der Wert der Zielfunktion. Ich benutze öffentlichen Bereich Mitglied Felder und entfernen alle Fehlerprüfung für Einfachheit. Das statische Random-Objekt kann der Code um zufällige Lösungen zu generieren.

Der erste Lösung-Konstruktor erstellt eine zufällige Lösung:

public Solution(int dim, double minX, double maxX)
{
  this.vector = new double[dim];
  for (int i = 0; i < dim; ++i)
  this.vector[i] = (maxX - minX) * random.NextDouble() + minX;
  this.value = AmoebaProgram.ObjectiveFunction(this.vector, null);
} 

Der Konstruktor akzeptiert eine Problem-Dimension und für jeden Vektor-Komponente beschränkt. Die Dimension für das Demoprogramm ist 2, weil Rosenbrock Funktion verfügt über zwei input-Variablen X und y. Nach dem Zuweisen von Speicherplatz für Mitglied-Feld-Vektor, der Konstruktor das Vektor-Array zufällige Werte zwischen MinX und MaxX zugewiesen, und ruft dann die global zugänglichen Zielfunktion um das Feld "Wert" zu berechnen.

Der zweite Lösung-Konstruktor erstellt eine Projektmappe von einem angegebenen Array von Double:

public Solution(double[] vector)
{
  this.vector = new double[vector.Length];
  Array.Copy(vector, this.vector, vector.Length);
  this.value = AmoebaProgram.ObjectiveFunction(this.vector, null);
} 

Da die Lösung-Klasse aus der IComparable-Schnittstelle abgeleitet ist, muss die Klasse eine CompareTo-Methode implementieren. CompareTo wird definiert, so dass Lösung Objekte automatisch aus besten (kleinere) zum schlimmsten (größeren) Werten der Zielfunktion sortiert werden:

public int CompareTo(Solution other)
{
  if (this.value < other.value) return -1;
  else if (this.value > other.value) return 1;
  else return 0;
} 

Zur Visualisierung und debugging-Zwecke definiert die Lösung-Klasse eine einfache ToString-Methode, die Verkettung von Zeichenfolgen verwenden:

public override string ToString()
{
  string s = "[ ";
  for (int i = 0; i < this.vector.Length; ++i) {
    if (vector[i] >= 0.0) s += " ";
    s += vector[i].ToString("F2") + " ";
  }
  s += "]  val = " + this.value.ToString("F4");
  return s;
} 

Klasse Amoeba

Die Amöbe-Klasse ist im Wesentlichen ein Array von Lösung Objekte sowie eine lösen-Methode, die den Amöbe-Methode-Algorithmus verwendet. Die Struktur der Klasse Amoeba notiert Abbildung 5.

Abbildung 5 die Amöbe-Klasse

public class Amoeba
{
  public int amoebaSize;  // Number of solutions
  public int dim;         // Problem dimension
  public Solution[] solutions;  // Potential solutions (vector + value)
  public double minX;
  public double maxX;
  public double alpha;  // Reflection
  public double beta;   // Contraction
  public double gamma;  // Expansion
  public int maxLoop;   // Limits main solving loop
  public Amoeba(int amoebaSize, int dim, double minX,
    double maxX, int maxLoop) 
  public Solution Centroid() 
  public Solution Reflected(Solution centroid) 
  public Solution Expanded(Solution reflected, Solution centroid) 
  public Solution Contracted(Solution centroid) 
  public void Shrink() 
  public void ReplaceWorst(Solution newSolution) 
  public bool IsWorseThanAllButWorst(Solution reflected) 
  public Solution Solve() 
  public override string ToString()
}

Ich erkläre alle Felder und Methoden, die mit öffentlichen Bereich für Einfachheit und einfacheres debugging während der Entwicklung. Das AmoebaSize-Feld gibt die Anzahl der möglichen Lösungen im Amoeba-Objekt. Bei weitem der häufigste Wert ist 3, aber vielleicht möchten mit größeren Werten experimentieren. Dim Bereich stellt die Anzahl der Variablen in der Zielfunktion, die für die gelöst werden müssen — zwei bei Rosenbrock Funktion.

Array-Lösungen hält die potenzielle Lösung-Objekte. Obwohl es nicht klar aus der Deklaration ist, müssen Array Lösungen zu allen Zeiten, von besten Lösung (kleinste Wertfeld) für schlechteste Lösung sortiert werden. Felder MinX und MaxX schränken die Anfangswerte in jedem Lösung-Objekt. Diese Werte variieren von Problem zu Problem.

Felder Alpha-, Beta- und Gamma sind Konstanten, die von Hilfsmethoden, die von der Solve-Methode aufgerufen verwendet werden. Feld MaxLoop begrenzt die Anzahl der Iterationen der Verarbeitungsschleife in lösen.

Der einzelne Amöben-Konstruktor erstellt ein Array von AmoebaSize Lösung Objekte, von die jeder ein Vektorfeld Größe dim hat. Die Arbeit erfolgt durch Methode lösen; alle anderen Methoden in Klasse Amoeba werden Hilfsmethoden.

Der Amoeba-Konstruktor wird wie folgt definiert:

public Amoeba(int amoebaSize, int dim, 
  double minX, double maxX, int maxLoop)
{
  this.amoebaSize = amoebaSize;
  this.dim = dim;
  this.minX = minX; this.maxX = maxX;
  this.alpha = 1.0; this.beta = 0.5; this.gamma = 2.0;
  this.maxLoop = maxLoop;
  this.solutions = new Solution[amoebaSize];
  for (int i = 0; i < solutions.Length; ++i)
    solutions[i] = new Solution(dim, minX, maxX);
  Array.Sort(solutions);
} 

Felder Alpha-, Beta- und Gamma steuern das Verhalten der Methode lösen und hartcodierte Werte von 0.5, 1.0 und 2.0, bzw. zugewiesen. Untersuchungen haben gezeigt, dass diese Werte in der Regel gute Ergebnisse geben, aber experimentieren möchten vielleicht. Nachdem Array Lösungen zugewiesen wurde, wird jede Zelle eine zufällige Solution-Objekt zugewiesen. Die Array.Sort-Methode werden die Lösungen vom günstigsten bis zur schlimmsten sortiert.

Die Amöbe-Klasse verfügt über eine einfache ToString-Methode für Visualisierung und einfacheres debugging:

public override string ToString()
{
  string s = "";
  for (int i = 0; i < solutions.Length; ++i)
    s += "[" + i + "] " + solutions[i].ToString() +
      Environment.NewLine;
  return s;
} 

Die Algorithmus-primitive

Ein zentraler Aspekt der Amöbe Optimierungsalgorithmus ist, dass die aktuelle schlechteste Lösung ersetzt wird — wenn es auf eine bessere Lösungen führt — durch einen so genannten reflektierten Punkt erweitert Punkt oder Punkt vergeben.

Amöbe Klasse Hilfsmethode Achsenschwerpunkt erstellt eine Lösung-Objekt, das in gewisser Weise eine mittlere Lösung zwischen allen Lösungen in die Amöbe außer die schlechteste Lösung ist (die schlechteste Lösung ist diejenige mit dem größten Lösung Wert, weil Ziel ist es, die Zielfunktion zu minimieren, und es sich am Index AmoebaSize-1 werden):

public Solution Centroid()
{
  double[] c = new double[dim];
  for (int i = 0; i < amoebaSize - 1; ++i) 
    for (int j = 0; j < dim; ++j)
      c[j] += solutions[i].vector[j];  
  // Accumulate sum of each component
  for (int j = 0; j < dim; ++j)
    c[j] = c[j] / (amoebaSize - 1);
  Solution s = new Solution(c);
  return s;
} 

Hilfsmethode erstellt reflektiert eine Lösung-Objekt, die in die allgemeine Richtung der bessere Lösungen ist. Konstante Alpha, legen Sie in der Regel auf 1.0, steuert, wie weit weg von den Schwerpunkt zu verschieben, die reflektierte Lösung zu erbringen. Größere Werte für Alpha generieren reflektierten Punkte, die weiter von den Schwerpunkt sind:

public Solution Reflected(Solution centroid)
{
  double[] r = new double[dim];
  double[] worst = this.solutions[amoebaSize - 1].vector;  // Convenience only
  for (int j = 0; j < dim; ++j)
    r[j] = ((1 + alpha) * 
    centroid.vector[j]) - (alpha * worst[j]);
  Solution s = new Solution(r);
  return s;
} 

Hilfsmethode erweitert erstellt eine Lösung-Objekt noch weiter von den Schwerpunkt als die reflektierte Lösung dar. Ständige Gamma, legen Sie in der Regel auf 2.0, steuert, wie weit der reflektierte Punkt vom Schwerpunkt ist:

public Solution Expanded(Solution reflected, Solution centroid)
{
  double[] e = new double[dim];
  for (int j = 0; j < dim; ++j)
    e[j] = (gamma * reflected.vector[j]) + 
    ((1 - gamma) * centroid.vector[j]);
  Solution s = new Solution(e);
  return s;
} 

Hilfsmethode zog erstellt eine Lösung-Objekt, die etwa zwischen die schlechteste Lösung und der Schwerpunkt liegt. Konstante Beta, legen Sie in der Regel auf 0,50, steuert wie nah an die schlechteste Lösung, die der vertraglich vereinbarten Punkt ist:

public Solution Contracted(Solution centroid)
{
  double[] v = new double[dim];  // Didn't want to reuse 'c' from centroid routine
  double[] worst = 
    this.solutions[amoebaSize - 1].vector;  // Convenience only
  for (int j = 0; j < dim; ++j)
    v[j] = (beta * worst[j]) + 
    ((1 - beta) * centroid.vector[j]);
  Solution s = new Solution(v);
  return s;
} 

Hilfsmethode ReplaceWorst ersetzt die aktuelle schlechteste Lösung, am Index-AmoebaSize-1, mit einer anderen Lösung (die reflektierte, erweitert oder erkrankte Punkt):

public void ReplaceWorst(Solution newSolution)
{
  for (int j = 0; j < dim; ++j)
    solutions[amoebaSize-1].vector[j] = newSolution.vector[j];
  solutions[amoebaSize - 1].value = newSolution.value;
  Array.Sort(solutions);
} 

Wenn das reflektierte, die erweiterten, weder noch der vertraglich vereinbarten Punkt eine bessere Gruppe von Lösungen gibt, schrumpft der Amöbe-Algorithmus die aktuellen Lösungsmenge. Jedem Punkt Lösung außer den optimalen Punkt am Index 0, wird auf halbem Weg von ihrem aktuellen Ort zu den besten hin verschoben:

public void Shrink()
{
  for (int i = 1; i < amoebaSize; ++i)  // start at [1]
  {
    for (int j = 0; j < dim; ++j) {
      solutions[i].vector[j] =
        (solutions[i].vector[j] + solutions[0].vector[j]) / 2.0;
      solutions[i].value = AmoebaProgram.ObjectiveFunction(
        solutions[i].vector, null);
    }
  }
  Array.Sort(solutions);
} 

Die Solve-Methode

Die Amöbe-Optimierung lösen Algorithmus findet sich in Abbildung 6, in hochrangigen Pseudocode.

Abbildung 6 die Amöbe-Optimierung lösen mit dem Algorithmus

generate amoebaSize random solutions
while not done loop
  compute centroid
  compute reflected
  if reflected is better than best solution then
    compute expanded
    replace worst solution with better of reflected, expanded
  else if reflected is worse than all but worst then
    if reflected is better than worst solution then
      replace worst solution with reflected
    end if
    compute contracted
    if contracted is worse than worst
      shrink the amoeba
    else
      replace worst solution with contracted
    end if
  else
    replace worst solution with reflected
  end if
end loop
return best solution found 

Auch wenn der Algorithmus kurz ist, ist es ein bisschen schwieriger, als es zuerst erscheint und du wahrscheinlich sehr genau zu prüfen musst, wenn Sie es aus irgendeinem Grund ändern möchten. Hilfsmethode IsWorseThanAllButWorst wird die Solve-Methode ganz ein bisschen übersichtlicher. Der Helfer untersucht ein Solution-Objekt und gibt nur true zurück, wenn das Solution-Objekt (immer die reflektierte Lösung im Algorithmus) schlimmer ist (hat einen höheren Wert der Zielfunktion) als alle anderen Lösungen in die Amöbe, außer vielleicht die schlechteste Lösung, (befindet sich am Index AmoebaSize-1):

public bool IsWorseThanAllButWorst(Solution reflected)
{
  for (int i = 0; i < amoebaSize - 1; ++i) {
    if (reflected.value <= solutions[i].value) // Found worse solution
      return false;
  }
  return true;
} 

Mit allen Hilfsmethoden im Ort-Methode lösen, die aufgeführt ist, Abbildung 7, ist ziemlich kurz. Die Verarbeitungsschleife in Solve beendet wird, nachdem MaxLoop Iterationen. Im Allgemeinen ein guter Wert des MaxLoop variiert von Problem zu Problem und muss durch Versuch und Irrtum bestimmt werden. Eine alternative oder zusätzliche stoppen-Voraussetzung ist die Verarbeitungsschleife auszusteigen, wenn der durchschnittliche Fehler der Lösungen in die Amöbe unter einige Problem-abhängigen Wert fällt.

Abbildung 7 die Methode lösen

public Solution Solve()
{
  int t = 0;  // Loop counter
  while (t < maxLoop)
  {
    ++t;
    Solution centroid = Centroid();
    Solution reflected = Reflected(centroid);
    if (reflected.value < solutions[0].value)
    {
      Solution expanded = Expanded(reflected, centroid);
      if (expanded.value < solutions[0].value)
        ReplaceWorst(expanded);
      else
        ReplaceWorst(reflected);
      continue;
    }
    if (IsWorseThanAllButWorst(reflected) == true)
    {
      if (reflected.value <= solutions[amoebaSize - 1].value)
        ReplaceWorst(reflected);
      Solution contracted = Contracted(centroid);
      if (contracted.value > solutions[amoebaSize - 1].value)
        Shrink();
      else
        ReplaceWorst(contracted);
      continue;
    }
    ReplaceWorst(reflected);
  } // loop
  return solutions[0];  // Best solution
} 

Anpassen des Codes

Der Beispielcode und die Erklärung, die in diesem Artikel vorgestellten sollten erhalten, einsatzbereit, wenn Sie experimentieren oder Amöbe Methodenoptimierung in ein Softwaresystem verwenden möchten. Es gibt einige Änderungen, die Sie betrachten möchten. In der Haupt-Algorithmus-Schleife berechnen vor Errechnung der Flächenschwerpunkt und reflektierten Lösungen ich häufig eine rein zufällige Lösung und überprüfen, ob diese zufällige Lösung besser als die aktuellen schlechteste Lösung ist. Dieser Ansatz wird verhindert, dass der Optimierungsalgorithmus in einer lokalen Minimallösung stecken zu bleiben.

Eine weitere Möglichkeit der Anpassung ist, reflektierte an mehreren Orten zu berechnen. Statt einem einzigen reflektierten Punkt auf der Strecke zwischen der aktuellen schlechteste Lösung und der Schwerpunkt liegt, können Sie zusätzliche reflektierte Punkte berechnen, die auf verschiedenen Linien liegen. Diese Vorgehensweise hilft auch lokale Minima fallen zu umgehen.

Dr. James McCaffrey arbeitet für Volt Information Sciences Inc., wo er technische Schulungen für Softwareentwickler bei der Microsoft in Redmond, Washington, Campus. Er hat an verschiedenen Microsoft-Produkten mitgearbeitet, unter anderem an Internet Explorer und MSN Search. Dr. McCaffrey ist der Autor von ".NET Test Automation Recipes" (Rezepte für die .NET-Testautomatisierung, Apress 2006) und kann unter jammc@microsoft.com erreicht werden.

Unser Dank gilt den folgenden technischen Experten für die Durchsicht dieses Artikels: Darren Gehring (Microsoft) und Mark Marron (Microsoft)
Mark Marron funktioniert bei Microsoft Research in Redmond, Washington. Er erhielt einen BA in angewandter Mathematik an UC Berkeley und seinen Ph.d. von der University of New Mexico. Seine Expertise ist im Bereich der Programm-Analyse und Synthese Programm, mit dem Schwerpunkt der Verwendung dieser Informationen zu Optimierung und Software-Engineering-Anwendungen unterstützen. Seine Web-Site ist bei https://research.microsoft.com/en-us/um/people/marron/.
Darren Gehring ist ein Test-Manager bei Microsoft Research in Redmond, Washington. Vor der Arbeit bei Microsoft Research, arbeitete er 10 Jahre in der Microsoft SQL Server -Produktgruppe. Darren-Web-Seite ist in https://research.microsoft.com/en-us/people/darrenge/.