Kurs:Didaktik der Stochastik für Lernumgebungen/Technische Umsetzung/Automatische Notenberechnung

Einleitung

Diese Seite zum Thema Kurs:Didaktik der Stochastik für Lernumgebungen/Technische Umsetzung/Automatische Notenberechnung kann als Wiki2Reveal Folien angezeigt werden. Einzelne Abschnitte werden als Folien betrachtet und Änderungen an den Folien wirken sich sofort auf den Inhalt der Folien aus. Dabei werden die folgenden Teilaspekte im Detail behandelt:

(1) Bestehensgrenzen und Notengebung
(2) Prozentuale Anteile an der Lösung und Schwierigkeitsniveau
(3) Implementation der automatischen Notengebung mit KnitR und R

Zielsetzung

Diese Lernressource zu Automatische Notenberechnung in der Wikiversity hat das Ziel, für Lernumgebungen in die technische Umsetzung einer automatisierten Notengebung einzuführen und erste Erfahrung bei der Implementiertung in R und KnitR zu sammeln.

Defintion - Bestehensgrenze

Für die automatisierte Notengebung liefert die prozentuale Bestehensgrenze $b>0$ im Sinne eines Bernoulli-Experimentes die dichotome Entscheidung $X(\omega )=1$ "bestanden" bzw. $X(\omega )=0$ . Die Normalisierung der erreichten Punktezahl $\omega$ von $n$ möglichen Punkte definiert man die Zufallsgröße: ${\begin{array}{rrcl}X:&\Omega &\rightarrow &\mathbb {R} \\&\omega &\mapsto &X\left(\omega \right)={\begin{cases}1&,&\displaystyle {\frac {\omega }{n}}\geq b\\0&,&\displaystyle {\frac {\omega }{n}}<b\\\end{cases}}\end{array}}$

Abbildung Noten und prozentualer Anteil der Punkte

Bemerkung . Schrittweite

Bei einer prozentualen Bestehensgrenze von 40% ist oben in der Abbildung erkennbar, dass die Schrittweiten oberhalb und unterhalb der Bestehensgrenze unterschiedlich sind.

Aufgabe

Die Bestehensgrenze soll nun auf 35% herabgesetzt werden. Berechnen Sie die dazu die zugehörigen Schrittweiten für die Notengrenzen.

Aufgaben für Lernende / Studierende

Für die folgenden Aufgaben verwenden Sie die R-Markdown-Demodatei^[1] zu dieser Lernressource und ergänzen Sie:

eine Spalte in der Ausgangstabelle eine Spalte ergänzt wird, die bei gegebener Bestehensgrenze $b$ angibt, ob die Klausur bestanden ist oder nicht.
die Festlegung von Noten 1,..,6 bei gegebener Bestehensgrenze
Berechnung von Schwierigkeitsniveaus auf Basis der Punkte für die Lernende, die in der abgegebenen Aufgabe eine bestimmte Punktzahl erreicht haben,

Demodaten einer Klausur

Die geladenen Daten mit Summespalte für data.csv haben die folgende Struktur. Die erste Datenzeile MAX enthält die maximale Anzahl der erreichbaren Punkte. Diese Informationen sind notwendig später den relativen Anteil der erreichten Punkte für die Aufgabe automatisiert berechnen zu können.

Datentabelle

name	aufgabe1	aufgabe2	aufgabe3
MAX	16.0	20	16.0
Anna	10.5	15	13.0
Bert	3.5	13	0.0
Camilla	12.0	8	15.0
Dieter	5.0	6	7.0
Emilia	15.0	15	14.5

Bemerkung - Datenzeile MAX

Wenn die maximale Anzahl der erreichbaren Punkte in der ersten Datenzeile zu finden ist, erleichtert das die automatisierte Auswertung der Klausur bei Ersetzung der Daten in data.csv durch eine neue Datei data1.csv einer weiteren Klausur, die ggf. andere maximale Punktzahlen hat. Bei der Berechnung einer Notenübersicht muss man allerdings die erste Zeile entfernen, da man sonst in der Notenübersicht MAX als Schüler mit der Note "1+" bzw. "sehr gut" zählt.

Implementation in KnitR

In diesem Abschnitt wird die automatische Notengebung in KnitR umgesetzt. Dabei soll eine Funktion für einen Vektor mit Punkten punktvektor $\in \mathbb {R} ^{n}$ aus einer Klassenarbeit bzw. Klausur mit einer Bestehensgrenze bestgrenze $\in \mathbb {R} ^{+}$ .

$punkte\in \mathbb {R} ^{n}$ enthält die Punkte (z.B. aus einer Klausur), für die die Noten ermitteln sollen.
$bestgrenze\in \mathbb {R} ^{+}$ ist die Bestehensgrenze,
$maxpunkte\in \mathbb {R} ^{+}$ ist die maximale Anzahl der Punkte, die in einer Klausur erreicht werden kann.
$notenskala$ ist ein Vektor mit den Notenbezeichnungen z.B. ("sehr gut","gut", ... ,"ungenügend") oder ("1","2","3","4","5","6").

KnitR-Beispieldatei - Notenberechnung

Die nachfolgenden u wurden in KnitR umgesetzt und als Beispieldatei auf GitHub^[2] zur Verfügung gestellt. Speichern Sie dazu in einem Unterverzeichnis data/klausur.csv die Klausurergebnisse als CSV-Datei. Die Demodatei kann später auf Ihrem Rechner durch echte Klausurdaten ersetzt werden. Die erste Zeiten gibt die Spaltenbeschriftungen an. Die zweite Zeile die maximale Punktzahl in den Aufgaben.

Berechnung der Notenskala

In dem folgende R-Code werden mit Hilfe von einer Funktion zu einem Vektor mit Punkten $pPunkte\in \mathbb {R} ^{n}$ und die Note automatisiert für alle Punkte berechnet.

$punkte\in \mathbb {R} ^{n}$ enthält die Punkte (z.B. aus einer Klausur), für die die Noten ermitteln sollen.
$bestgrenze\in \mathbb {R} ^{+}$ ist die Bestehensgrenze,
$maxpunkte\in \mathbb {R} ^{+}$ ist die maximale Anzahl der Punkte, die in einer Klausur erreicht werden kann.
Mit der Funktion notengrenzen_calc(pPunkteMax, pBestGrenze,pBestIndex,pNotenSkala) kann die Notengrenzen berechnen, um die Noten zuordnen danach mit der Funktion `note_zuordnen()` dem Punktevektor zuordnen zu können.
$notenskala$ enthält die Noten, die entsprechend der Notengrenzen den Punkten zugewiesen werden. Diese können Zahlenwert 1-6, Text "sehr gut", "sehr gut-" ..., oder auch Buchstaben A,B,C,D, und F für "failed" (amerikanisches Notensystem) sein, um entsprechend der Notengrenzen dan die Noten zuordnen zu können.
$bestindex\in \mathbb {N}$ ist Index in der Skala, ab der Note vergeben wird, mit dem man gerade noch bestanden hat. Also z.B. für den Vektor ("sehr gut","gut", ... ,"ungenügend") ist es der Index 4 für die Note "ausreichend".

notengrenzen_calc <- function(pPunkteMax, pBestGrenze,pBestIndex,pNotenSkala) {
     grenze = rep(0, length(pNotenSkala))
     imax <- length(pNotenSkala)
     schritt <- pBestGrenze/(imax-pBestIndex)
     ## Index für 6 bis zur 4 berechnen 
     gi <- imax
     ## Grenze unterhalb der Bestehensgrenze
     g <- 0
     while (gi > pBestIndex) {
        # Füge die Grenze in den Vektor ein
        g <- g + schritt
        grenze[gi] <- g
     
        # Vermindere den Index
        gi <- gi - 1 
     }
     ## Grenze oberhalb der Bestehensgrenze
     schritt <- (pPunkteMax - pBestGrenze)/(pBestIndex)
     ## Index für 4 und besser 
     while (gi > 0) {
        g <- g + schritt
        grenze[gi] <- g
        # Vermindere den Index
        gi <- gi - 1 
     }
     ## Rückgabewert Vektor "grenze"
     grenze
}

Funktion zur Notenberechnung

Die Anwendung der folgenden Funktion note_zuordnen() setzt voraus, dass man vorher bei einer gegebenen

maximalen Anzahl von Punkten,
Bestehensgrenze und
einem Bestehensindex für eine Notenskala

die Bestehensgrenze berechnet hat.

note_zuordnen <- function(pPunkte,pGrenzen,pNotenskala) {
     ## Vektor mit der Länge der Punkte erstellen
     ## in dem Vektor wird die Note eingetragen
     note4punkte <- rep(0,length(pPunkte))
     for (i in 1:length(pPunkte)) {
       ## Notenindex auf schlechtest Note setzen
       gi <- length(pNotenskala)-
       ## Noten auf schlechtesten Index setzen
       note4punkte[i] <- pNotenskala[gi]
       ## so lange die Note verbessern bis Note passt
       while ((gi > 0) && (pPunkte[i] >= pGrenzen[gi]))  {
          gi <- gi - 1 
          ## Index gi kann bei Erreichen der Maximalpunkte auch 0 werden
          ## daher Ueberpruefung, ob der Index gi >= 1
          if (gi >= 1) {
            ## Notenbezeichnung setzen 
            note4punkte[i] <- pNotenskala[gi]
          }
       }
     }
     ### Rückgabewert der Noten fuer alle Punkte
     note4punkte        
}

Notenberechnung 1-6

Die Notenskala ist im dem folgende Beispiel mit Text belegt. Die Belegung der Notebezeichnung ist von der Nutzung abhängig und könnte auch der Vektor $(1,2,3,4,5,6)\in \mathbb {N} ^{6}$ sein. Dies hängt vom Anwendungskontext ab.

### Parameter für die Berechnung der Notengrenzen
maxpunkte <- 100  ## Punkte
bestgrenze <- 40 ## Punkte
notenskala <- c("sehr gut","gut","befriedigend","ausreichend","mangelhaft","ungenügend")
bestindex <- 4 ## Index für Note, mit der man gerade noch bestanden hat 4 "ausreichend"

### Aufruf der Funktion "notengrenzen_calc()" 
grenzen <- notengrenzen_calc(maxpunkte, bestgrenze,bestindex,notenskala)
## Ergebnis: grenzen = c(100,85,70,55,40,20)
## Vektor liefert die Grenzen für die Noten 
## z.B. Punkte < 20 bedeutet Note "ungenügend"

  
### Noten berechnen
noten <- noten_zuordnen(punkte, grenzen, notenskala)

### Notenberechnung ist nun abgeschlossen - Ausgabe
print(noten)

Bemerkung - Notengrenzen

Die Intervallbreiten oberhalb der Bestehensgrenze unterscheiden sich von der Intervallbreite unterhalb der Bestehensgrenze. Im obigen Beispiel ist die Intervall oberhalb der Bestehensgrenze 15 und unterhalb der Bestehensgrenze 20.

Noten für Punktevektoren zuordnen

Nun möchte man einem Vektor mit den Punkte aus einer Klausur und oben berechneten Grenzen die Noten aus der Notenskala zuordnen. Dazu definiert man zunächst die Funktion note_zuordnen(), die diese Aufgabe für einen gegebenen Punktvektor übernimmt.

Notenberechnung mit Tendenz

Der folgende R-Code berechnet für einen Vektor punkte mit 5 Klausurergebnissen, die jeweilige Note mit Tendenz (also "3+"). Der Vektor punkte und der Notenvektor noten haben jeweils die gleiche Vektorlänge.

  # Berechne die Notengrenzen
  maxpunkte <- 100  ## Punkte
  bestgrenze <- 40 ## Punkte
  notenskala <- c("1+","1", "1-", "2+", "2", "2-", "3+", "3", "3-", "4+", "4","4-", "5+","5","5-", "6") 
  bestindex <- 12 ## entspricht der "4-" 
  ## ab 5+ beginnt der defizitäre Bereich - nicht bestanden
  
  ### Notengrenzen berechnen
  ### Aufruf der Funktion "notengrenzen_calc()" 
  grenzen <- notengrenzen_calc(maxpunkte, bestgrenze,bestindex,notenskala)

  # Vektor "punkte" enthält Punkte für 5 Klausuren
  punkte <- c(23,92,33,89,60)
  noten <- noten_zuordnen(punkte, grenzen, notenskala)
  ### Noten sind nun im Vektor "noten" berechnet
  ### Vektor "noten" ausgeben mit print()
  print(noten)

Notengebung als Dezimalzahl

Wenn man mit den zugeordneten Noten in R weiter rechnen möchte, bietet es sich an, eine Dezimalzahl 0.7 statt einer Textvariablen "1+" bzw. "sehr gut +" zuzuordnen. Die kann man erreichen, indem man die textliche Belegung der Notenzuordnung mit notenskala durch eine numerischen Wert ersetzt. In dem obigen Codebeispiel muss man dann lediglich die Definition des Vektors Notenskala ersetzen.

  # Berechne die Notengrenzen
  maxpunkte <- 100  ## Punkte
  bestgrenze <- 40 ## Punkte
  notenskala <- c(0.7,1.0, 1.3, 1.7, 2.0, 2.3, 2.7, 3.0, 3.3, 3.7, 4.0,4.3, 4.7,5.0,5.3, 6.0) 
  bestindex <- 12 ## entspricht der 4.3 
  ## ab 4.7 beginnt der defizitäre Bereich - nicht bestanden
  
  ### Notengrenzen berechnen
  ### Aufruf der Funktion "notengrenzen_calc()" 
  grenzen <- notengrenzen_calc(maxpunkte, bestgrenze,bestindex,notenskala)

  # Vektor "punkte" enthält Punkte für 5 Klausuren
  punkte <- c(23,92,33,89,60)
  noten <- noten_zuordnen(punkte, grenzen, notenskala)
  ### Noten sind nun im Vektor "noten" berechnet
  ### Vektor "noten" ausgeben mit print()
  print(noten)
  ### mit den numerischen Noten die auf ganze Noten gerundeten Werte berechnen
  notengerundet <- round(noten)

Ausgaben in KnitR

Ausgabe von Daten und den Berechnungen in dem KnitR-Dokument können hilfreiche Informationen zu der Datenanalyse sein. Dazu gehört die

Ausgabe der Rohdaten zur Klausur,
Ausgabe der berechneten Notengrenzen,
Ausgabe der Rohdaten mit ergänzten Spalten.

Laden der Rohdaten zur Klausur

Daten aus der Datei data/klausur.csv geladen. Die Datei liegt im Unterverzeichnis data/. Diese Unterverzeichnis muss im dem Verzeichnis, in dem die R-Markdowndatei liegt existieren und in dem Verzeichnis data/ muss die Datei klausur.csv zu finden sein.

## Daten aus der Datei "klausur.csv" im Unterverzec
studentdata <- read.csv("data/klausur.csv", header=TRUE, stringsAsFactors=FALSE)

Wenn Sie kein Unterzeichnis data/ existiert und die Daten in dem gleichen Verzeichnis liegen, muss man den Dateinamen der CSV-Datei data/klausur.csv in klausur.csv ändern.

Ausgabe der Rohdaten zur Klausur

Wenn man nun die Datei in der KnitR-Datei mit kable ausgeben möchte, verwendet man den folgenden Code:

knitr::kable(
  studentdata, booktabs = TRUE,
  caption = 'Geladene Daten mit Summespalte für data.csv.'
)

In dem R-Codechunk sollte man die Ausgabe der Codefragmentes zur Tabellendarstellung mit echo=FALSE unterdrücken. Mit den rahmenden Backticks sieht der obige Codechunk wie folgt aus

```{r , echo=FALSE}

  knitr::kable(
    studentdata, booktabs = TRUE,
    caption = 'Geladene Daten mit Summespalte für data.csv.'
  )
```

Notengrenzen in KnitR als Tabelle

Für eine Übersicht zur Klausur macht es ggf. Sinn, die Notengrenzen in einer Tabelle darzustellen.

Funktion zur Berechnung der Tabelle

Zunächst wird eine Funktion verwendet, die eine Tabelle für die Notengrenzen erzeugt. Diese soll dann mit kable dargestellt werden.

tabelle4grenzen <- function (pNotenSkala,pGrenzen) {
  ## Erzeuge einen Dataframe mit der Notenskala in der 1. Spalte 
  return4df <- data.frame(Notenskala=pNotenSkala)  
  max_i <- length(pNotenSkala) 

  Notengrenze <- rep("-",max_i)
  ## Berechne die Notengrenzen z.B. "22-28" 
  for (i in 1:(max_i-1)) {
    Notengrenze[i] <- paste(pGrenzen[i],"-",pGrenzen[i+1])
  }
  ## Setze die Punktegrenzen für schlechteste Note
  Notengrenze[max_i] <- paste(pGrenzen[max_i],"-",0)
  return4df$Notengrenze <-Notengrenze  
  
  ## return Dataframe mit Punktegrenzen
  return4df
}

Die Funktion ist der Bibliothek knitr4education.R enthalten und kann mit source("lib/knitr4education.R") in jedes R-Markdowndokument importiert werden.

Ausgabe der Notengrenzentabelle

Die kann in KnitR mit kable wie folgt erfolgen.

df4grenzen <- tabelle4grenzen(notenskala,grenzen)

knitr::kable(
  df4grenzen, booktabs = TRUE,
  align=c('l','c'),
  caption = 'Punktegrenzen für die Noten'
)

Punktegrenzen für die Noten als Ausgabe

Die folgende Tabelle würde z.B. bei einer maximalen Anzahl der Punkte von 52 und einer Bestehensgrenze von 26 Punkten erzeugt, wenn die Notenskala der folgende Vektor ist.

notenskala <- c("sehr gut","gut","befriedigend","ausreichend","mangelhaft","ungenügend")

Notenskala	Notengrenze
sehr gut	52 - 45.5
gut	45.5 - 39
befriedigend	39 - 32.5
ausreichend	32.5 - 26
mangelhaft	26 - 13
ungenügend	13 - 0

Ergänzte Tabelle der Rohdaten zur Klausur

In der Notenberechnung ergänzt man die Punktesumme, Noten zu einer festgelegten Bestehensgrenze automatisiert. Diese zusätzlichen Spalten ergänzt man in dem Dataframe studentdata gibt die erweiterte Tabelle mit kable aus.

Berechnung der Punktesumme

Die Berechnung der Punktesumme ist nur ein Beispiel für mögliche Berechnungen. Dies können z.B. ebenfalls die oben berechneten Noten als Spalte enthalten.

a1 <- studentdata$aufgabe1
a2 <- studentdata$aufgabe2
a3 <- studentdata$aufgabe3
### Punktesumme der Spaltenvektoren a1, a2, a3 berechnen
summe <- a1 + a2 + a2
### Punktesumme als Spalte in der Tabelle 'studentdata' ergaenzen
studentdata$summe <- summe

Ausgabe der erweiterten Datentabelle

Die Ausgabe der Datentabelle erfolgt analog zu den anderen Aufrufen von kable. Durch die Erweiterung der Rohdatentabelle studentdata um die Summenspalte, enthält die Ausgabe lediglich eine weitere Spalte.

knitr::kable(
  studentdata, booktabs = TRUE,
  caption = 'Geladene Daten mit Summespalte für data.csv.'
)

Resultat der Ausgabe mit Noten

Insgesamt kann man die geladene Daten aus der Datei data.csv mit Punktesumme und automatisiert berechneter Note erweitern (siehe oben).

name	aufgabe1	aufgabe2	aufgabe3	summe	note
MAX	16.0	20	16.0	52.0	sehr gut
Anna	10.5	15	13.0	38.5	befriedigend
Bert	3.5	13	0.0	16.5	mangelhaft
Camilla	12.0	8	15.0	35.0	befriedigend
Dieter	5.0	6	7.0	18.0	mangelhaft
Emilia	15.0	15	14.5	44.5	gut

Aufgabe - Fuzzybewertung der Aufgabe

In den Rohdaten steht in der ersten Datenzeile MAX die maximal erreichbare Anzahl der Punkte in der Aufgabe.
Berechnen Sie zu jeder Aufgabe einen Fuzzy-Bewertung der Aufgabe, die als Dezimalzahl in der Spalte fuzzy1, fuzzy2, fuzzy3 den Fuzzywert für den linguistischen Wert "Aufgabe korrekt bearbeitet" enthält.

Hilfe zur Aufgabe

Wenn die erste Komponente in dem jeweiligen Spaltenvektor für die Aufgabe die maximale Punktzahl enthält, kann man mit relativen Anteil der Bearbeitung durch den Quotienten berechnen. Wurde z.B. in dem Spaltenvektor a3 die erreichten Punktezahlen für die Aufgabe 3 gespeichert, dann enthält die erste Komponente a3[1] die maximale Punktzahl für Aufgabe 3. Mit diesem Wissen kann man die gesuchten Fuzzywerte wie folgt berechnen.

fuzzy1 <- a1/a1[1]
fuzzy2 <- a2/a1[2]
fuzzy3 <- a3/a1[3]

Wenn Sie diese Wert auch in der Tabelle (dataframe) studentdata ergänzen wollen, können Sie das wie folgt realisieren:

studentdata$fuzzy1 <- fuzzy1
studentdata$fuzzy2 <- fuzzy2
studentdata$fuzzy3 <- fuzzy3

Literatur/Quellennachweise

↑ Niehaus, E. (2023) KnitR4Education - erste KnitR-Beispiel für eine Wikiversity Lernressource - URL https://github.com/niebert/knitr4education/blob/main/de/demo_01_codechunks_mathem_formeln.Rmd
↑ Bert Niehaus (2025) KnitR-Beispieldatei zur Noteberechnung - erstellt 2016 - GitHub URL: https://github.com/niebert/knitr4education/blob/main/de/demo_03_notenberechnung.Rmd - Upload 2025/05/19

Siehe auch

Seiteninformation

Diese Lernresource können Sie als Wiki2Reveal-Foliensatz darstellen.

Wiki2Reveal

Dieser Wiki2Reveal Foliensatz wurde für den Lerneinheit Kurs:Didaktik der Stochastik für Lernumgebungen' erstellt der Link für die Wiki2Reveal-Folien wurde mit dem Wiki2Reveal-Linkgenerator erstellt.

Die Seite wurde als Dokumententyp PanDocElectron-SLIDE erstellt.
Link zur Quelle in Wikiversity: https://de.wikiversity.org/wiki/Kurs:Didaktik%20der%20Stochastik%20f%C3%BCr%20Lernumgebungen/Technische%20Umsetzung/Automatische%20Notenberechnung
siehe auch weitere Informationen zu Wiki2Reveal und unter Wiki2Reveal-Linkgenerator.

[1] Niehaus, E. (2023) KnitR4Education - erste KnitR-Beispiel für eine Wikiversity Lernressource - URL https://github.com/niebert/knitr4education/blob/main/de/demo_01_codechunks_mathem_formeln.Rmd

[2] Bert Niehaus (2025) KnitR-Beispieldatei zur Noteberechnung - erstellt 2016 - GitHub URL: https://github.com/niebert/knitr4education/blob/main/de/demo_03_notenberechnung.Rmd - Upload 2025/05/19

[1]

[2]