[JS]
[PLUGIN] ml.plugin
[PLUGIN] math.plugin
[PLUGIN] popup.plugin
[PLUGIN] button.plugin
[DE]

[TITLE] Übung 2 zu Einführung in Maschinelles Lernen
[AUTHOR] PD Stefan Bosse

# Naive Klassifikation

[TOC]

## Daten

### Kategorische Daten

#### Data 1: Der Klassiker: Sportliche Aktivität

[DATA] dataex01D:../data/dataex01D.json

```
X=[]
Y=[Klasse]
```

[CODE] ***X***,*Y*=Klasse={N,P} { lines:10; height:10; }
```js
print(dataex01D);
Table(dataex01D);
```

## Ein einfacher Klassifikator

Nachfolgend wird gezeigt wie auf einfachen kategorischen Daten rein programmatisch ein einfacher Klassifikator programmiert (also algorithmisch erzeugt) werden kann.

- Zunächst ein einfaches Beispiel mit einer Datentabelle aus zwei Eingabevariablen *a* und *b* und einer Zielvariable *c*

| a | b | c |
|--|--|--|
| A1 | B1 | C1 |
| A1 | B2 | C1 |
| A1 | B1 | C1 |
| A2 | B2 | C2 |
| A2 | B1 | C2 |

- Man sieht sofort dass Variable *a* eine starke, und *b* eine schwache variable ist um *c* zu berechnen, und eine Informationsgewinnanalyse würde dies sofort zeigen.

[CODE] Beispiel Datentabelle { lines:10; height:10; }
```js
data = [
{a:'A1',b:'B1',c:'C1' },
{a:'A1',b:'B2',c:'C1' },
{a:'A1',b:'B1',c:'C1' },
{a:'A2',b:'B2',c:'C2' },
{a:'A2',b:'B1',c:'C2' },
{a:'A1',b:'B1',c:'C2' },
]
Table(data);
```

- Nachfolgend zwei beispielhafte Implementierungen der Modellfunktion *M*(*a*,*b*):  (*a*,*b*) → *c*:

[CODE] Beispiel Klassifikator 1 und Test { lines:10; height:10; }
```js
// Klassifikatorfunktion
function classifiy1(instance) {
  if (instance.a=='A1') return 'C1';
  else return 'C2';
}
// Inferenz und Fehlerberechnung
var error = 0;
var results = data.map(function(instance) {
  var pred = classifiy1(instance);
  if (pred != instance.c) error++;
  return {y:pred,y0:instance.c};
});
// Ergebnisse ausgeben
Table(results);
print('Fehlerrate: '+error/data.length*100+'%');
```

[CODE] Beispiel Klassifikator 2 und Test { lines:10; height:10; }
```js
// Klassifikatorfunktion
function classifiy2(instance) {
  switch (instance["a"]) {  // v.a == v["a"]!
    case 'A1': return 'C1';
    case 'A2': return 'C2';
    default : return 'C2';
  }
}
// Inferenz und Fehlerberechnung
var error = 0;
var results = data.map(function(instance) {
  var pred = classifiy2(instance);
  if (pred != instance.c) error++;
  return {y:pred,y0:instance.c};
});
// Ergebnisse ausgeben
Table(results);
print('Fehlerrate: '+error/data.length*100+'%');
```

- Ersezte in obigen Beispielen die Eingabevariable und vergleiche das Ergebnis

[EXERCISE] 1.

Benutze ***D***=Datensatz 1.

0. Wähle das beste Attribute aus mit dem sich die Zielvariable mit der höchsten richtig-positiv Quote bestimmen lässt (also höchster Informationsgewinn), bestimme die Symbolmenge dieser Eingabevariable und der Zielvariable ('N','P'!).
1. Implementiere eine einfache Klassifikationsfunktion um aus *x* das *y* zu berechnen
2. Wende diese Funktion auf alle Instanzen aus ***D*** an
3. Gebe Ergebnisse und Fehler aus

Auswahl der Variable und die berechnete Fehlerrate in das Eingabefeld eintragen.

[INPUT] { lines:2 }

[CODE] Klassifikator für Datensatz 1 { lines:10; height:20; }
```js
// dataex01D verwenden
var data = dataex01D;
// Klassifikatorfunktion
// function classify(instance) { .. }
// Inferenz und Fehlerberechnung
// Ergebnisse ausgeben
```
[EXERCISE]

---

[BUTTON] Hilfe { action:post; label:Absenden; style:"color:red" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Frage'],
  email:{from:'$Email', to:'sbosse@uni-bremen.de', name:'$Name'},
  subject:'Hilfe Kurs ML $TITLE',
  message:'$Name: $Frage',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Einreichung (Assignment #04-18091) { action:post; label:Absenden; style:"color:green" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Kommentar'],
  submit: { from:'$Email', to:'sbosse@uni-bremen.de' },
  assignment:'04-18091',
  name : '$Name',
  comment : '$Kommentar',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Prüfen { action:post; label:Laden; style:"color:browm" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Pin'],
  load: { id:'$ID' },
  pin:[1827,9223],
}
```

[BUTTON] Bewerten (Lehrer) { action:post; label:Absenden; style:"color:blue" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Marking','Pin','Remarks'],
  submit: { id:'$ID', from:'sbosse@uni-bremen.de', name:'$Name' },
  marks : '$Marking',
  remarks : '$Remarks',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:9223,
}
```

---

Naive Klassifikation

Inhalt.

Naive Klassifikation

Daten

Kategorische Daten

Data 1: Der Klassiker: Sportliche Aktivität

Ein einfacher Klassifikator

Daten

Kategorische Daten

Data 1: Der Klassiker: Sportliche Aktivität

DATA: Variable dataex01D Type: {Beispiel, Aussicht, Temperatur, Luftfeuchtigk., Windig?, Klasse} []

X=[]
Y=[Klasse]

X,Y=Klasse={N,P}

print(dataex01D);
Table(dataex01D);

▸

✗

Ein einfacher Klassifikator

Nachfolgend wird gezeigt wie auf einfachen kategorischen Daten rein programmatisch ein einfacher Klassifikator programmiert (also algorithmisch erzeugt) werden kann.

Zunächst ein einfaches Beispiel mit einer Datentabelle aus zwei Eingabevariablen a und b und einer Zielvariable c

a	b	c
A1	B1	C1
A1	B2	C1
A1	B1	C1
A2	B2	C2
A2	B1	C2

Man sieht sofort dass Variable a eine starke, und b eine schwache variable ist um c zu berechnen, und eine Informationsgewinnanalyse würde dies sofort zeigen.

Beispiel Datentabelle

data = [
{a:'A1',b:'B1',c:'C1' },
{a:'A1',b:'B2',c:'C1' },
{a:'A1',b:'B1',c:'C1' },
{a:'A2',b:'B2',c:'C2' },
{a:'A2',b:'B1',c:'C2' },
{a:'A1',b:'B1',c:'C2' },
]
Table(data);

▸

✗

Nachfolgend zwei beispielhafte Implementierungen der Modellfunktion M(a,b): (a,b) → c:

Beispiel Klassifikator 1 und Test

// Klassifikatorfunktion
function classifiy1(instance) {
  if (instance.a=='A1') return 'C1';
  else return 'C2';
}
// Inferenz und Fehlerberechnung
var error = 0;
var results = data.map(function(instance) {
  var pred = classifiy1(instance);
  if (pred != instance.c) error++;
  return {y:pred,y0:instance.c};
});
// Ergebnisse ausgeben
Table(results);
print('Fehlerrate: '+error/data.length*100+'%');

▸

✗

Beispiel Klassifikator 2 und Test

// Klassifikatorfunktion
function classifiy2(instance) {
  switch (instance["a"]) {  // v.a == v["a"]!
    case 'A1': return 'C1';
    case 'A2': return 'C2';
    default : return 'C2';
  }
}
// Inferenz und Fehlerberechnung
var error = 0;
var results = data.map(function(instance) {
  var pred = classifiy2(instance);
  if (pred != instance.c) error++;
  return {y:pred,y0:instance.c};
});
// Ergebnisse ausgeben
Table(results);
print('Fehlerrate: '+error/data.length*100+'%');

▸

✗

Ersezte in obigen Beispielen die Eingabevariable und vergleiche das Ergebnis

Aufgabe. 1.

Benutze D=Datensatz 1.

Wähle das beste Attribute aus mit dem sich die Zielvariable mit der höchsten richtig-positiv Quote bestimmen lässt (also höchster Informationsgewinn), bestimme die Symbolmenge dieser Eingabevariable und der Zielvariable ('N','P'!).
Implementiere eine einfache Klassifikationsfunktion um aus x das y zu berechnen
Wende diese Funktion auf alle Instanzen aus D an
Gebe Ergebnisse und Fehler aus

Auswahl der Variable und die berechnete Fehlerrate in das Eingabefeld eintragen.

Klassifikator für Datensatz 1

// dataex01D verwenden
var data = dataex01D;
// Klassifikatorfunktion
// function classify(instance) { .. }
// Inferenz und Fehlerberechnung
// Ergebnisse ausgeben

▸

✗

Hilfe

Einreichung (Assignment #04-18091)

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.8.8 (c) Dr. Stefan Bosse (Fri Dec 11 2020 15:40:10 GMT+0100 (CET))