---
# System prepended metadata

title: informatiCup

---

# informatiCup


## Presentation

* Intro
    * Name der Gruppe
    * Name der Personen
* Agenda (orientiert an Zeitplan)
* Vorüberlegungen
    * Wo anfangen
    * Welche Ziele
    * Mögliche ML Ansätze
* Architektur
    * Observer
        * Evolution des Observers
    * Modellierung in Objekte
    * Request flow 
* Heristiken
    * Nichtumsetzbarkeit von ML
    * Human + Stupid
    * Ensemble
* Auswertung und Tuning
    * Execution Manager
* Fazit
* Fragen
* Backup Slides (Zu was könnten Fragen kommen?)

## Eventuelle Fragen

## Next todos

* Make Heurisitc classfication ensemble better [L]
* Make heuristics better [L]
* write docu [L]

* Docu
    * Setup [DONE]
    * Basic Structure [T]
* Dockerfile [DONE]
    * DockerHub auto-build setup [[DONE]](https://hub.docker.com/repository/docker/couchconsulting/ic20)



* Discuss Game object refactoring
    * Move computed things to @properties
        * eher weniger oder
        * init ist ziemlich überladen mittlerweile
    * Evaluate caching decorators for speedup
        * nicht mehr aber aufschreiben für doku unter verbesserungen. ähnlich wie parallaization der einzelen heuristiken
        * Würde halt vor allem mit Punkt 1 zusammenfallen
    * remove unused functions and properties (check whether pylint can resolve this automatically)
        * sollte gehen sind aber auch nur 2 stück so weit ich weiß, sonst kann ich es in pycharm suchen lassen
        * Ungenutzer Code wird sich vermutlich in der Bewertung für die Wartbarkeit nicht so gut machen.





## Done 
* extend observer [T]
    * think about: maybe add error logger to oberserver to see if anything is wrong with my actions (try -> except -> end round ) [DONE]
    * more planed executions? especially for events/3er-actions [short] - do not do if takes too long
* Start & Track Tool to start client and server with a seed.[DONE]
    * Extend observer to document store and log seeds [DONE]
* Automated heuristic tester that allows to get avg rounds, win/loss ratio [DONE]
* Last touches Human heuristic
* 
## Programmieren
* In Python (PEP 8)
* GitHub [DONE]

1. Webserivce bauen (nach Vorlage) [DONE]
2. Klassen für alle Daten
    * Eingabe/state -> cities -> events [Begründent mit allen Infos as PDF] 
        * Hilfefunktionen
    * Ausgabe: Actions model [DONE]
    * Events [DONE]
4. Beobachter programmieren und Simmulieren [Ongoing]
    * Sammel alle events + Pre/post state of city 
    * Also global events und stadt spezfische kennen
    * ALle keime kennen
    * beobachter mit unterschiedlichen aktionen testen (random action antwort) 
        * Erweitern mit statischer aktionsleiste
6. Mögliche Aktionsliste mit Klasse [DONE]
    * Alle möglichen aktions  

7. Abhängikeitsbaum [Ongoing]
    * https://drive.google.com/file/d/1jmkTKUckfA1JoWvMd9mKYNsSZ-yQDHVU/view?usp=sharing
    * (May change in the future, not the best idea possibliy) Points independent, therefore "EndRound" is missing since it only depends on the points 
        * Heuristic bias as result: Check first for the best action and then if you have enough points. If not enough points EndRound
    * heurstic always checks for all possible actions , thus it can be validated against what would be possible and do nothing if possible
        * alternative give points into heuristic and make it also decide wheter it is a good idea to wait or use the points

    * Missing target vaues for automatic herustic, thus if we find a way to get target values for action it would be doable via NN etc. 

9. Huerisitcmethoden um mögliche Aktionsliste auszuführen [Schwerste]
    * WIP:
         
    * Done:
        *  Human heuristic
    
    * Build msot generic feature vector of the game state
    * Ansätze: 
    
        * SAT/SMT/Theory Solver
        * ML (SVM oder NN)
        * Keimspread-Modell
        * Nachforschen Spielheuristic 
        * random forest
        * Heuristic wobei jede aktion variabeln hat die durch game status gefüllt wird und die vorhandenen punkte (einflussfaktorenfunktionen)
        * Funktion- based NN
        * Deadl Heursitc inverted of softmax output
        * solution only focused on graphs and how something may spread and how you could avoid the spread 
        * adjustable humanheuristic reweigh after a game has ended 
    
    * Ensenmble classifiere als endansatz ()



10. Aktionen ausführen  [DONE]

### Other
* Check: Kann durch bioTerrorism nur vorhandenes Pathogen hinzukommen? Folgen für Modeling (Doch liste von outbreaks?) [DONE]
    * still correct? (check outbreak is list? and if yes fix implementation) -> No second outbreak
        * macht nix kaputt weil solang kein outbreak da ist, nix passiert und wenn da einfach nur prevalnce verstärkt
    * bioTerrorism -> outbreak? jaein


## Ausarbeitung
* Kompoentendiagram
* Sequenzdiagram
* Archteictural Decissions

## Orga
* 15. Januar 2020 (einschl.): Ende der Annahme der vollständigen Lösung (E-Mail: ludger.porada@gi.de)

## Resourcen 
AWS Educate Classrooms

Der InformatiCup 2020 wird von Amazon mit einem AWS Educate Classroom für Wettbewerbsteilnehmer unterstützt. Darin enthalten sind 150$ AWS-Budget und Free-Tier-Ressourcen für, zum Beispiel, AWS Lambda. Ihre Zugangsdaten erhalten Sie auf Wunsch mit Ihrer Anmeldung zum InformatiCup.

## Details der Aufgabe

### Ziel
Software die Menschheit vor eine Pandemie retten durch gewinnen eines rundenbasierten Spiel.

* Aufgabe wird gelöst *teilweise* durch Beobachtung innerhalb der Spiele (aka ML algo durchaus möglich)

### Spielabluaf
0. Startguthaben Punkte: 40 | Summe Einwohner aller Städe: X
1. In zufällig gewählten Städten berechen zufällig gewählte Keime aus
    * Eigenschaften der Städte und Keime wirken sich auf die Ausbreitung der Keime innerhalb der Städte und zwischen den Städten sowie auf die Eintrittswahrscheinlichkeiten von Ereignissen aus.
2. Abwechselnde Runden
    * Pandemie-Runde:
        * Pro Runde können Keime in neuen Städten auftreten durhc Übertragung etc. 
        * Aktion/Spielstatus = Eingabe
            * HTTP-POST-Request, JSON, UTF-8
        * JSON Eingabe Data - siehe PDF
    * Heiler-Runde: 
        * + 20 Punkte (herausfinden ob am Anfang oder Ende der Runde)
            * Gezhält von Spiel
        * Aktionen = Ausgabe
            * Aktionen kosten Punkte
            * Beliebig viele Aktion pro Runde
    * Runden-Ende:
        * Check Sieg/Niederlage bedingung 
            * Ende: Alle Keime eliminiert oder Menschheit ausgelöscht
                * Menschheit ausgelöscht := Summe Einwohner aller Städte jetzt <= (Summe Einwohner aller Städte Runde 1)/2
                * ?Alle Keime eliminiert := Nieman mehr Infiziert?

#### Wichtige Details für Spielablauf 
* Aktionsentscheidung ohne Beachtung der Historie des Spiel, da eingegbene Spielzuständen unterschiedlichen Spielen gehören könnten. 
    * Spielzustände nicht eindeutig zuordbar 
    * ?Eigne Historie aufbauen?
    * Ereignisse lassen Rückschlüsse auf Historie zu. 
        * e.g. # Runden entwicklung Impfstoff gegen einen Keim


### Werte
* Menge von Städten
    * Eigenschaften-Unveränderlich: [Name, Koordinaten, Flugverbindungen (zu anderen Städten)]
    * Eigenschfaten-Veränderlich: [Einwohnerzahl, Stärke der Wirtschaft, Stabilität der Regierung, Hygienestandards, Achtsamkeit der Einwohner]
    * Hat Events wo Keime drinnen stehen etc. 
    * Anmerkungen:
        * Koordinaten nutzen?
        * Event haben eine "sinceRound" und "prevalence" angabe welche für Prioritiserung benutzt werden könnte
* Keime
    * Eigenschaften-Unveränderlich: 
        * Name (Fiktiv)
        * Infektiosität: % Infizierung Einwohner ander Städte oder  seiner Stadt
        * Mobilität: % Übergang des Keims auf nicht verbunde Städte
        * Dauer: # Runde der Infektion und der möglichkeit andere zu Infizieren
        * Letalität: % Infizierter Stribt
            * Infizierte Sterben oder werden Immun gegen diesen Keim
    * Menge endlich
    * Mögliche Keime sind unbekannt aber dürfen "gesammelt" werden über hinreichend viele Spiele hinweg. 
* Events: 
    * Events für das Ganze Spiel oder nur für Städte
    * Hat Eigenschaften und Auswirkungen auf Spielgeschehen
    * Mögliche Events sind unbekannt aber dürfen "gesammelt" werden über hinreichend viele Spiele hinweg. 
* Error: Eingabe wenn Aktion nicht akzeptiert wurde
#### Details
* Numerische Eigenschaftswerte sind auf "--" (min), "-", "o", "+", "++" (max) abgebildet. 

## Anforderungen/Anmerkungen für Programmierung
1. Webservice der Eingabe annimmt  [Vorlageverfügbar]
    * Hintergrundinfos können nicht geupdatet werden. Daher folgendes Hardcoden/Festenspeicher Planen: 
        * Keime + Eigenschaften
        * Ereignise + Eigenschaften analog
    * Berücksichtigen Sie die Umsetzung der Produktivversion Ihrer Software als zustandslosen Webservice von Anfang an in Ihrem Softwareentwurf.
2. Software die Antwortet und als Response an die Eingabe zurückschickt 
    * Antwort ?Liste? von Dicts
* Umsetzung Prioritiserung welche Aktion hauptfrage: 
    * Implizierungsgraphen/Bayesnetze 
    * ML


* Docker/Webserivce Umsetzung
    * Docker besser für Local
    * Webservice besser für Koopertaives teste/entwickeln?
* Klassen für alle Daten (Eingabe/Ausgabe)
* Beobachter programmieren der alle Datensammelt 


* 

### Annahmen/Folgerung:
* Tool zum Testen vorhanden
* Eingabe code ist immer richtig
    * Trotzdem Testen für Code quaility/korrektheit? 
* Piroritisuerng/Heurisitc für Aktionen Nötig, folgendes kann benutzt werden in allen möglichen Kombinationen:
    * Stadtstatus
        * Event haben eine "sinceRound" und "prevalence" angabe welche für Prioritiserung benutzt werden könnte
    * Keimstatus
    * Ende-Bedingung 
    * Punkte verfügbar/Kosten
        * Skallierungsfaktor 


# Bewertung
* Heuristik: In Möglichst wenig Runden alle Keime eliminieren
    * Wenn Gewinnt, in wenig Runden
    * Wenn Verliert, in möglichst vielen Runden
* Güte des Lösungsansatzes 
* Form der Ausarbeitung 
* Softwarearchitektur und -quailität 
* Mögliche Erweiterung
* [Wenn im Finale] Qualität der Präsentation

In detail, siehe Checkliste Bewertungskriterien der PDF


# Ausarbeitung 
* Installation, Bedienung der Software
* Theoretischen Lösungsansatz 
* Angucken alter Wettbewerbsausarbeitungen: https://github.com/InformatiCup/