was_sind_booleans.ipynb

{
 "metadata": {
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Was sind Booleans?\n",
    "## Auflösung der letzten Aufgabe\n",
    "### Daten Laden"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "feature = np.array([[4.0, 37.92655435, 23.90101111],\n",
    "                    [4.0, 35.88942857, 22.73639281],\n",
    "                    [4.0, 29.49674574, 21.42168559],\n",
    "                    [4.0, 32.48016326, 21.7340484 ],\n",
    "                    [4.0, 38.00676226, 24.37202837],\n",
    "                    [4.0, 30.73073988, 22.69832608],\n",
    "                    [4.0, 35.93672343, 21.07445241],\n",
    "                    [4.0, 38.65212459, 20.57099727],\n",
    "                    [4.0, 35.52041768, 21.74519457],\n",
    "                    [4.0, 37.69535497, 20.33073640],\n",
    "                    [4.0, 33.00699292, 22.57063861],\n",
    "                    [4.0, 33.73140934, 23.81730782],\n",
    "                    [4.0, 43.85053380, 20.05153803],\n",
    "                    [4.0, 32.95555986, 24.12153986],\n",
    "                    [4.0, 36.38192916, 19.20280266],\n",
    "                    [4.0, 36.54270168, 20.45388966],\n",
    "                    [4.0, 33.08246118, 22.20524015],\n",
    "                    [4.0, 31.76866280, 21.01201139],\n",
    "                    [4.0, 42.24260825, 20.44394610],\n",
    "                    [4.0, 29.04450264, 22.46633771],\n",
    "                    [4.0, 30.04284328, 21.54561621],\n",
    "                    [4.0, 18.95626707, 19.66737753],\n",
    "                    [4.0, 18.60176718, 17.74023009],\n",
    "                    [4.0, 12.85314993, 18.42746953],\n",
    "                    [4.0, 28.62450072, 17.94781944],\n",
    "                    [4.0, 21.00655655, 19.33438286],\n",
    "                    [4.0, 17.33580556, 18.81696459],\n",
    "                    [4.0, 31.17129195, 17.23625014],\n",
    "                    [4.0, 19.36176482, 20.67772798],\n",
    "                    [4.0, 27.26581705, 16.71312863],\n",
    "                    [4.0, 21.19107828, 19.00673617],\n",
    "                    [4.0, 19.08131597, 15.24401994],\n",
    "                    [4.0, 26.69761925, 17.05937466],\n",
    "                    [2.0, 4.44136559 , 3.52432493 ],\n",
    "                    [2.0, 10.26395607, 1.07729281 ],\n",
    "                    [2.0, 7.39058439 , 3.44234423 ],\n",
    "                    [2.0, 4.23565118 , 4.28840232 ],\n",
    "                    [2.0, 3.87875761 , 5.12407692 ],\n",
    "                    [2.0, 15.12959925, 6.26045879 ],\n",
    "                    [0.0, 5.93041263 , 1.70841905 ],\n",
    "                    [0.0, 4.25054779 , 5.01371294 ],\n",
    "                    [0.0, 2.15139117 , 4.16668657 ],\n",
    "                    [0.0, 2.38283228 , 3.83347914 ]])\n",
    "\n",
    "label = np.concatenate((np.ones(21), np.zeros(22)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = feature[0, 1:]\n",
    "x = np.insert(x, 2, 1)\n",
    "\n",
    "w = np.random.rand(3)"
   ]
  },
  {
   "source": [
    "### Perzeptron Funktion"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ausgeschrieben\n",
    "y = w[0] * x[0] + w[1] * x[1] + w[2] * x[2]\n",
    "\n",
    "# Skalarprodukt\n",
    "y = np.dot(w, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "23.97986995889001\n"
     ]
    }
   ],
   "source": [
    "def perzeptron(w, x):\n",
    "    y = np.dot(w, x)\n",
    "    return y\n",
    "\n",
    "y = perzeptron(w, x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "15.444706851481362\n"
     ]
    }
   ],
   "source": [
    "x_new = feature[30, 1:]\n",
    "x_new = np.insert(x_new, 2, 1)\n",
    "y = perzeptron(w, x_new)\n",
    "print(y)"
   ]
  },
  {
   "source": [
    "## Booleans"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "hund = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "hund = False"
   ]
  },
  {
   "source": [
    "### Vergleichsoperatoren"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "hund = y > 0\n",
    "print(hund)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "hund = y == 0\n",
    "hund = y != 0\n",
    "\n",
    "hund = y > 0\n",
    "hund = y < 0\n",
    "hund = y >= 0\n",
    "hund = y <= 0"
   ]
  },
  {
   "source": [
    "### Boolesche Operatoren"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "hund = y >= 0 and y != 0\n",
    "hund = y >= 0 or y != 0\n",
    "hund = not y == 0"
   ]
  },
  {
   "source": [
    "### Andere Wichtige Operatoren"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Identität\n",
    "var = (5 is 6) or (5 is not 6)\n",
    "var = (5 == 6) or (5 != 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "False\nFalse\n"
     ]
    }
   ],
   "source": [
    "print(5 is 6) # die Ausgaben sind hier gleich\n",
    "print(5 == 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "True\nTrue\n"
     ]
    }
   ],
   "source": [
    "print(5 is not 6)\n",
    "print(5 != 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(0 in feature)"
   ]
  },
  {
   "source": [
    "## Perzeptron Funktion\n",
    "Wir ändern die Perzeptron Funktion, sodass wir den ganzen oberen Teil zeigen"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "def perzeptron(w, x):\n",
    "    return np.dot(w, x) > 0\n",
    "\n",
    "y = perzeptron(w, x)\n",
    "print(y)"
   ]
  }
 ]
}