Funktionen in der R-Programmierung (mit Beispiel)

Was ist eine Funktion in R?

Eine Funktion in einer Programmierumgebung ist eine Reihe von Anweisungen. Ein Programmierer erstellt eine Funktion, um zu vermeiden , dass dieselbe Aufgabe wiederholt wird , oder um die Komplexität zu verringern .

Eine Funktion sollte sein

• geschrieben, um eine bestimmte Aufgabe auszuführen
• kann Argumente enthalten oder nicht
• einen Körper enthalten
• kann einen oder mehrere Werte zurückgeben oder nicht.

Ein allgemeiner Ansatz für eine Funktion besteht darin, den Argumentteil als Eingabe zu verwenden , den Körperteil zu füttern und schließlich eine Ausgabe zurückzugeben . Die Syntax einer Funktion lautet wie folgt:

function (arglist) {#Function body}

In diesem Tutorial werden wir lernen

• R wichtige eingebaute Funktionen
• Allgemeine Funktionen
• Mathematische Funktionen
• Statistische Funktionen
• Schreibfunktion in R.
• Wann sollen wir Funktion schreiben?
• Funktioniert mit Bedingung

R wichtige eingebaute Funktionen

In R sind viele Funktionen integriert. R stimmt Ihre Eingabeparameter mit seinen Funktionsargumenten ab, entweder nach Wert oder nach Position, und führt dann den Funktionskörper aus. Funktionsargumente können Standardwerte haben: Wenn Sie diese Argumente nicht angeben, nimmt R den Standardwert an.

Hinweis : Sie können den Quellcode einer Funktion anzeigen, indem Sie den Namen der Funktion selbst in der Konsole ausführen.

Wir werden drei Funktionsgruppen in Aktion sehen

• Allgemeine Funktion
• Mathematikfunktion
• Statistische Funktion

Allgemeine Funktionen

Wir sind bereits mit allgemeinen Funktionen wie den Funktionen cbind (), rbind (), range (), sort (), order () vertraut. Jede dieser Funktionen hat eine bestimmte Aufgabe und benötigt Argumente, um eine Ausgabe zurückzugeben. Im Folgenden sind wichtige Funktionen aufgeführt, die Sie kennen müssen:

diff () Funktion

Wenn Sie an Zeitreihen arbeiten , müssen Sie die Reihen stationär halten, indem Sie ihre Verzögerungswerte verwenden . Ein stationärer Prozess ermöglicht einen konstanten Mittelwert, eine konstante Varianz und eine konstante Autokorrelation über die Zeit. Dies verbessert hauptsächlich die Vorhersage einer Zeitreihe. Dies kann einfach mit der Funktion diff () durchgeführt werden. Wir können zufällige Zeitreihendaten mit einem Trend erstellen und dann die Funktion diff () verwenden, um die Reihe zu stationieren. Die Funktion diff () akzeptiert ein Argument, einen Vektor, und gibt eine geeignete verzögerte und iterierte Differenz zurück.

Hinweis : Wir müssen häufig zufällige Daten erstellen, aber zum Lernen und Vergleichen möchten wir, dass die Zahlen maschinenübergreifend identisch sind. Um sicherzustellen, dass wir alle die gleichen Daten generieren, verwenden wir die Funktion set.seed () mit beliebigen Werten von 123. Die Funktion set.seed () wird durch den Prozess des Pseudozufallszahlengenerators generiert, der dafür sorgt, dass alle modernen Computer dieselbe Sequenz haben von Zahlen. Wenn wir die Funktion set.seed () nicht verwenden, haben wir alle unterschiedliche Zahlenfolgen.

set.seed(123)## Create the datax = rnorm(1000)ts <- cumsum(x)## Stationary the seriediff_ts <- diff(ts)par(mfrow=c(1,2))## Plot the seriesplot(ts,)plot(diff(ts),)

Länge () Funktion

In vielen Fällen möchten wir die Länge eines Vektors für die Berechnung kennen oder in einer for-Schleife verwendet werden. Die Funktion length () zählt die Anzahl der Zeilen im Vektor x. Die folgenden Codes importieren den Fahrzeugdatensatz und geben die Anzahl der Zeilen zurück.

Hinweis : length () gibt die Anzahl der Elemente in einem Vektor zurück. Wenn die Funktion an eine Matrix oder einen Datenrahmen übergeben wird, wird die Anzahl der Spalten zurückgegeben.

dt <- cars## number columnslength(dt)

Ausgabe:

## [1] 1

## number rowslength(dt[,1])

Ausgabe:

## [1] 50

Mathematische Funktionen

R hat eine Reihe von mathematischen Funktionen.

Operator	Beschreibung
abs (x)	Nimmt den absoluten Wert von x an
log (x, base = y)	Nimmt den Logarithmus von x mit der Basis y; Wenn base nicht angegeben ist, wird der natürliche Logarithmus zurückgegeben
exp (x)	Gibt das Exponential von x zurück
sqrt (x)	Gibt die Quadratwurzel von x zurück
Fakultät (x)	Gibt die Fakultät von x (x!) Zurück.

# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(x_vector)

Ausgabe:

## [1] 3.806662 3.828641 3.850148 3.871201 3.891820 3.912023 3.931826## [8] 3.951244 3.970292 3.988984 4.007333

#exponentialexp(x_vector)

#squared rootsqrt(x_vector)

Ausgabe:

## [1] 6.708204 6.782330 6.855655 6.928203 7.000000 7.071068 7.141428## [8] 7.211103 7.280110 7.348469 7.416198

#factorialfactorial(x_vector)

Ausgabe:

## [1] 1.196222e+56 5.502622e+57 2.586232e+59 1.241392e+61 6.082819e+62## [6] 3.041409e+64 1.551119e+66 8.065818e+67 4.274883e+69 2.308437e+71## [11] 1.269640e+73

Statistische Funktionen

Die R-Standardinstallation enthält eine Vielzahl statistischer Funktionen. In diesem Tutorial werden wir kurz auf die wichtigste Funktion eingehen…

Grundlegende statistische Funktionen

Operator	Beschreibung
Mittelwert (x)	Mittelwert von x
Median (x)	Median von x
var (x)	Varianz von x
sd (x)	Standardabweichung von x
Skala (x)	Standardwerte (z-Werte) von x
Quantil (x)	Die Quartile von x
Zusammenfassung (x)	Zusammenfassung von x: Mittelwert, Min, Max usw.

speed <- dt$speedspeed# Mean speed of cars datasetmean(speed)

Ausgabe:

## [1] 15.4

# Median speed of cars datasetmedian(speed)

Ausgabe:

## [1] 15

# Variance speed of cars datasetvar(speed)

Ausgabe:

## [1] 27.95918

# Standard deviation speed of cars datasetsd(speed)

Ausgabe:

## [1] 5.287644

# Standardize vector speed of cars datasethead(scale(speed), 5)

Ausgabe:

## [,1]## [1,] -2.155969## [2,] -2.155969## [3,] -1.588609## [4,] -1.588609## [5,] -1.399489

# Quantile speed of cars datasetquantile(speed)

Ausgabe:

## 0% 25% 50% 75% 100%## 4 12 15 19 25

# Summary speed of cars datasetsummary(speed)

Ausgabe:

## Min. 1st Qu. Median Mean 3rd Qu. Max.## 4.0 12.0 15.0 15.4 19.0 25.0

Bis zu diesem Punkt haben wir viele integrierte R-Funktionen gelernt.

Hinweis : Seien Sie vorsichtig mit der Klasse des Arguments, dh numerisch, boolesch oder string. Wenn wir beispielsweise einen Zeichenfolgenwert übergeben müssen, müssen wir die Zeichenfolge in Anführungszeichen setzen: "ABC".

Schreibfunktion in R.

In einigen Fällen müssen wir unsere eigene Funktion schreiben, da wir eine bestimmte Aufgabe erfüllen müssen und keine fertige Funktion vorhanden ist. Eine benutzerdefinierte Funktion umfasst einen Namen , Argumente und einen Textkörper .

function.name <- function(arguments){computations on the argumentssome other code}

Hinweis : Es empfiehlt sich, eine benutzerdefinierte Funktion zu benennen, die sich von einer integrierten Funktion unterscheidet. Es vermeidet Verwirrung.

Eine Argumentfunktion

Im nächsten Snippet definieren wir eine einfache quadratische Funktion. Die Funktion akzeptiert einen Wert und gibt das Quadrat des Werts zurück.

square_function<- function(n){# compute the square of integer `n`n^2}# calling the function and passing value 4square_function(4)

Code Erläuterung:

• Die Funktion heißt square_function; es kann so genannt werden, wie wir wollen.
• Es erhält ein Argument "n". Wir haben den Variablentyp nicht angegeben, damit der Benutzer eine Ganzzahl, einen Vektor oder eine Matrix übergeben kann
• Die Funktion nimmt die Eingabe "n" und gibt das Quadrat der Eingabe zurück.

  Wenn Sie mit der Funktion fertig sind, können wir sie mit der Funktion rm () entfernen.

# nachdem Sie die Funktion erstellt haben

rm(square_function)square_function

Auf der Konsole wird eine Fehlermeldung angezeigt: Fehler: Das Objekt 'square_function' wurde nicht gefunden und weist darauf hin, dass die Funktion nicht vorhanden ist.

Umweltumfang

In R ist die Umgebung eine Sammlung von Objekten wie Funktionen, Variablen, Datenrahmen usw.

R öffnet jedes Mal eine Umgebung, wenn Rstudio dazu aufgefordert wird.

Die verfügbare Umgebung der obersten Ebene ist die globale Umgebung mit dem Namen R_GlobalEnv. Und wir haben die lokale Umgebung.

Wir können den Inhalt der aktuellen Umgebung auflisten.

ls(environment())

Ausgabe

## [1] "diff_ts" "dt" "speed" "square_function"## [5] "ts" "x" "x_vector"

Sie können alle Variablen und Funktionen sehen, die im R_GlobalEnv erstellt wurden.

Die obige Liste hängt für Sie vom historischen Code ab, den Sie in R Studio ausführen.

Beachten Sie, dass sich n, das Argument der Funktion square_function, nicht in dieser globalen Umgebung befindet .

Für jede Funktion wird eine neue Umgebung erstellt. Im obigen Beispiel erstellt die Funktion square_function () eine neue Umgebung innerhalb der globalen Umgebung.

Um den Unterschied zwischen globaler und lokaler Umgebung zu verdeutlichen , untersuchen wir das folgende Beispiel

Diese Funktion nimmt einen Wert x als Argument und fügt ihn zu y hinzu, um außerhalb und innerhalb der Funktion zu definieren

Die Funktion f gibt die Ausgabe 15 zurück. Dies liegt daran, dass y in der globalen Umgebung definiert ist. Jede in der globalen Umgebung definierte Variable kann lokal verwendet werden. Die Variable y hat bei allen Funktionsaufrufen den Wert 10 und ist jederzeit zugänglich.

Mal sehen, was passiert, wenn die Variable y innerhalb der Funktion definiert ist.

Wir müssen `y` löschen, bevor wir diesen Code mit rm r ausführen

Die Ausgabe ist ebenfalls 15, wenn wir f (5) aufrufen, gibt jedoch einen Fehler zurück, wenn wir versuchen, den Wert y zu drucken. Die Variable y befindet sich nicht in der globalen Umgebung.

Schließlich verwendet R die neueste Variablendefinition, um innerhalb des Funktionskörpers zu übergeben. Betrachten wir das folgende Beispiel:

R ignoriert die außerhalb der Funktion definierten y-Werte, da wir explizit eine Variable innerhalb des Funktionskörpers erstellt haben.

Funktion mit mehreren Argumenten

Wir können eine Funktion mit mehr als einem Argument schreiben. Betrachten Sie die Funktion "Zeiten". Es ist eine einfache Funktion, die zwei Variablen multipliziert.

times <- function(x,y) {x*y}times(2,4)

Ausgabe:

## [1] 8

Wann sollen wir Funktion schreiben?

Datenwissenschaftler müssen viele sich wiederholende Aufgaben erledigen. Meistens kopieren und fügen wir wiederholt Codestücke ein. Beispielsweise wird die Normalisierung einer Variablen dringend empfohlen, bevor wir einen Algorithmus für maschinelles Lernen ausführen. Die Formel zum Normalisieren einer Variablen lautet:

Wir wissen bereits, wie man die Funktionen min () und max () in R verwendet. Wir verwenden die tibble-Bibliothek, um den Datenrahmen zu erstellen. Tibble ist bislang die bequemste Funktion, um einen Datensatz von Grund auf neu zu erstellen.

library(tibble)# Create a data framedata_frame <- tibble(c1 = rnorm(50, 5, 1.5),c2 = rnorm(50, 5, 1.5),c3 = rnorm(50, 5, 1.5),)

Wir werden in zwei Schritten fortfahren, um die oben beschriebene Funktion zu berechnen. Im ersten Schritt erstellen wir eine Variable namens c1_norm, die die Neuskalierung von c1 darstellt. In Schritt zwei kopieren wir einfach den Code von c1_norm und fügen ihn ein und ändern ihn mit c2 und c3.

Detail der Funktion mit der Spalte c1:

Nominator :: Datenrahmen $ c1 -min (Datenrahmen $ c1))

Nenner: max (Datenrahmen $ c1) -min (Datenrahmen $ c1))

Daher können wir sie teilen, um den normalisierten Wert der Spalte c1 zu erhalten:

(data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1)) 

Wir können c1_norm, c2_norm und c3_norm erstellen:

Create c1_norm: rescaling of c1data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))# show the first five valueshead(data_frame$c1_norm, 5)

Ausgabe:

## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991

Es klappt. Wir können kopieren und einfügen

data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))

Ändern Sie dann c1_norm in c2_norm und c1 in c2. Wir machen das gleiche, um c3_norm zu erstellen

data_frame$c2_norm <- (data_frame$c2 - min(data_frame$c2))/(max(data_frame$c2)-min(data_frame$c2))data_frame$c3_norm <- (data_frame$c3 - min(data_frame$c3))/(max(data_frame$c3)-min(data_frame$c3))

Wir haben die Variablen c1, c2 und c3 perfekt neu skaliert.

Diese Methode ist jedoch fehleranfällig. Wir könnten kopieren und vergessen, den Spaltennamen nach dem Einfügen zu ändern. Daher empfiehlt es sich, jedes Mal eine Funktion zu schreiben, wenn Sie denselben Code mehr als zweimal einfügen müssen. Wir können den Code in eine Formel umordnen und ihn bei Bedarf aufrufen. Um unsere eigene Funktion zu schreiben, müssen wir geben:

• Name: normalisieren.
• die Anzahl der Argumente: Wir brauchen nur ein Argument, nämlich die Spalte, die wir für unsere Berechnung verwenden.
• Der Körper: Dies ist einfach die Formel, die wir zurückgeben möchten.

Wir werden Schritt für Schritt fortfahren, um die Funktion normalisieren zu erstellen.

Schritt 1) Wir erstellen den Nominator . In R können wir den Nominator in einer Variablen wie dieser speichern:

nominator <- x-min(x)

Schritt 2) Wir berechnen den Nenner : . Wir können die Idee von Schritt 1 replizieren und die Berechnung in einer Variablen speichern:

denominator <- max(x)-min(x)

Schritt 3) Wir führen die Aufteilung zwischen Nominator und Nenner durch.

normalize <- nominator/denominator

Schritt 4) Um den Wert an die aufrufende Funktion zurückzugeben, müssen wir normalize inside return () übergeben, um die Ausgabe der Funktion zu erhalten.

return(normalize)

Schritt 5) Wir sind bereit, die Funktion zu verwenden, indem wir alles in die Klammer einwickeln.

normalize <- function(x){# step 1: create the nominatornominator <- x-min(x)# step 2: create the denominatordenominator <- max(x)-min(x)# step 3: divide nominator by denominatornormalize <- nominator/denominator# return the valuereturn(normalize)}

Testen wir unsere Funktion mit der Variablen c1:

normalize(data_frame$c1)

Es funktioniert perfekt. Wir haben unsere erste Funktion erstellt.

Funktionen sind eine umfassendere Möglichkeit, eine sich wiederholende Aufgabe auszuführen. Wir können die Normalisierungsformel über verschiedene Spalten verwenden, wie unten:

data_frame$c1_norm_function <- normalize (data_frame$c1)data_frame$c2_norm_function <- normalize (data_frame$c2)data_frame$c3_norm_function <- normalize (data_frame$c3)

Obwohl das Beispiel einfach ist, können wir auf die Kraft einer Formel schließen. Der obige Code ist leichter zu lesen und vermeidet insbesondere Fehler beim Einfügen von Codes.

Funktioniert mit Bedingung

Manchmal müssen wir Bedingungen in eine Funktion aufnehmen, damit der Code verschiedene Ausgaben zurückgeben kann.

Bei maschinellen Lernaufgaben müssen wir den Datensatz zwischen einem Zugsatz und einem Testsatz aufteilen. Der Zugsatz ermöglicht es dem Algorithmus, aus den Daten zu lernen. Um die Leistung unseres Modells zu testen, können wir den Testsatz verwenden, um das Leistungsmaß zurückzugeben. R hat keine Funktion zum Erstellen von zwei Datensätzen. Wir können unsere eigene Funktion schreiben, um das zu tun. Unsere Funktion akzeptiert zwei Argumente und heißt split_data (). Die Idee dahinter ist einfach: Wir multiplizieren die Länge des Datensatzes (dh die Anzahl der Beobachtungen) mit 0,8. Wenn wir beispielsweise den Datensatz 80/20 aufteilen möchten und unser Datensatz 100 Zeilen enthält, multipliziert unsere Funktion 0,8 * 100 = 80. 80 Zeilen werden ausgewählt, um unsere Trainingsdaten zu werden.

Wir werden den Luftqualitätsdatensatz verwenden, um unsere benutzerdefinierte Funktion zu testen. Der Luftqualitätsdatensatz enthält 153 Zeilen. Wir können es mit dem folgenden Code sehen:

nrow(airquality)

Ausgabe:

## [1] 153 

Wir werden wie folgt vorgehen:

split_data <- function(df, train = TRUE)Arguments:-df: Define the dataset-train: Specify if the function returns the train set or test set. By default, set to TRUE

Unsere Funktion hat zwei Argumente. Der Argumentzug ist ein boolescher Parameter. Wenn TRUE festgelegt ist, erstellt unsere Funktion den Zugdatensatz, andernfalls erstellt sie den Testdatensatz.

Wir können so vorgehen, wie wir es mit der Funktion normalize () getan haben. Wir schreiben den Code, als wäre es nur ein einmaliger Code, und wickeln dann alles mit der Bedingung in den Körper ein, um die Funktion zu erstellen.

Schritt 1:

Wir müssen die Länge des Datensatzes berechnen. Dies geschieht mit der Funktion nrow (). Nrow gibt die Gesamtzahl der Zeilen im Dataset zurück. Wir nennen die variable Länge.

length<- nrow(airquality)length

Ausgabe:

## [1] 153

Schritt 2:

Wir multiplizieren die Länge mit 0,8. Es wird die Anzahl der auszuwählenden Zeilen zurückgegeben. Es sollte 153 * 0,8 = 122,4 sein

total_row <- length*0.8total_row

Ausgabe:

## [1] 122.4

Wir möchten 122 Zeilen unter den 153 Zeilen im Luftqualitätsdatensatz auswählen. Wir erstellen eine Liste mit Werten von 1 bis total_row. Wir speichern das Ergebnis in der Variablen split

split <- 1:total_rowsplit[1:5] 

Ausgabe:

## [1] 1 2 3 4 5

split wählt die ersten 122 Zeilen aus dem Datensatz aus. Zum Beispiel können wir sehen, dass unser Variablensplit den Wert 1, 2, 3, 4, 5 usw. erfasst. Diese Werte sind der Index, wenn wir die zurückzugebenden Zeilen auswählen.

Schritt 3:

Wir müssen die Zeilen im Luftqualitätsdatensatz basierend auf den in der geteilten Variablen gespeicherten Werten auswählen. Dies geschieht folgendermaßen:

train_df <- airquality[split, ]head(train_df)

Ausgabe:

##[1] Ozone Solar.R Wind Temp Month Day##[2] 51 13 137 10.3 76 6 20##[3] 15 18 65 13.2 58 5 15##[4] 64 32 236 9.2 81 7 3##[5] 27 NA NA 8.0 57 5 27##[6] 58 NA 47 10.3 73 6 27##[7] 44 23 148 8.0 82 6 13

Schritt 4:

Wir können den Testdatensatz mithilfe der verbleibenden Zeilen 123: 153 erstellen. Dies geschieht mit - vor dem Split.

test_df <- airquality[-split, ]head(test_df)

Ausgabe:

##[1] Ozone Solar.R Wind Temp Month Day##[2] 123 85 188 6.3 94 8 31##[3] 124 96 167 6.9 91 9 1##[4] 125 78 197 5.1 92 9 2##[5] 126 73 183 2.8 93 9 3##[6] 127 91 189 4.6 93 9 4##[7] 128 47 95 7.4 87 9 5

Schritt 5:

Wir können die Bedingung innerhalb des Funktionskörpers erstellen. Denken Sie daran, dass wir einen Argumentzug haben, der standardmäßig auf TRUE gesetzt ist, um den Zugsatz zurückzugeben. Um die Bedingung zu erstellen, verwenden wir die if-Syntax:

if (train ==TRUE){train_df <- airquality[split, ]return(train)} else {test_df <- airquality[-split, ]return(test)}

Das ist es, wir können die Funktion schreiben. Wir müssen die Luftqualität nur in df ändern, weil wir unsere Funktion für jeden Datenrahmen testen möchten, nicht nur für die Luftqualität:

split_data <- function(df, train = TRUE){length<- nrow(df)total_row <- length *0.8split <- 1:total_rowif (train ==TRUE){train_df <- df[split, ]return(train_df)} else {test_df <- df[-split, ]return(test_df)}}

Probieren wir unsere Funktion für den Luftqualitätsdatensatz aus. Wir sollten einen Zug mit 122 Reihen und einen Test mit 31 Reihen haben.

train <- split_data(airquality, train = TRUE)dim(train)

Ausgabe:

## [1] 122 6

test <- split_data(airquality, train = FALSE)dim(test)

Ausgabe:

## [1] 31 6