Letzte Aktualisierungen Kommentarverlauf ein-/ausschalten | Tastaturkürzel

  • aaron 11:50 am 19. October 2016 permalink | Antwort  

    Ubuntu: automatische Updated 

    vi /etc/apt/apt.conf.d/10periodic

    APT::Periodic::Update-Package-Lists "1";
    APT::Periodic::Download-Upgradeable-Packages "1";
    APT::Periodic::AutocleanInterval "1";

    vi /etc/apt/apt.conf.d/50unattended-upgrades

    Unattended-Upgrade::Allowed-Origins {
    "${distro_id}:${distro_codename}-security";
    "${distro_id}:${distro_codename}-updates";
    // "${distro_id}:${distro_codename}-proposed";
    // "${distro_id}:${distro_codename}-backports";
    };
     
  • aaron 23:59 am 18. October 2016 permalink | Antwort  

    R Programmierung: Auswertung der Titanic Daten von Kaggle 

    Titanic Datensatz einlesen

    train <- read.csv("C:/[PFAD]/train.csv", header = TRUE)

    Information über die Datenstruktur

    str (train)

    Ergebnis:
    ‚train.frame‘: 891 obs. of 11 variables:
    $ survived: int 0 1 1 1 0 0 0 0 1 1 …
    $ pclass : int 3 1 3 1 3 3 1 3 3 2 …
    $ name : Factor w/ 891 levels „Abbing, Mr. Anthony“,..: 109 191 358 277 16 559 520 629 417 581 …
    $ sex : Factor w/ 2 levels „female“,“male“: 2 1 1 1 2 2 2 2 1 1 …
    $ age : num 22 38 26 35 35 NA 54 2 27 14 …
    $ sibsp : int 1 1 0 1 0 0 0 3 0 1 …
    $ parch : int 0 0 0 0 0 0 0 1 2 0 …
    $ ticket : Factor w/ 681 levels „110152“,“110413″,..: 524 597 670 50 473 276 86 396 345 133 …
    $ fare : num 7.25 71.28 7.92 53.1 8.05 …
    $ cabin : Factor w/ 148 levels „“,“A10″,“A14″,..: 1 83 1 57 1 1 131 1 1 1 …
    $ embarked: Factor w/ 4 levels „“,“C“,“Q“,“S“: 4 2 4 4 4 3 4 4 4 2 …

    Die ersten Datensätzte ink. Spaltenüberschrift anzeigen lassen

    head (train)

    Ergebnis:
    survived pclass name sex age sibsp parch ticket fare cabin embarked
    1 0 3 Braund, Mr. Owen Harris male 22 1 0 A/5 21171 7.2500 S
    2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Thayer) female 38 1 0 PC 17599 71.2833 C85 C
    3 1 3 Heikkinen, Miss. Laina female 26 0 0 STON/O2. 3101282 7.9250 S
    4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35 1 0 113803 53.1000 C123 S
    5 0 3 Allen, Mr. William Henry male 35 0 0 373450 8.0500 S
    6 0 3 Moran, Mr. James male NA 0 0 330877 8.4583 Q

    Anzahl der Zeilen & Spalten bzw. Datensätze

    dim(tableName)
    oder
    nrow (train)
    ncol (train)

    Ergebnis:
    891
    11

    Anzahl überlebende und verstorbene Passagiere

    table (train$survived)x

    Ergebnis:
    342 Überlebende
    549 Verstorbene

    Darstellung:

    pie ( table(train$survived), labels=c( paste("Verstorbene =", table (train$survived), "Personen"), "Überlebende"), main = "Anzahl überlebende und verstorbene Passagiere" )

    Anzahl überlebende und verstorbene Passagiere

    1. Prozentuale Auswertung
    prop.table(table (train$survived))

    Ergebnis:
    38% Überlebende
    62% Verstorbene

    Übersicht über das Geschlecht der Reisenden

    table (train$sex)

    Ergebnis:
    Anzahl weibliche Passagiere: 314
    Anzahl männliche Passagiere: 577

    Darstellung:

    barplot(table (train$sex), col = c("pink", "blue"), ylab = "Anzahl Passagiere", main = "Anzahl Passagiere nach Geschlecht unterteilt", legend.text = TRUE, args.legend = list(x=0.5, y=600), ylim = c(0,600) )

    Übersicht über das Geschlecht der Reisenden

    Anzahl überlebende und verstorbene Passagiere nach Geschlecht

    table(train$sex, train$survived)

    Ergebnis:
    Anzahl überlebende Frauen: 233
    Anzahl verstorbene Frauen: 81
    Anzahl überlebende Männer: 109
    Anzahl verstorbene Männer: 468

    Darstellung:

    barplot(table(train$sex, train$survived), col = c("pink", "blue"), ylab = "Anzahl Passagiere", xlab = "0 = verstorben | 1 = überlebt ", main = "Übersicht überlebende und verstorbene Passagiere", legend.text = TRUE, args.legend = list(x=2.4, y=600), ylim = c(0,600) )

    Anzahl überlebende und verstorbene Passagiere nach Geschlecht

    Anzahl (prozentual) überlebende und verstorbene Passagiere nach Geschlecht (ausgehend von Gesamtzahl der Passagiere)

    prop.table(table(train$sex, train$survived))

    Ergebnis:
    Anzahl überlebende Frauen: 26%
    Anzahl verstorbene Frauen: 9%
    Anzahl überlebende Männer: 12%
    Anzahl verstorbene Männer: 53%

    Anzahl (prozentual) überlebende und verstorbene Passagiere (geschlechtsspezifisch)

    prop.table(table(train$sex, train$survived),1)

    Ergebnis:
    Anzahl überlebende Frauen: 26% aller Frauen
    Anzahl verstorbene Frauen: 74%
    Anzahl überlebende Männer: 19% aller Männer
    Anzahl verstorbene Männer: 81%

    Anzahl der Personen pro Klasse

    table (train$pclass)

    Ergebnis:
    Erste Klasse: 216 Personen
    Zweite Klasse: 184 Personen
    Dritte Klasse: 491 Personen

    Anzahl der Überlebende und verstorbene pro Klasse (ausgehend von Gesamtzahl der Passagiere)

    table(train$survived, train$pclass)

    Ergebnis:
    Erste Klasse:
    Anzahl überlebende: 136
    Anzahl verstorbene: 80

    Zweite Klasse:
    Anzahl überlebende: 87
    Anzahl verstorbene: 97

    Dritte Klasse:
    Anzahl überlebende: 119
    Anzahl verstorbene: 372

    Darstellung:

    dotchart(table(train$survived, train$pclass), pch = 15, col="blue", gcolor = "red", lcolor = "orange", xlab = "Anzahl überlebende und verstorbene Passagiere", ylab = "Überlebende und versorbene Passagiere nach Klassen", main = "Auflistung aller überlebenden und verstorbenene Passagiere nach Klassen" )

    Anzahl der Überlebende und verstorbene pro Klasse (ausgehend von Gesamtzahl der Passagiere)

    Anzahl (prozentual) der Überlebende pro Klasse (ausgehend von Gesamtzahl der Passagiere)

    prop.table(table(train$survived, train$pclass))

    Ergebnis:
    Erste Klasse
    Anzahl überlebende: 15%
    Anzahl verstorbene: 9%

    Zweite Klasse
    Anzahl überlebende: 10%
    Anzahl verstorbene: 11%

    Dritte Klasse
    Anzahl überlebende: 13%
    Anzahl verstorbene: 42%

    Anzahl (prozentual) der überlebenden und verstorbenen Passgiere aus der ersten Klasse

    100/216*136 #62.96296
    100/216*80 #37.03704

    Ergebnis:
    63% der Passagiere aus der ersten Klasse haben überlebt
    37% der Passagiere aus der ersten Klasse sind verstorben

    Ergebnis für die zweite Klasse
    47% der Passagiere aus der zweiten Klasse haben überlebt
    53% der Passagiere aus der zweiten Klasse sind verstorben

    Ergebnis für die dritte Klasse
    24% der Passagiere aus der dritten Klasse haben überlebt
    76% der Passagiere aus der dritten Klasse sind verstorben

    Anzahl überlebende Frauen und Männer aus der einzelnen Klassen

    table(train$sex, train$survived, train$pclass)

    Ergebnis:
    Erste Klasse
    Überlebende Frauen: 91
    Verstorbene Frauen: 3
    Überlebende Männer: 45
    Verstorbene Männer: 77

    Zweite Klasse
    Überlebende Frauen: 70
    Verstorbene Frauen: 6
    Überlebende Männer: 17
    Verstorbene Männer: 91

    Dritte Klasse
    Überlebende Frauen: 72
    Verstorbene Frauen: 72
    Überlebende Männer: 47
    Verstorbene Männer: 300

    Alter der Passagiere

    qplot(age, ylab = "Number", main = "Alter der Passagiere", data = train, geom = "bar")

    Alter der Passagiere

    Durchschnittsalter der Passagiere

    summary(train$age)

    Ergebnis:
    Min. 1st Qu. Median Mean 3rd Qu. Max. NA’s
    0.42 20.12 28.00 29.70 38.00 80.00 177

    Durchschnittsalter der Überlebenden Frauen aus der ersten Klasse

    summary(train[train$survived=="1" & train$sex=="male" & train$pclass=="1" ,]$age)

    Ergebnis:
    Min. 1st Qu. Median Mean 3rd Qu. Max. NA’s
    14.00 23.25 35.00 34.94 44.00 63.00 9

    Ergebnis für die zweite Klasse:
    Min. 1st Qu. Median Mean 3rd Qu. Max. NA’s
    2.00 21.75 28.00 28.08 35.25 55.00 2

    Ergebnis für die dritte Klasse:
    Min. 1st Qu. Median Mean 3rd Qu. Max. NA’s
    0.75 13.50 19.00 19.33 26.50 63.00 25
    Anzahl Kinder in der ersten Klasse (Annahme: Kinder sind unter 18):
    Eingabe:
    sum (table(train[train$pclass==“1″ & train$age < 18 ,]$age))

    Ergebnis:
    12

    Ergebnis für die zweite Klasse:
    23

    Ergebnis für die dritte Klasse:
    78

    Anzahl verstorbene Kinder aus der ersten Klasse

    sum (table(train[train$survived=="0" & train$pclass=="1" & train$age < 18 ,]$age))

    Ergebnis:
    1

    Ergebnis für die zweite Klasse:
    2

    Ergebnis für die dritte Klasse:
    49

    Anzahl überlebende Kinder (Mädchen) aus der ersten Klasse

    sum (table(train[train$survived=="1" & train$sex=="female" & train$pclass=="1" & train$age < 18 ,]$age))

    Ergebnis:
    7

    Ergebnis für die zweite Klasse:
    12

    Ergebnis für die dritte Klasse:
    19

    Anzahl verstorbene Kinder (Mädchen) aus der ersten Klasse

    sum (table(train[train$survived=="0" & train$sex=="female" & train$pclass=="1" & train$age < 18 ,]$age))

    Ergebnis:
    1

    Ergebnis für die zweite Klasse:
    0

    Ergebnis für die dritte Klasse:
    16

    Information Gain

    Def.: Der Information Gain ermittelt das Attribut, welches den meisten Informationsgehalt bringt. Es hat das Ziel, die Tiefe des Entscheidungsbaumes zu minimieren. Quelle: [Künstliche Intelligenz: Ein moderner Ansatz]

    1. Paket ‚FSelector‘ installieren und laden
    install.packages("FSelector")
    library (FSelector)
    1. Berechnung von ‚Information gain‘ – ‚target value‘ entspricht ‚train$survived‘.
    information.gain(train)
    1. Ergebnis:

    attr_importance
    pclass 0.053608163
    name 1.609435396
    sex 0.145685212
    age 0.008687071
    sibsp 0.000000000
    parch 0.000000000
    ticket 1.355042740
    fare 0.048528443
    cabin 0.318976005
    embarked 0.022301869

    Die wichtigsten Attribute, für das Überleben der Passagiere sind ’name‘ und ‚ticket‘.

    Feststellen, ob die Spalte ’name‘ Duplikate beinhaltet

    anyDuplicated( as.character(train$name) )

    Ergebnis:
    0 # Keine Duplikate

    Nach (Mrs., Miss., Mr., Master.) filtern

    titles <- NULL
    mrs <- NULL
    miss <- NULL
    mr <- NULL
    master <- NULL
    other <- NULL
    ages <- NULL
    parseTitle <- function(name) {
    name <- as.character(name)
    if (length(grep("Mrs.", name)) > 0) {
    mrs <<- c(mrs, name)
    return ("Mrs.")
    } else if (length(grep("Miss.", name)) > 0) {
    miss <<- c(miss, name)
    return ("Miss.")
    } else if (length(grep("Mr.", name)) > 0) {
    mr <<- c(mr, name)
    return ("Mr.")
    } else if (length(grep("Master.", name)) > 0) {
    master <<- c(master, name)
    return ("Master.")
    } else {
    other <<- c(other, name)
    return ("Other")
    }
    }
    for (i in 1:nrow(train)) {
    titles <- c(titles, parseTitle(train[i, "name"]))
    ages <<- c(ages, train[i,5])
    }
    table(titles)

    Ergebnis:
    Master. Miss. Mr. Mrs. Other
    40 180 518 129 24

    Anzahl überlebende und verstorbene nach Title

    table(titles, train$survived)

    Ergebnis:
    titles 0 1
    Master. 17 23
    Miss. 54 126
    Mr. 436 82
    Mrs. 27 102
    Other 15 9

    Anzahl überlebende und verstorbene nach Title (Prozentual)

    100/40*17 # 42,5%
    100/40*23 # 57,5%

    Ergebnis:
    titles 0 1
    Master. 42,5% 57,5%
    Miss. 30% 70%
    Mr. 84,2% 15,8%
    Mrs. 20,9% 79,1%
    Other 62,5% 37,5%

    Titel nach Klassen unterteilt

    table(titles, train$survived, train$pclass)

    Ergebnis:
    Erste Klasse
    titles 0 1
    Master. 0 3
    Miss. 2 44
    Mr. 70 38
    Mrs. 1 43
    Other 7 8

    Zweite Klasse
    titles 0 1
    Master. 0 9
    Miss. 1 31
    Mr. 83 8
    Mrs. 5 38
    Other 8 1

    Dritte Klasse
    titles 0 1
    Master. 17 11
    Miss. 51 51
    Mr. 283 36
    Mrs. 21 21
    Other 0 0

    Alter der Passagiere innerhalb der einzelnen Klassen berechnen

    table(titles, ages)

    Ergebnis:

    1. Der älteste Master. ist 12
    2. Die älteste Miss. ist 63
    3. Der älteste Mr. ist 80
    4. Die älteste Mrs. ist 63
     
  • aaron 23:59 am 18. October 2016 permalink | Antwort  

    R Programmierung: R-Befehle Sammlung 

    Kommentar

    # Ich bin ein Kommentar

    Ausgabe

    • print(„Hello World“)
    • cat(„Hello“, „World“)

    Information über R-Befehle

    1. Informationen über einen bestimmten Befehlt z.B. ‚which‘ ermitteln

    • apropos(„which“)
    • help(which)
    • ?which
    • RSiteSearch(„which“)

    Befehl-Historie & Exit

    1. Zuvor eingegebene Befehle anzeigen

    history()

    1. RStudio Verlassen

    q()

    Arbeitsverzeichnis

    1. Mein R Arbeitsverzeichnis anzeigen

    getwd()

    # Arbeitsverzeichnis ändern

    1. Ein neues Arbeitsverzeichnis angeben

    setwd(‚PFAD‘)

    R-Befehle/Script Speichern

    # R-Befehle bzw. R-Scribt lokal speichern
    save (myTable, file=“C:/Users/axxKreis/Desktop/myTable.RData“)

    R-Befehle/Script laden

    1. Persistierte Ergebnisse laden

    load (file=“C:/Users/axxKreis/Desktop/myTable.RData“)

    CSV-Datei laden

    1. Eine Tabelle (CSV-Datei) laden

    myCsvTable <- read.table(file=“C:/[PFAD]/myCsvTable.csv“, header=TRUE, sep=“;“)
    oder
    myCsvTable <- read.csv(file=“C:/[PFAD]/myCsvTable.csv“, header=TRUE, sep=“;“)

    Bibliotheken

    Informationen über vorhandene Bibliothelen

    1. Gibt an, wo die Bibiotheken installiert sind

    .libPaths()

    1. Die installierten basis Pakete anzeigen lassen

    getOption(„defaultPackages“)

    1. Die Liste alle Pakete, die aktuell geladen wurden

    (.packages())

    1. Alle Pakete, die bereits installiert wurden und zur Verfügung stehen

    (.packages(all.available=TRUE))
    oder
    library() # Für detaillierte Informationen
    oder
    installed.packages()

    1. Ort, an der sich die installierten Pakete bzw. libs befinden

    Sys.getenv(„R_LIBS_USER“)

    Bibliothek laden

    1. Existierende Bibliothek z.B. rpart laden

    library(rpart)

    Bibliothek installieren

    install.packages(c(„tree“,“maptree“))
    install.packages(„Name der Bibiothek“, dependencies=TRUE)

    Öffentliche Liste von R Bibliotheken

    https://cran.r-project.org/web/packages/available_packages_by_date.html

    Installierte Pakete updaten

    update.packages()

    Bibliotheken beim Start von R-Studio laden

    1. Mit einem Texteditor im Admin-Modus die folgende Datei anpassen: C:\Program Files\R\R-3.2.4\etc\Rprofile.site
    2. Innerhalb der Datei die gewünschten Bibliotheken eintragen

    library(DBI)
    library(FSelector)
    library(ggplot2)
    library(lattice)
    library(RODBC)
    library(RMySQL)
    library(lattice)

    Datenbank Bibliotheken installieren und laden

    RODBC entspricht ODBC
    DBI entspricht  JDB
    RMySQL entspricht  MySQL

    1. DB Packages installieren

    install.packages(„RODBC“)
    install.packages(„DBI“)
    install.packages(„RMySQL“) # MySQL

    1. Installiertes Paket laden

    library(RODBC) # Im Fehlerfall wird eine Meldung angezeigt. Ansonsten keine Ausgabe.
    library(DBI)
    library(RMySQL)

    Bibliothek für Datenverarbeitung

    install.packages(„FSelector“)

    Bestimmung der Entropy für ‚target value‘

    entropy (entropyTargetValue)

    Information Gain

    information.gain(data)

    1. ‚Information Gain‘ für das Attribut ‚xxx‘ in Bezug auf das ‚target value‘ bestimmen

    information.gain (head(data[c(„TARGET.VALUE“,“xxx“)],length(data$TARGET.VALUE)))

    Bibliothek für Visiualisierungs

    1. Visualisierungspakete

    • lattice # Muss installiert und geladen werden
    • ggplot2

    Datentypen

    1. Am meisten verwendeten Datentypen
    • Vectors
      • Logical
      • Numeric
      • Integer
      • Complex (1+2x)
      • Character
      • Raw (Hexadezimal)
    • Lists
    • Matrices
    • Arrays
    • Factors

    Variablen (Symbol)

    Deklaration

    a <- 1
    oder
    a = 1

    1. Funktionale Schreibweise

    ‚<-‚(a,1)

    Alle Variablen anzeigen

    ls()

    1. Alle Variablen, die zum Pattern passen anzeigen

    ls(pattern = „var“)

    1. Alle Variablen inkl. die versteckten Dateien anzeigen

    ls (all.names = TRUE)

    Variable/n ‚a‘ löschen

    rm(a)

    1. Alle Variablen löschen

    rm(list = ls())

    Variablen miteinander vergleichen

    a = 1
    b = 2
    a==b # FALSE

    Operatoren

    Arithmetische Operatoren

    • +
    • /

    %%
    %/%
    ^

    Relationale Operatoren

    >
    <
    ==
    <=
    >=
    !=

    Logische Operatoren

    &
    |
    !
    &&
    ||

    Zuweisungsoperatoren

    <− (lokal)
    =
    <<− (global)
    ->
    ->>

    Sonstige Operatoren

    :
    %in%
    %*%

    Bespiele

    1. Module (%%)

    a = c(4, 8, 12)
    b = c(12, 8, 4)
    a%%b

    Ergebnis:
    4 0 0

    1. Wie oft passen die Werte aus Vektor ‚a‘ in Vector ‚b‘

    a = c(4, 8, 12)
    b = c(12, 8, 4)
    a%/%b

    Ergebnis:
    0 1 3

    1. Vektor ‚a‘ um die Zahlen in Vektor ‚b‘ exponieren z.B. 2*2*2=8; 3*3=9; 4*4=16

    a = c(2, 3, 4)
    b = c(3, 2, 2)
    a^b

    Ergebnis:
    8 9 16

    1. Kontrollieren, ob die Werte von Vektor ‚a‘ größer sind als die von Vektor ‚b‘

    a = c(4, 8, 12)
    b = c(12, 8, 4)
    a>b

    Ergebnis:
    FALSE FALSE TRUE

    1. Gibt true aus, falls die Werte von Vaktor ‚a‘ und ‚b‘ TRUE sein sollten

    a = c(2, TRUE, 4)
    b = c(3, FALSE, 2)
    a&b

    Ergebnis:
    TRUE FALSE TRUE

    1. Gibt TRUE aus, falls ein Wert eines Vektors TRUE sein sollte z.B. 0 und 0 = FALSE oder FALSE und FALSE = FALSE

    a = c(3,0,TRUE,FALSE, 0)
    b = c(4,0,FALSE,FALSE, 0.1)
    a|b

    Ergebnis:
    TRUE FALSE TRUE FALSE TRUE

    1. Beinhaltet ein Vektor einen bestimmten Wert

    a = c(3,0,TRUE,FALSE, 0)
    3%in%a

    Ergebnis:
    TRUE
    String

    String

    1. einfache Anführungsstriche werden intern in doppelte umgewandelt

    ‚hello‘
    „Hello“

    Länger einer Zeichenkette ermitteln

    nchar(a)

    Substring

    a=“abcdefg“
    substr(a,3,5)

    Ergebnis:
    cde

    String Verkettung

    a <- „Hello“
    b <- ‚How‘
    c <- „are you?“

    paste(a,b,c)
    „Hello How are you?“

    paste(a,b,c, sep = „@“)
    „Hello@How@are you?“

    paste(a,b,c, sep = „“, collapse = „“)
    „HelloHoware you? “

    5 Stelligen String erzeugen

    format(18, width = 5)
    [1] “ 18″

    Ausrichtung der Ausgabe

    format(„Hello“, width = 8, justify = „centre“) #left, right, centre, none
    “ Hello “

    String groß und klein schreiben

    toupper(x)
    tolower(x)

    Faktor

    v = c(„thomas“, „thomas“, „thomas“, „linda“)

    levels(v)
    NULL

    typeof(v)
    [1] „character“

    class(v)
    [1] „character“

    1. Faktor Umwandlung & kontrollieren

    v = factor(v)

    is.factor(v)
    TRUE

    levels(v)
    „linda“ „thomas“

    typeof(v)
    „integer“

    class(v)
    „factor“

    1. Innerhalb von ‚data frame‘ werden Strings in Faktoren umgewandelt

    a <- c(„Thomas“, „Linda“, „Felix“, „Sam“)
    b <- c(34,19,18,56)
    myDataFrame <- data.frame(a,b)
    is.factor(a)
    is.factor(myDataFrame$a)

    Ergebnis:
    FALSE
    TRUE

    1. Reihenfolge der Faktoren bestimmen

    a <- factor( c(„Thomas“, „Linda“, „Felix“, „Sam“, „Linda“)

    Ergebnis:
    Levels: Felix Linda Sam Thomas

    1. Reihenfolge ändern

    a <- factor( a, levels = c(„Linda“, „Sam“, „Thomas“, „Felix“) )

    Ergebnis:
    Levels: Linda Sam Thomas Felix

    1. Faktor generieren – 4 gibt an, wie oft ein Faktor vorkommen soll und 2 gibt an, wieviele der Faktor vorkommen sollen – In diesem Beispiel soll „Linda“ und „Sam“ jeweils 4x vorkommen.

    a <- gl(2, 4, labels = c(„Linda“, „Sam“, „Thomas“, „Felix“))

    Ergebnis:
    Linda Linda Linda Linda Sam Sam Sam Sam
    Levels: Linda Sam Thomas Felix
    Vektor

    1. Vektor erstellen

    myVector <- c(1,2,c(3,4),5)

    Ergebnis:
    1 2 3 4 5

    1. Wenn ein Vektor ein String beinhaltet, werden alle non-string Werte in Strings umgewandelt

    c(‚hello‘,0,TRUE)

    Ergebnis:
    „hello“ „0“ „TRUE“

    1. Vektor Index auslesen

    days <- c(„mo“, „di“, „mi“, „do“, „fr“, „sa“, „so“)
    days[c(1,3)]

    Ergebnis:
    „mo“ „mi“

    1. Jeden zweiten Wert ausgeben

    days <- c(„mo“, „di“, „mi“, „do“, „fr“, „sa“, „so“)
    days[c(TRUE,FALSE)]

    Ergebnis:
    „mo“ „mi“ „fr“ „so“

    1. Einzelne Index entfernen

    days <- c(„mo“, „di“, „mi“, „do“, „fr“, „sa“, „so“)
    days[c(-2,-3)]

    Ergebnis:
    „mo“ „do“ „fr“ „sa“ „so“

    1. Index Reihenfolge bestimmen

    days <- c(„mo“, „di“, „mi“, „do“, „fr“, „sa“, „so“)
    days[c(1,7,6,5,4,3,2)]

    Ergebnis:
    „mo“ „so“ „sa“ „fr“ „do“ „mi“ „di“

    1. Operatoren auf zwei Vektoren anwenden

    +, -, *, /

    1. Ungleiche Länge wird wie folgt gerechnet: 1*1, 2*2, 3*3, 4*1, 5*2, 6*3

    a = c(1, 2, 3)
    b = c(1, 2, 3, 4, 5, 6)
    a*b

    Ergebnis:
    1 4 9 4 10 18

    1. Vektor Sortierung (numerisch und Strings)

    a = c(1, 4, 9, 4, 10, 18)
    sort(a)

    1. Reihenfolge der Sortierung ändern

    sort(a, decreasing = TRUE)

    1. Länge ermitteln

    length (myVector)

    1. Sortieren

    sort(myVector)

    1. Duplikate erkennen

    duplicated (myVector)

    1. Vektor mit ganzen Zahlen zwischen 1 und 50

    1:50

    1. Dritte Stelle eines Vektors auslesen

    a[3]

    1. Erste bis dritte Stelle des Vektors auslesen

    a[1:3]

    1. Vectoren zusammenfügen bzw. Tabelle bauen

    first.name <- c(„Hannes“, „Julia“)
    last.name <- c(„Müller“, „Schmidt“)
    myTable <- data.frame(first.name, last.name)

    oder

    y <- c(„A“, „B“)
    paste(x,y) # Ergebnis: „a A“ „b B“ „a C“

    oder

    rbin (x, y)

    oder

    cbind (x,y)

    Liste

    1. Eine Liste erstellen und den name ‚meineListe‘ geben

    meineListe <- list(1, 2, c(3,4))

    Ergebnis:
    [[1]]
    [1] 1

    [[2]]
    [1] 2

    [[3]]
    [1] 3 4

    1. Listen bzw. Elemente der Liste betitteln

    names(meineListe) <- c(„Element1“, „Element2“) # die ersten beideb Listen betitteln

    Ergebnis:
    $Element1
    [1] 1

    $Element2
    [1] 2

    $<NA> # Für das dritte Element wurde kein Titel vergeben
    [1] 3 4

    1. Die Namen der Listen explizit ausgeben

    names(meineListe)

    1. Zugriff auf die Listenelemente

    meineListe[1]
    oder
    meineListe$Element1

    1. Liste komplett überschreiben

    meineListe <- list(c(10, 20, 30), „Hello Liste“)

    1. Listenelement überschreiben

    meineListe[2] <- „Hello World!“

    1. Listen miteinander verknüpfen

    a = list(1,2,3)
    b = list(4,5,6)
    meineNeueListe = c(a,b)

    1. Liste in ein Vektor umwandeln

    unlist(meineNeueListe)

    Ergebnis:
    [1] 1 2 3 4 5 6

    Matrix

    1. Matrix erstellen (immer zweidimensional)

    matrix( c(1,2,3,4,5,6), ncol = 3, nrow = 2, byrow = FALSE)

    Ergebnis:
    [,1] [,2] [,3]
    [1,] 1 3 5
    [2,] 2 4 6

    oder

    matrix( c(1,2,3,4,5,6), ncol = 3, nrow = 2, byrow = TRUE)
    Ergebnis:
    [,1] [,2] [,3]
    [1,] 1 2 3
    [2,] 4 5 6

    1. Metrix mit vorgegbenem Zeilen- und Spaltenbezeichnung

    rownames = c(„row1“, „row2“, „row3“)
    colnames = c(„col1“, „col2“, „col3“, „col4“)
    myMatrix <- matrix(c(1:12), ncol = 4, nrow = 3, byrow = TRUE, dimnames = list(rownames, colnames))

    Ergebnis:
    col1 col2 col3 col4
    row1 1 2 3 4
    row2 5 6 7 8
    row3 9 10 11 12

    1. Die gesamte erste Zeile auslesen

    myMatrix[1,]

    Ergebnis:
    col1 col2 col3 col4
    1 2 3 4

    1. Die gesamte erste Spalte auslesen

    myMatrix[,1]

    Ergebnis:
    row1 row2 row3
    1 5 9

    1. Werte aus der ersten Zeile und der dritten Spalte auslesen.

    myMatrix[1,3]

    1. Matrix Addition (Weitere mathematische Operationen funktionieren auf die gleiche Weise)

    myMatrix1
    [,1] [,2] [,3]
    [1,] 1 2 3
    [2,] 4 5 6

    myMatrix2
    [,1] [,2] [,3]
    [1,] 1 2 3
    [2,] 4 5 6

    myMatrix1 + myMatrix2

    Ergebnis:
    [,1] [,2] [,3]
    [1,] 2 4 6
    [2,] 8 10 12

    Array

    1. Array (n- bzw. mehrdimensinal)

    array(„a“, dim = c(3,4,2) )

    Ergebnis:
    , , 1

    [,1] [,2] [,3] [,4]
    [1,] „a“ „a“ „a“ „a“
    [2,] „a“ „a“ „a“ „a“
    [3,] „a“ „a“ „a“ „a“

    , , 2

    [,1] [,2] [,3] [,4]
    [1,] „a“ „a“ „a“ „a“
    [2,] „a“ „a“ „a“ „a“
    [3,] „a“ „a“ „a“ „a“

    1. Multidimensionaler Vektor

    a <- array(c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), dim=c(3, 4))

    oder

    a <- c(1,2,3,4)
    b <- c(5,6,7,8,9,10,11,12)
    rownames = c(„row1“, „row2“, „row3“)
    colnames = c(„col1“, „col2“, „col3“, „col4“)
    myArray <- array( c(a,b), dim = c(3,4,2), dimnames = list(rownames, colnames) )

    Ergebnis:
    , , 1

    col1 col2 col3 col4
    row1 1 4 7 10
    row2 2 5 8 11
    row3 3 6 9 12

    , , 2

    col1 col2 col3 col4
    row1 1 4 7 10
    row2 2 5 8 11
    row3 3 6 9 12

    1. Ausgabe: Zeile 1, Spalte 3 und Dimension 2

    myArray[1,3,2]

    Ergebnis:
    7

    1. Ausgabe der gesamten zweiten Dimension:

    myArray[,,2]

    1. Array der zweiten Dimension überschreiben

    a <- c(13,14,15,16)
    b <- c(17,18,19,20,21,22,23,24)
    rownames = c(„row1“, „row2“, „row3“)
    colnames = c(„col1“, „col2“, „col3“, „col4“)
    myArray[,,2] <- array( c(a,b), dim = c(3,4), dimnames = list(rownames, colnames) )

    1. Matrix Berechnung vornehmen bzw. eine Funktion anwenden z.B. die Summe der Zeilen aller Dimensionen bilden d.h. die Summe der ersten Zeile der ersten Dimension + die Summe der ersten Zeile der zweiten Dimension usw.

    apply(myArray, c(1), sum) # Zeile = 1; Spalte = 2; Zeile & Spalte = c(1,2)

    Ergebnis:
    row1 row2 row3
    92 100 108

    Data Frame

    1. Data Frame – Die Werte einer Spalte müssen vom gleichen Type und Länge sein

    myDataFrame <- data.frame (
    name = c(„Thomas“, „Johan“, „Linda“),
    alter = c(34, 21, 49),
    geschlecht = c(„M“, „M“, „W“),
    stringsAsFactors = FALSE
    )

    Ergebnis:
    name alter geschlecht
    1 Thomas 34 M
    2 Johan 21 M
    3 Linda 49 W

    1. Die Struktur der data.frame anzeigen lassen

    str(myDataFrame)

    Ergebnis:
    ‚data.frame‘: 3 obs. of 3 variables:
    $ name : Factor w/ 3 levels „Johan“,“Linda“,..: 3 1 2
    $ alter : num 34 21 49
    $ geschlecht: Factor w/ 2 levels „M“,“W“: 1 1 2

    1. Spalten Werte auswerten

    summary(myDataFrame)

    Ergebnis:
    name alter geschlecht
    Length:3 Min. :21.00 Length:3
    Class :character 1st Qu.:27.50 Class :character
    Mode :character Median :34.00 Mode :character
    Mean :34.67
    3rd Qu.:41.50
    Max. :49.00

    1. Spalte auslesen

    data.frame(myDataFrame$name)

    Ergebnis:
    myDataFrame.name
    1 Thomas
    2 Johan
    3 Linda

    1. Die ersten beiden Spalten anzeigen lassen – index fängt bei 0 an

    myDataFrame[0:1,]

    Ergebnis:
    name alter geschlecht
    1 Thomas 34 M

    1. Spalte 1 & 3 auslesen – index fängt bei 1 an

    myDataFrame[c(1,3)]

    Ergebnis:
    name geschlecht
    1 Thomas M
    2 Johan M
    3 Linda W

    1. Neue Spalte hinzufügen

    myDataFrame$SpaltenBezeichnung <- c(„Wert1″,“Wert2″,“Wert3“)

    Ergebnis:
    name alter geschlecht SpaltenBezeichnung
    1 Thomas 34 M Wert1
    2 Johan 21 M Wert2
    3 Linda 49 W Wert3

    1. Neue Zeile hinzufügen

    newDataFrameRows <- data.frame (
    name = c(„Igor“, „Andreas“, „Sascha“),
    alter = c(19, 25, 34),
    geschlecht = c(„M“, „M“, „W“),
    SpaltenBezeichnung = c(„new1″,“new2″,“new3“),
    stringsAsFactors = FALSE
    )

    rbind(myDataFrame,newDataFrameRows)

    Ergebnis:
    name alter geschlecht SpaltenBezeichnung
    1 Thomas 34 M Wert1
    2 Johan 21 M Wert2
    3 Linda 49 W Wert3
    4 Igor 19 M new1
    5 Andreas 25 M new2
    6 Sascha 34 W new3

    Tabelle

    1. GUI aufrufen, um die zuvor erstelle Tabelle zu bearbeiten

    myTable <- edit (myTable)
    oder
    fix (myTable) # Hier wird der veränderte Wert zum ursprünglichen Symbol (myTable) hinzugefügt

    1. Anzahl Zeilen und Spalten einer Tabelle anzeigen

    dim(tableName)

    1. Die Namen der Spalten auflisten

    colnames(tablName)

    1. Tabelle auf gewünschte Spalten reduzieren

    Eingabe:
    train[,c(‚age‘,’name‘)]

    Bedingung (if/else)

    1. if / else

    if (1 > 2) „yes“ else „no“

    1. Ausdrücke mit Semikolon (;)hintereinander schreiben

    „hello“; 1+1; 1*3

    Loop

    i = 5
    repeat {if (i > 25) break else {print(i); i <- i + 5;}}
    oder
    while (i <= 25) {print(i); i <- i + 5}
    oder
    for (i in seq(from=0, to=100, by=5)) print(i)

    oder

    seq(0, 100, by = 5)

    Ergebnis:
    0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100
    Datenbank Verbindungsaufbau und Query Abfrage

    Funktionen

    1. Unterschiedliche Schreibweisen und Funktionsparameter

    log2(64)
    log(x=64,base=2)
    log(64,2)

    1. funktion mit Funktion-Argumenten erstellen

    x(2) # Ergebnis: 4

    1. Eigene Funktion schreiben

    nameDerFunktion <- function(Übergabeparameter) {
    print(Übergabeparameter)
    }

    1. Funktionsaufruf

    nameDerFunktion(Übergabeparameter)

    1. Funktion mit mehreren Parameter

    sayHelloWorld <- function(s,h) {
    cat(s, „“, h)
    }
    sayHelloWorld(s=“Hello“, h=“World“)
    oder
    sayHelloWorld(„Hello“, „World“)

    1. Funktion mit vorgegebenen Werten

    sayHelloWorld <- function(s=“H“,h=“W“) {
    cat(s, „“, h)
    }
    sayHelloWorld() # Für die Ausgabe der vorgegebenen Werten
    sayHelloWorld(„Hello“, „World“) # Um die vorgegebenen Werte zu überschreiben

    Mathematische Funktionen

    1. Anzahl der Nachkommastellen festlegen. Maximal sind 17 Stellige Zahlen z.B. eine Zahl und 16 Nachkommastellen erlaubt. Default = 6 Nachkommastellen bzw. 7 Stellige Zahlen

    options(digits=17)

    1. Runden z.B. Wurzel 99

    round( sqrt(99) )
    oder
    round(x=sqrt(99), digits=2) # Angabe der Nachkommastellen
    oder
    round(sqrt(99), 2)

    1. Durchschnittswert Berechnen

    mean(x) # 2

    1. Median bzw. Zentralwert Berechnung

    median(x) # 3

    1. Minimalwert und Maximalwert

    min(x)
    max x)
    oder
    range(x) # 1 99

    1. Maximaler Wert minus minimaler Wert

    diff( range(x) )

    1. Zufällige Daten erzeugen

    sample(1:1000, 10, replace = FALSE, prob = NULL)

    1. 10x die Zahl 0 erzeugen

    a <- rep(0, 10)

    1. Formatierung der Ausgabe

    format(20.0, nsmall = 10) # die Nachkommastelle um 10 Stellen auffüllen

    Ergebnis:
    „20.0000000000“

    1. Reduzierung der Nachkommastellen

    format(20.123456789, digits = 4)

    Ergebnis:
    20.12

    1. Wissenschaftliche Schreibweise

    format(20.0000000000, scientific = TRUE)

    Ergebnis:
    2e+01 #

    1. Eingab in String formatieren

    format(100)

    Ergebnis:
    „100“

     
  • aaron 23:59 am 18. October 2016 permalink | Antwort  

    Raspberry Pi – Auflösung ändern 

    vi /boot/config.txt

    #overscan deaktivieren
    disable_overscan=1

    #HDMI Typ (CEA=1, DMT=2) angeben
    hdmi_group=1

    #Auflösung angeben
    hdmi_mode=5

    Beschreibung der parameter

     
  • aaron 23:59 am 18. October 2016 permalink | Antwort  

    OpenELEC: kein HDMI Signal 

    OpenELEC:/flash # mount -o remount,rw /flash
    OpenELEC:/flash # vi config.txt

    #hotplug aktivieren
    hdmi_force_hotplug=1

    OpenELEC:/flash # mount -o remount,ro /flash
    OpenELEC:/flash # reboot

     
  • aaron 23:58 am 18. October 2016 permalink | Antwort  

    OpenELEC: ‚Confluence‘ Menüpunkt erstellen 

    In diesem Beispiel soll ein Menüpunkt für die Dokumentationen erstellt werden.

    1) Unter ‚Videos->Datein->Videos hinzufügen…‘ den gewünschten Ordner z.B. Dokumentationen auswählen und hinzufügen.

    2) Den neuen Ordner (Dokumentationen ) zu den Favoriten hinzufügen:

    Favoriten

    4) Favoriten-Pfad via ‚putty‘ ermitteln:

    Favoriten via Putty

    vi ./.xbmc/userdata/favourites.xml

    Die Ausgabe sieht wie folgt aus:

    <favourites>
    <favourite name=“Dokumentationen“>ActivateWindow(10025,&quot;/media/Seagate Expansion Dr/Dokumentationen/&quot;)</favourite>
    </favourites>

    Wir benötigen die folgende Passage: 10025,&quot;/media/Seagate Expansion Dr/Dokumentationen/&quot;

    5) ‚Confluence‘ Skin unter einen neuen Namen (skin.confluence.customized) duplizieren:

    cp -r /usr/share/xbmc/addons/skin.confluence/ /storage/.xbmc/addons/skin.confluence.customized

    6) ‚Confluence‘ Skin (id & name) umbenennen:

    vi /storage/.xbmc/addons/skin.confluence.customized/addon.xml

    <?xml version=“1.0″ encoding=“UTF-8″?>
    <addon
    id=“skin.confluence.customized
    version=“2.1.5″
    name=“Confluence Customized
    ….

    7) Home.xml um den neuen Menüpunkt z.B. Dokus erweitern

    FTP

    /storage/.xbmc/addons/skin.confluence.customized/720p/Home.xml

    Folgende Passagen dort wo sich die restlichen ‚grouplist‘ Einträge befinden hinzufügen:

    <control type=“grouplist“ id=“documentation„>
    <include>HomeSubMenuCommonValues</include>
    <visible>Container(9000).HasFocus(documentationButton)</visible>
    <include>HomeSubMenuVideos</include> <!– Buttons for the grouplist –>
    </control>

    Diese Passage dort hinzufügen, wo sich der Button später befinden soll:

    <item id=“documentationButton„>
    <label>Dokus</label>
    <onclick>ActivateWindow(10025,&quot;/media/Seagate Expansion Dr/Dokumentationen/&quot;)</onclick>
    <icon>-</icon>
    <thumb>-</thumb>
    <visible>True</visible>
    </item>

    8) Raspi rebooten

    9) ‚Confluence Customized‘ Skin auswählen:

    Customized

    10) *tata*

    Button

    Für die Bearbeitung der Unterpunkte muss die Datei ‚IncludesHomeMenuItems.xml‘ angepasst werden.

     
  • aaron 23:58 am 18. October 2016 permalink | Antwort  

    Windows zeitgesteuert ausschalten 

    Ausführungsfenster öffnen und Kommando eingeben

    Win+R
    C:\Users\aaron>shutdown.exe /s /t 3600

    Zeitgesteuertes ’shutdown‘ anhanlten
    C:\Users\aaron>shutdown.exe /a

     
  • aaron 23:58 am 18. October 2016 permalink | Antwort  

    Raspberry Pi – DenyHosts gegen SSH Bruteforcing einsetzen 

    Um sicher zu gehen, dass eigene fehlerhafte Login-Versuche aus der Vergangenheit nicht ausgewertet werden:

    sudo -s
    cat /dev/null > /var/log/auth.log

    DenyHosts installieren
    sudo apt-get install denyhosts

    DenyHosts konfigurieren
    sudo vi /etc/denyhosts.conf

    # Dauer der Sperre
    # ‚m‘ = minutes
    # ‚h‘  = hours

    1. ‚d‘  = days
    2. ‚w‘ = weeks
    3. ‚y‘  = years

    PURGE_DENY = 1h

    1. Login-Name darf 5x falsch eingegeben werden

    DENY_THRESHOLD_INVALID = 5

    1. Login Passwort darf 10x falsch eingegeben werden

    DENY_THRESHOLD_VALID = 10

    1. ‚root‘ Login Passwort des darf 3x falsch eingegeben werden

    DENY_THRESHOLD_ROOT = 3

    DenyHosts restart
    sudo /etc/init.d/denyhosts restart

     
  • aaron 23:57 am 18. October 2016 permalink | Antwort  

    Raspberry Pi – SSH-Authentifizierung mit Schlüsselpaaren 

    Schlüsselpaar Generierung mit PuTTYgen: download

    key generation

    Public- und Private-Schlüssel speichern

    public key

    public key

    Einen versteckten .ssh Ordner auf Raspi unter /home/ anlegen

    ssh folder

    Lokale public-Datei anpassen

    Vorher:

    ssh folder

    Die markierte Passage in einer Zeile schreiben und den Rest entfernen.
    Anschließend vor der Zeile „ssh-rsa“ und nach der Zeile die eigene E-Mail Adresse eintragen.

    Nachher:

    ssh folder

    ssh folder

    Die lokale public-Datei in das angelegte .ssh Verzeichnis kopieren

    ssh folder

    Die Nutzung des Schlüssels aktivieren
    sudo vi /etc/ssh/sshd_config

    Die folgenden drei Zeilen müssen wie folgt angepasst werden:

    RSAAuthentication yes
    PubkeyAuthentication yes
    AuthorizedKeysFile %h/.ssh/public

    SSH-Serve neu starten
    sudo /etc/init.d/ssh restart

    Client Einrichtung
    PuTTY wie folgt konfigurieren:

    ssh folder

    Format: Benutzername@Adresse (IP)

    ssh folder

    Beispiel für WinSCP Anpassung

    ssh folder

    SSH-Login ohne Schlüsselpaare deaktivieren
    Nach der erfolgreichen Anmeldung kann das SSH-Login ohne Schlüssel deaktiviert werden:
    sudo vi /etc/ssh/sshd_config

    Die folgende Zeile von yes auf no umstellen:
    PasswordAuthentication no

    SSH-Serve neu starten
    sudo /etc/init.d/ssh restart

     
  • aaron 23:57 am 18. October 2016 permalink | Antwort  

    rsync Windows GUI 

    Mit Hilfe der Anwendung können zwei Ordner oder Festplatten miteinander synchronisiert bzw. abgeglichen werden.
    Alle Inhalte der ersten Festplatte (Quelle/Source) werden auf die zweite Festplatte (Ziel/Destination) kopiert.
    Vor dem Kopieren wird kontrolliert, ob die Dateien bereits existieren. Existieren die Dateien, so wird kontrolliert, ob die Größe der Dateien miteinander übereinstimmen. Weichen die Größen voneinander ab, so werden die Datei auf der zweiten Festplatte (Ziel/Destination) gelöscht und durch die Dateien auf der ersten Festplatte (Quelle/Source) ersetzt.

    Wie unter ‚rSync Parameter‘ zu sehen ist, kann das Verhalten der Anwendung durch die Änderung der rSync-Parameter (Manpage) verändert werden.

    rSyncGUI

    Download GUI: Link

    Kann im Error-Fall helfen: –ignore-errors

     
c
Neuen Beitrag erstellen
j
nächster Beitrag/nächster Kommentar
k
vorheriger Beitrag/vorheriger Kommentar
r
Antwort
e
Bearbeiten
o
zeige/verstecke Kommentare
t
Zum Anfang gehen
l
zum Login
h
Zeige/Verberge Hilfe
Shift + Esc
Abbrechen