diff --git a/README.md b/README.md index 168805a..9f335e7 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,26 @@ -# Examples +# Notebook Examples -Various example scripts for the [Sandbox](https://sandbox.iuk.hdm-stuttgart.de/). \ No newline at end of file +This Repository contains multiple Example Notebooks which demonstrates the [Sandbox](https://sandbox.iuk.hdm-stuttgart.de/) platform capabilities. + +## Usecase +The [usecase.ipynb](usecase.ipynb) showcases multiple stylistic tools to create textual, visual, scientific, and interactive use cases. + +## Upload Share +The [share_file.ipynb](share_file.ipynb) present how to interact with the datapool by three different ways. + +## Slideshows +The [rise_slideshow.ipynb](rise_slideshow.ipynb) shows an example for using the rise plugin to create a slideshow out of a notebook. + +## Webcam Eye Detection +The [webcam_eye_detection.ipynb](webcam_eye_detection.ipynb) demonstrates how the Sandbox WebUI (browser) can interact with the server backend by sending Webcam live video streams using WebRTC. This can be used for live processing like face recognition and other tasks. + +## ML model Evaluation +The [tf-cifar10.ipynb](tf-cifar10.ipynb) shows how a model can be quickly evaluated and trained, as a preparation for long running ML training tasks. + +## Text to Image +The [text_to_image.ipynb](text_to_image.ipynb) shows a interactive notebook which generates pictures from the user input by the stable diffusion model. + +## Audio to Text +The [whisper_audio_to_text.ipynb](whisper_audio_to_text.ipynb) demonstrates OpenAIs whisper model which can be used to convert audio to text transcription. + +*additional information can be found at [https://docs.sandbox.iuk.hdm-stuttgart.de](https://docs.sandbox.iuk.hdm-stuttgart.de)* diff --git a/rise_slideshow.ipynb b/rise_slideshow.ipynb new file mode 100644 index 0000000..d8bfbb1 --- /dev/null +++ b/rise_slideshow.ipynb @@ -0,0 +1,543 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*this notebook works in any Sandbox environments* " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Turn your notebooks into slideshows" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "" + } + }, + "source": [ + "Press `Space` to proceed." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "You can write a regular Jupyter notebook, with the usual mix of markdown and code cells (keep on pressing `Space`)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "cell_style": "center", + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "In code cells you press `Shift-Enter` as usual to evaluate your code (but for now press `Space` again)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "cell_style": "center", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Hello world'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# this is where you press Shift-Enter\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "plt.ion()\n", + "\n", + "\"Hello world\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But apart from that, `Space` is your friend!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "You're in a browser, so remember that you can always use smaller / larger fonts with keyboard shortcuts like `Alt +` and `Alt -` or similar (it could be `Ctrl` instead of `Alt` depending on the platform you are on).\n", + "\n", + "
ideally, the following 2 cells are shown side-by-side, at least that was the case with the old-school classic notebook
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cell_style": "split", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# of course you can show figures\n", + "\n", + "def polynom(x):\n", + " return 2 * x**2 - 20 * x + 2\n", + "\n", + "X = np.linspace(-10, 10)\n", + "Y = polynom(X)\n", + "plt.plot(X, Y);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cell_style": "split", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# and everything works as usual\n", + "\n", + "# an animation to illustrate \n", + "# translation by variable change\n", + "from ipywidgets import interact, FloatSlider\n", + "\n", + "def parabolic(offset):\n", + " X = np.linspace(-10, 10)\n", + " Y = polynom(X-offset)\n", + " # use same y scale for all offsets\n", + " plt.gca().set_ylim([-100, 500])\n", + " plt.plot(X, Y);\n", + " \n", + "interact(parabolic, \n", + " offset=FloatSlider(min=-10., max=10.,\n", + " step=0.25));" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# The RISE notebook extension" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All this is achieved through the RISE notebook extension.\n", + "\n", + "See full documentation at http://rise.readthedocs.io/." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Thanks to reveal.js" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The underlying tool is [reveal.js](https://revealjs.com/), and it supports a lot of cool features." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For example you can organize your show into:\n", + "\n", + "* slides (left to right)\n", + "* subslides (top to bottom)\n", + "* fragments (stops inside a slide)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You do not need to worry, just press `Space` to proceed along the main line." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "For example this is a subslide; observe the cursor in the bottom right corner." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you press `Shift-Space` - here or anywhere else - you will go backwards, so here it would be up." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Speaker notes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you now press `t` you should see a second window open, with a presenter view, that shows *Notes* cells - that won't show up in the main slides." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "source": [ + "This is an example of a *Notes* cell." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "" + } + }, + "source": [ + "Next, we'll cover how to tag cells as *Slide*, *SubSlide*, *Fragment* or *Notes*." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# How to create slideshows" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1: enable slideshow cell toolbar" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](slide-toolbar.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "cell_style": "center", + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Step 2: add appropriate tag to each cell" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "cell_style": "split" + }, + "source": [ + "From the cell toolbar...\n", + "\n", + "![](toolbar-options.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "cell_style": "split", + "slideshow": { + "slide_type": "-" + } + }, + "source": [ + "or, in command mode, use keyboard shortcuts\n", + "\n", + "* `shift-i` : toggle slide\n", + "* `shift-b` : toggle subslide\n", + "* `shift-g` : toggle fragment" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# CSS" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "notes" + } + }, + "source": [ + "2 files are loaded without the need for configuring\n", + "\n", + "* `rise.css` in the current directory\n", + "* `README.css` for this notebook because it is called `README.ipynb`\n", + "\n", + "If that works then the cell below has a large border width and a big south-east border-radius" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [], + "source": [ + "# sample code cell\n", + "message = \"my look is changed by both rise.css and README.css\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Publishing on binder" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order for a binder-hosted notebook to start in slideshow mode, you need to have the following tag set in the notebook metadata:\n", + "\n", + "```javascript \n", + " ...\n", + " \"rise\": {\n", + " \"autolaunch\": true\n", + " }\n", + " ...\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "You can edit the notebook metadata from the `edit` menu, submenu `edit notebook metadata`.\n", + "\n", + "Note finally that the `rise` key in this json file used to be named `livereveal`. The latter is still honored, but the former takes precedence, and it is recommended to use only `rise` from now on." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Chalkboard" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As an option, you can turn on the *chalkboard* reveal plugin, that manifests itself with 2 extra buttons in the lower left area, that let you add free drawings on your slides." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This option is turned on, in the notebook metadata again, with:\n", + "\n", + "```javascript\n", + " ...\n", + " \"rise\": {\n", + " \"enable_chalkboard\": true\n", + " }\n", + " ...\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# tables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mostly for checking the rendering of tables, here's a few samples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# first using pandas\n", + "\n", + "import seaborn as sns\n", + "titanic = sns.load_dataset('titanic')\n", + "columns = \"survived\tpclass\tsex\tage\tembarked\tclass\twho\tadult_male\".split()\n", + "titanic[columns].head(8)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "and the same but inlined as markdown\n", + "\n", + "| | survived | pclass | sex | age | embarked | class | who | adult_male |\n", + "|---:|-----------:|---------:|:-------|------:|:-----------|:--------|:------|:-------------|\n", + "| 0 | 0 | 3 | male | 22 | S | Third | man | True |\n", + "| 1 | 1 | 1 | female | 38 | C | First | woman | False |\n", + "| 2 | 1 | 3 | female | 26 | S | Third | woman | False |\n", + "| 3 | 1 | 1 | female | 35 | S | First | woman | False |\n", + "| 4 | 0 | 3 | male | 35 | S | Third | man | True |\n", + "| 5 | 0 | 3 | male | nan | Q | Third | man | True |\n", + "| 6 | 0 | 1 | male | 54 | S | First | man | True |\n", + "| 7 | 0 | 3 | male | 2 | S | Third | child | False |\n" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "jupytext": { + "formats": "ipynb" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.11.7" + }, + "rise": { + "autolaunch": true, + "enable_chalkboard": true + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/cli_share_upload_file.ipynb b/share_file.ipynb similarity index 74% rename from cli_share_upload_file.ipynb rename to share_file.ipynb index 54e2799..ee3d6b2 100644 --- a/cli_share_upload_file.ipynb +++ b/share_file.ipynb @@ -4,9 +4,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Example CLI Share (Headless) File Upload\n", + "*this notebook works in any Sandbox environments* " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sharing files on the Sandbox Platform\n", + "### Using Share UI\n", + "\n", + "for non technical users an interactive webservice is provided. [ShareUI](https://share.sandbox.iuk.hdm-stuttgart.de/admin). \n", + "\n", + "![ShareUI](https://gist.github.com/assets/634470/f90a0c03-8834-4685-95ca-a73e98cabc2f)\n", + "\n", + "### Example CLI Share (Headless) File Upload\n", "The following example provides a code snippet for sharing a file via cli share. The CLI Endpoint is only avaiable from the Sandbox.\n", - "### using python" + "#### Using Python" ] }, { @@ -42,7 +56,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### using curl\n" + "#### Using Curl\n" ] }, { @@ -56,7 +70,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Response\n", + "#### Response\n", "\n", "The respone of both requests includes the public available download link and the expiration date.\n", "\n", diff --git a/text_to_image.ipynb b/text_to_image.ipynb index a784aab..8502acd 100644 --- a/text_to_image.ipynb +++ b/text_to_image.ipynb @@ -1,5 +1,21 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "e355f137", + "metadata": {}, + "source": [ + "*this notebook requires a working PyTorch GPU environment* " + ] + }, + { + "cell_type": "markdown", + "id": "e04b5280", + "metadata": {}, + "source": [ + "# Stable Diffusion Text to Image model" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/tf-cifar10.ipynb b/tf-cifar10.ipynb new file mode 100644 index 0000000..6246b5b --- /dev/null +++ b/tf-cifar10.ipynb @@ -0,0 +1,405 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8413e039", + "metadata": {}, + "source": [ + "*this notebook requires a working Tensorflow GPU environment* " + ] + }, + { + "cell_type": "markdown", + "id": "1434db93-27e6-4ed4-bcb5-1fabbdf155d5", + "metadata": {}, + "source": [ + "# Tensorflow model for Image recognition\n", + "Inside the following Use Case their is a CNN trained on the CIFAR-10 Dataset to classify different images. \n", + "\n", + "*For long running trainings this Notebook can be converted to plain python (using nbconvert). An example repository can be found [here](https://git.sandbox.iuk.hdm-stuttgart.de/grosse/test-ci).*" + ] + }, + { + "cell_type": "markdown", + "id": "b5ec6c62-d6a7-4b13-b802-c7de5a3716a4", + "metadata": {}, + "source": [ + "## Import Libaries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e1b70492-eba5-421b-8b51-d56632657efc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-05-27 08:17:22.992136: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-05-27 08:17:22.992198: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-05-27 08:17:22.993032: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-05-27 08:17:22.998566: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import requests\n", + "import numpy as np\n", + "import os\n", + "# Version Information\n", + "# tensorflow 2.2.0 , Cudnn7.6.5 and Cuda 10.1 , python 3.8\n", + "from keras import backend as K\n", + "K.clear_session()\n", + "import matplotlib.pyplot as plt " + ] + }, + { + "cell_type": "markdown", + "id": "085824f7-0423-4ede-8203-76b0d673bb04", + "metadata": {}, + "source": [ + "## Select available Hardware for model execution" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2067ff7e-f5fc-4ad2-a95d-29d82e3f7059", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-05-27 08:17:25.521816: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-05-27 08:17:25.554614: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-05-27 08:17:25.556557: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n" + ] + } + ], + "source": [ + "gpus = tf.config.experimental.list_physical_devices('GPU')\n", + "if gpus:\n", + " try:\n", + " tf.config.experimental.set_virtual_device_configuration(gpus[0], [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=6024)])\n", + " except RuntimeError as e:\n", + " print(e)\n", + " os.exit(1)\n" + ] + }, + { + "cell_type": "markdown", + "id": "fbff826d-33ac-42f7-8a18-f3df0ec01b5f", + "metadata": {}, + "source": [ + "## Show some dataset details " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d9d12acc-d312-4b32-87dc-131148012c4d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[PhysicalDevice(name='/physical_device:CPU:0', device_type='CPU'), PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n", + "2.15.0\n", + "True\n", + "(50000, 32, 32, 3) (50000, 1)\n", + "deer\n" + ] + } + ], + "source": [ + "print(tf.config.experimental.list_physical_devices())\n", + "\n", + "print(tf.__version__)\n", + "\n", + "print(tf.test.is_built_with_cuda())\n", + "\n", + "(X_train, y_train), (X_test,y_test) = tf.keras.datasets.cifar10.load_data()\n", + "\n", + "(X_train, y_train), (X_test,y_test) = tf.keras.datasets.cifar10.load_data()\n", + "\n", + "print(X_train.shape,y_train.shape)\n", + "\n", + "classes = [\"airplane\",\"automobile\",\"bird\",\"cat\",\"deer\",\"dog\",\"frog\",\"horse\",\"ship\",\"truck\"]\n", + "\n", + "print(classes[y_train[3][0]])\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "59ac7149-9708-463a-a214-8e01ee71b04d", + "metadata": {}, + "source": [ + "## image scaling " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fb66a6f8-b4f9-4e85-9251-87c6ae403632", + "metadata": {}, + "outputs": [], + "source": [ + "X_train_scaled = X_train / 255\n", + "X_test_scaled = X_test / 255\n", + "\n", + "y_train_categorical = keras.utils.to_categorical(\n", + " y_train, num_classes=10, dtype='float32'\n", + ")\n", + "y_test_categorical = keras.utils.to_categorical(\n", + " y_test, num_classes=10, dtype='float32'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "28bb8a0e-52af-4cf4-999e-008e464398aa", + "metadata": {}, + "source": [ + "## show dataset with categories" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e14ec124-9d54-43a3-9ea1-4b63383590dd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,10))\n", + "for i in range(25):\n", + " plt.subplot(5,5,i+1)\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.grid(False)\n", + " plt.imshow(X_train_scaled[i])\n", + " # The CIFAR labels happen to be arrays, \n", + " # which is why you need the extra index\n", + " plt.xlabel(classes[y_train[i][0]])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7a2c7eff-b9a7-4ded-ac0a-2d117f5cf532", + "metadata": {}, + "source": [ + "## configure model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "196ab4a0-45a5-479a-8b0c-86b8e6f2daa0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-05-27 08:17:26.939176: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-05-27 08:17:26.942340: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-05-27 08:17:26.944200: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-05-27 08:17:27.074726: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-05-27 08:17:27.076028: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-05-27 08:17:27.077228: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-05-27 08:17:27.078400: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 6024 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe MIG 3g.40gb, pci bus id: 0000:05:00.0, compute capability: 8.0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-05-27 08:17:29.263602: I external/local_xla/xla/service/service.cc:168] XLA service 0x7fcd9f189fa0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", + "2024-05-27 08:17:29.263822: I external/local_xla/xla/service/service.cc:176] StreamExecutor device (0): NVIDIA A100 80GB PCIe MIG 3g.40gb, Compute Capability 8.0\n", + "2024-05-27 08:17:29.278180: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1716797849.319990 330 device_compiler.h:186] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1563/1563 [==============================] - 7s 4ms/step - loss: 1.8087 - accuracy: 0.3562\n", + "Epoch 2/5\n", + "1563/1563 [==============================] - 7s 4ms/step - loss: 1.6230 - accuracy: 0.4242\n", + "Epoch 3/5\n", + "1563/1563 [==============================] - 7s 4ms/step - loss: 1.5412 - accuracy: 0.4558\n", + "Epoch 4/5\n", + "1563/1563 [==============================] - 6s 4ms/step - loss: 1.4829 - accuracy: 0.4778\n", + "Epoch 5/5\n", + "1563/1563 [==============================] - 7s 4ms/step - loss: 1.4331 - accuracy: 0.4957\n", + "finished training\n" + ] + } + ], + "source": [ + "\n", + "def get_model():\n", + " model = keras.Sequential([\n", + " keras.layers.Flatten(input_shape=(32,32,3)),\n", + " keras.layers.Dense(3000, activation='relu'),\n", + " keras.layers.Dense(1000, activation='relu'),\n", + " keras.layers.Dense(10, activation='sigmoid') \n", + " ])\n", + "\n", + " model.compile(optimizer='SGD',\n", + " loss='categorical_crossentropy',\n", + " metrics=['accuracy'])\n", + " return model\n", + "history = None\n", + "with tf.device('/GPU:0'):\n", + " model = keras.Sequential([\n", + " keras.layers.Flatten(input_shape=(32,32,3)),\n", + " keras.layers.Dense(3000, activation='relu'),\n", + " keras.layers.Dense(1000, activation='relu'),\n", + " keras.layers.Dense(10, activation='sigmoid') \n", + " ])\n", + " model.compile(optimizer='SGD',\n", + " loss='categorical_crossentropy',\n", + " metrics=['accuracy'])\n", + " history = model.fit(X_train_scaled, y_train_categorical, epochs=5)\n", + " model.save('mymodel.keras')\n", + " \n", + " print(\"finished training\")" + ] + }, + { + "cell_type": "markdown", + "id": "98c4e3c1-39ab-48fc-97c6-97bd0349b396", + "metadata": {}, + "source": [ + "## show result" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "970f7cd9-8b78-423b-8067-aaf666c31cd9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2,1)\n", + "\n", + "xticks = np.arange(1, 6, step=1)\n", + "xlabels = [f'{x:1d}' for x in xticks]\n", + "ax[0].set_xticks(xticks, labels=xlabels)\n", + "ax[1].set_xticks(xticks, labels=xlabels)\n", + "\n", + "\n", + "ax[0].plot(history.history['loss'], color='b', label=\"Training Loss\")\n", + "legend = ax[0].legend(loc='best', shadow=True)\n", + "\n", + "ax[1].plot(history.history['accuracy'], color='b', label=\"Training Accuracy\")\n", + "legend = ax[1].legend(loc='best', shadow=True)\n" + ] + }, + { + "cell_type": "markdown", + "id": "ade9b5f7-9048-4b1d-876c-32bb16cfa7f7", + "metadata": {}, + "source": [ + "## upload model to datapool" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ae09ac93-5f47-4008-86d6-b9a503b0b20a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "uploading file\n", + " {\"PublicUrl\":\"https://share.storage.sandbox.iuk.hdm-stuttgart.de/upload/a0a1ca44-0413-4ad2-9031-78aac6336072/mymodel.keras\",\"Size\":97865925,\"Expiration\":\"2024-09-25T00:00:00Z\"}\n" + ] + } + ], + "source": [ + "myurl = 'https://share.storage.sandbox.iuk.hdm-stuttgart.de/upload'\n", + "print(\"uploading file\")\n", + "files = {\n", + " 'fileUpload':('mymodel.keras', open('mymodel.keras', 'rb'),'application/octet-stream')\n", + "}\n", + "\n", + "response = requests.post(myurl, files=files)\n", + "print(response,response.text)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6db2bcf5-5c39-4796-b77e-1c16e3f42ac4", + "metadata": {}, + "outputs": [], + "source": [ + "K.clear_session()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/usecase.ipynb b/usecase.ipynb new file mode 100644 index 0000000..8c54460 --- /dev/null +++ b/usecase.ipynb @@ -0,0 +1,264 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*this notebook works in any Sandbox environments* " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Markdown\n", + "The following table shows the general description of the Markdwon syntax to format text." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "| Markdown Syntax | Description |\n", + "| :------------------------------------------------ | :----------------------------------------------------------|\n", + "| ** text ** | format text as **bold** |\n", + "| * text * | format text as *italic* |\n", + "| *** text *** | format text as ***bold &italic*** |\n", + "| # Heading 1 | format text as Heading Level 1 |\n", + "| ## Heading 2 | format text as Heading Level 2 |\n", + "| ### Heading 3 | format text as Heading Level 3 |\n", + "| 1. Listitem
2. Listitem
3. Listitem | format list as Ordered List |\n", + "| * Listitem 1
* Listitem 2
* Listitem 3 | format list as Unordered List (instead of * it can be +, - used) |\n", + "| > blockqute | Blockquote |\n", + "| [ linkdescription ] ( http://URL ) | format text as link |\n", + "| ![ imagecaption ] ( /path/to/image ) | add image to text |\n", + "| --- | Horizontal Rule |\n", + "| ```python 3x(`) | can be used to show embed python syntax with highlighting |\n", + "| `code` (1x`) | can be used to show a small chunk of code |\n", + "|- [x] Write the press release | Tasklist |\n", + "| sup html tag >sup< | use sup tag to superscript characters |\n", + "| sub html tag >sub< | use sub tag to subscript characters |\n", + "\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## example for markdown\n", + "the following text is just a placeholder to viszualize the text format. Inside the ***example*** all *markdown syntax* is used which is shown in the **table** above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Header first Level\n", + "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,\n", + "\n", + "## Header second level\n", + "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem **ipsum** dolor sit amet.\n", + "1. voluptua\n", + "2. magna\n", + "3. consetetur\n", + "\n", + "\n", + "\n", + "\n", + "### Header third level\n", + "Lorem *ipsum* dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,\n", + "* Lorem\n", + "* dolor\n", + "* ***gubergren***\n", + "\n", + "Lorem *ipsum* dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem **ipsum** dolor \n", + "\n", + "```python\n", + "def foo(): \n", + " print(\"bar\")\n", + "\n", + "foo()\n", + "```\n", + "\n", + "Lorem *ipsum* dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "![md](https://upload.wikimedia.org/wikipedia/commons/thumb/4/48/Markdown-mark.svg/208px-Markdown-mark.svg.png)\n", + "\n", + "if you want to know more about markdown syntax just use the [documentation](https://www.markdownguide.org)\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# *voilà*\n", + "\n", + "In the following examples **controls** are provided with *voila* to show or manipulate diagrams and create interactive notebooks.\n", + "\n", + "1. ***small number multiplicator*** for integers between 0 and 100" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "04713a82a921423aa71381040a9d56a8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(VBox(children=(IntSlider(value=0), IntSlider(value=0))), Output()))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from ipywidgets import HBox, VBox, IntSlider, interactive_output\n", + "from IPython.display import display\n", + "\n", + "a = IntSlider()\n", + "b = IntSlider()\n", + "\n", + "def f(a, b):\n", + " print(\"{} * {} = {}\".format(a, b, a * b))\n", + "\n", + "out = interactive_output(f, { \"a\": a, \"b\": b })\n", + "\n", + "display(HBox([VBox([a, b]), out]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Display **latex formulas** inside a notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import display\n", + "from IPython.display import (\n", + " Latex, Math\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$F=ma$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "math = Latex(\"$F=ma$\")\n", + "math" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "\n", + "\\begin{align}\n", + "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\ \\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n", + "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n", + "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0\n", + "\\end{align}\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "maxwells = Latex(r\"\"\"\n", + "\\begin{align}\n", + "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\ \\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n", + "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n", + "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0\n", + "\\end{align}\n", + "\"\"\")\n", + "maxwells" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$a = b + c$$ (line break after the equation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$a = b + c$$ \n", + "\n", + "## (line break after the equation)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/webcam_eye_detection.ipynb b/webcam_eye_detection.ipynb index 30eca0b..49d9ed1 100644 --- a/webcam_eye_detection.ipynb +++ b/webcam_eye_detection.ipynb @@ -1,5 +1,12 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*this notebook works in any Sandbox environments* " + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/whisper_audio_to_text.ipynb b/whisper_audio_to_text.ipynb index 42224ae..722de12 100644 --- a/whisper_audio_to_text.ipynb +++ b/whisper_audio_to_text.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "...original notebook from https://github.com/fastforwardlabs/whisper-openai/blob/master/WhisperDemo.ipynb" + "*this notebook requires a working PyTorch GPU environment* " ] }, { @@ -14,6 +14,9 @@ }, "source": [ "# OpenAI's Whisper\n", + "\n", + "...original notebook from https://github.com/fastforwardlabs/whisper-openai/blob/master/WhisperDemo.ipynb\n", + "\n", "Speech to text...\n", "\n", "more information at\n", diff --git a/whisper_test_multimodel.ipynb b/whisper_test_multimodel.ipynb index de9ead0..f72bb84 100644 --- a/whisper_test_multimodel.ipynb +++ b/whisper_test_multimodel.ipynb @@ -1,5 +1,29 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "b56703b7", + "metadata": {}, + "source": [ + "*this notebook requires a working PyTorch GPU environment* " + ] + }, + { + "cell_type": "markdown", + "id": "3967f4b4", + "metadata": {}, + "source": [ + "# OpenAI's Whisper multimodel\n", + "\n", + "Speech to text...\n", + "\n", + "more information at\n", + "- https://openai.com/blog/whisper\n", + "- https://github.com/openai/whisper\n", + "\n", + "\n" + ] + }, { "cell_type": "code", "execution_count": null,