Die Ausgangslage

Firma Kiste & Co. (Name frei erfunden) produziert Kisten aus Holz und aus Kunststoff.
Die Firma möchte fit werden für den digitalen Wandel.

Aber wie macht man das?
Kisten sind einfache Produkte ohne Sensoren oder Elektronik.
Wie digitalisiert man klassische Produkte oder Dienstleistungen?

Die Produkte digitalisieren

Als Erstes legt man in einer zentralen Datenbank eine Tabelle für die Produkte an und definiert die wichtigsten für den Verkauf und die Produktion erforderlichen Merkmale. Für unsere Kisten beginnen wir mit 6 Merkmalen:

Name, Länge x Breite x Höhe, Material und Farbe.

Das sieht bei unserer Kiste & Co. dann so aus:

Ab jetzt stehen diese Produktmerkmale zentral und eindeutig für alle weiteren digitalen Anwendungen zur Verfügung. Änderungen an einzelnen Merkmalen werden sofort und eindeutig übernommen.

Die gesuchte Kiste schneller finden => Der Kisten-Filter

Auf der Seite 'Kisten-Filter' können jetzt passende Kisten exakt nach den gewünschten Merkmalen gefiltert werden, also nach Abmessungen, Farbe und Material. Ohne die exakte Beschreibung der Merkmale wäre das nicht möglich.

Den Kisten-Filter ausprobieren ...

Eigentlich sind solche Produktfilter Stand der Technik. Sie funktionieren aber selbst bei den namhaftesten Online-Anbietern oft nur unzureichend, wenn die oben beschriebenen Produktmerkmale unvollständig hinterlegt sind.

Ein Nachteil der Produktfilter liegt darin, daß eine gewisse Kenntnis des Kunden für die Produktmerkmale vorausgesetzt wird. Weiß ein Kistenkäufer, welche Materialien 'EPP' oder 'ESD' sind? Es fehlt also die Kundenorientierung, die gerade die heutigen erfolgreichen Startups auszeichnet! Hierauf geht der nächste Abschnitt ein:

Fachwissen digitalisieren

Was sucht der Kunde wirklich?

Er sucht eine Möglichkeit, seine Ware zu transportieren und zu lagern, zum Beispiel Äpfel, Schrauben oder Elektronik! Von Kisten versteht er vermutlich nicht besonders viel. Kiste & Co. hat langjährige Erfahrung darin, welche Kiste sich für welchen Inhalt am besten eignet. Diese Erfahrungen kann man digitalisieren. Ganz ohne komplizierte künstliche Intelligenz. Man muß dazu 'nur' die vielen einzelnen Entscheidungen analysieren, wenn ein Kiste & Co.-Mitarbeiter für einen Kunden die passende Kiste vorschlägt.

Hier ein Code-Beispiel für eine digitale Entscheidung:

Wenn der Kunde als Inhalt (_content) Fisch in der Kiste transportieren möchte, paßt als bestes Material 'EPP' zu 100%, 'PP' zu 75%, 'Holz' zu 30%, 'ESD' zu 10% und alle anderen zu 0%.

In der Programmiersprache C# formulieren wir das als 'Kisten-Inhalts-Regel' oder 'BoxContentMaterialRule' wie folgt:

...
if (_content == "Fisch")                // Wenn Inhalt = Fisch, dann ...
{
    _index = _box.Material switch
    {
        "EPP" => 1.0,                   // Material "EPP" zu 100% geeignet
        "PP" => 0.75,                   // Material "PP" zu 75%
        "Holz" => 0.3,                  // Material "Holz" zu 75%
        "ESD" => 0.1,                   // Material "ESD" zu 75%
        _ => 0.001,                     // Alle anderen Materialien ungeeignet
    };
    return _index;
}
if (_content == "Elektronik")
{
    _index = _box.Material switch
    {
        "ESD" => 1.0,
        "PP" => 0.3,
        "EPP" => 0.2,
        "Holz" => 0.11,
        _ => 0.001,
    };
    return _index;
}
...

Die ideale Kiste finden => Der Kisten-Experte

Oben haben wir über einen Index 'benotet', welches Kistenmaterial am besten zum Inhalt paßt. Jetzt geht es noch darum, die restlichen Merkmale der Kisten zu bewerten:

- Euro-Abmessungen sind besser stapelbar, als Sondermaße.
- Ist die gewünschte Farbe verfügbar, oder eine 'ähnliche' Farbe?
- Sind die Wunschmaße verfügbar?

Ähnlich wie die oben gezeigte BoxContentMaterialRule programmieren wir für die Euro-Abmessungen die BoxEuroRule:

public BoxEuroRule(BoxModel box)
{
    _box = box;
}
public double Execute()
{
    if (_box.Name.Contains("Euro"))
        return 1.0;
    if (_box.Name.Contains("Sonder"))
        return 0.33;

    return 0.001;
}

... und für die passende Farbe die BoxColorRule:

public BoxColorRule(BoxModel box, string desiredColor)
{
    _box = box;
    _desiredColor = desiredColor;
}
public double Execute()
{
    if (_desiredColor == null) // Keine Wunschfarbe gewählt
        return 1.0;

    if (_box.Farbe == _desiredColor) // Wunschfarbe paßt => 100%
    {
        return 1.0;
    }

    if (_desiredColor == "Rot"
        || _desiredColor == "Rosa"
        || _desiredColor == "Lila") // Rot zuerst, dann 'rötliche' Farben auflisten
    {
        return _box.Farbe switch
        {
            "Rot" or "Rosa" or "Lila" => 0.75,
            _ => 0.5,
        };
    }

    return 0.5;
}

Diese 3 Entscheidungen über Material, Farbe und Euro-Abmessungen fassen wir jetzt zu einer Gesamt-Bewertung zusammen. Jede der 3 Regeln gibt uns einen Index zwischen 0 und 1 zurück, vergleichbar einer Schulnote.

Jede dieser Noten multiplizieren wir mit einer Gewichtung, ähnlich der stärkeren Gewichtung von Leistungskursen in der Schule.

Die 3 gewichteten Noten multiplizieren wir zum Schluß miteinander und erhalten eine Gesamtnote, ähnlich dem Numerus Clausus im Abitur:

Gesamtnote = Regel1 * Gewichtung1 * Regel2 * Gewichtung2 * Regel3 * Gewichtung3

Der C#-Code sieht jetzt etwas verwirrender aus, da man in der Computerei die Multiplikation mit 0 unbedingt vermeiden sollte. Anstatt P1*P2*P3 rechnet man exp(ln(P1) + ln(p2) + ln(p3)). Das braucht man nicht zu verstehen, Hauptsache es tut :-)

Im Kisten-Experten übernehmen wir auch gleich die Begründungs-Texte zur Ausgabe in der Liste:

public KistenExperte(BoxRepository boxRepository)
{
    _boxRepository = boxRepository;
}

public IEnumerable Execute(ExpertInput input, double lengthMin = 20, double lengthMax = 200, 
            double widthMin = 20, double widthMax = 200, double heightMin = 10, double heightMax = 100)
{
    var boxes = _boxRepository.GetAll();

    boxes = from b in boxes
        where b.Laenge >= lengthMin && b.Laenge <= lengthMax 
            && b.Breite >= widthMin && b.Breite <= widthMax 
            && b.Hoehe >= heightMin && b.Hoehe <= heightMax
        select b;

    var expertResult = new List();

    foreach (var box in boxes)
    {
        // Bewertungsregel: Welches Material für welchen Inhalt?
        var ContentRule = new BoxContentMaterialRule(box, input.BoxContent);
        var ContentFactor = ContentRule.Execute();
        var ContentReason = ContentRule.Reason(ContentFactor);

        // Bewertungsregel: Eurokisten vor Sonderabmessungen!
        var EuroRule = new BoxEuroRule(box);
        var EuroFactor = EuroRule.Execute();
        var EuroReason = EuroRule.Reason(EuroFactor);

        // Bewertungsregel: Wunschfarbe vor ähnlichen Farben vor restlichen Farben!
        var ColorRule = new BoxColorRule(box, input.Color);
        var ColorFactor = ColorRule.Execute();
        var ColorReason = ColorRule.Reason(ColorFactor);

        // Gewichtungen:
        var ContentWeight = 3;
        var EuroWeight = 2;
        var ColorWeight = 1;

        // Gesamtindex bauen:
        // Wir wollen P1*P2*P3, das ist numerisch instabil
        // Wir machen exp(ln(P1*P2*P3)) = exp(ln(P1) + ln(p2) + ln(p3))
        double index;
        double divisor;
        index = Math.Log(EuroFactor * EuroWeight);
        divisor = EuroWeight;
        if (input.BoxContent != null)
        {
            index += Math.Log(ContentFactor * ContentWeight);
            divisor *= ContentWeight;
        }
        if (input.Color != null)
        {
            index += Math.Log(ColorFactor * ColorWeight);
            divisor *= ColorWeight;
        }
        index = Math.Exp(index) / divisor;

        // Begründungen auflisten:
        List decisions = new List();
        decisions.Add(new Decision() { DecisionIndex = Math.Round(ContentFactor * ContentWeight, 1), DecisionReason = ContentReason });
        decisions.Add(new Decision() { DecisionIndex = Math.Round(EuroFactor * EuroWeight, 1), DecisionReason = EuroReason });
        decisions.Add(new Decision() { DecisionIndex = Math.Round(ColorFactor * ColorWeight, 1), DecisionReason = ColorReason });

        // Nach Index absteigend sortieren:
        ListsortedDecisions = decisions.OrderByDescending(d => d.DecisionIndex).ToList();

        // Begründungen an View übergeben:
        var decision1 = sortedDecisions[0].DecisionReason;
        var decision2 = sortedDecisions[1].DecisionReason;
        var decision3 = sortedDecisions[2].DecisionReason;

        expertResult.Add(new ExpertResult()
        {
            Box = box,
            Index = index,
            Reason1 = decision1,
            Reason2 = decision2,
            Reason3 = decision3,
        });
    }

    return expertResult.OrderByDescending(r => r.Index); ;
}

Gehen Sie jetzt auf den Tab 'Kisten-Experte', wählen Sie den Inhalt, den Sie in die Kiste legen möchten, wählen Sie vielleicht noch eine Farbe und Wunschmaße aus:

Den Kisten-Experten ausprobieren ...

Jetzt sehen Sie ganz oben in der Liste zuerst die Kisten, die sich für Ihren Bedarf am besten eignen. Rechts werden Ihnen sogar die Gründe für die Auswahl gezeigt. Sie brauchen als Kunde nicht mehr bei Kiste & Co. anzurufen, sondern erhalten automatisch professionellen Experten-Rat.