+"Read Text" From Image Python 3 -tesseract

Keras is a loftier level neural network API, supporting popular deep learning libraries like Tensorflow, Microsoft Cognitive Toolkit, and Theano.

The RapidMiner Keras extension provides a set of operators that let an like shooting fish in a barrel visual configuration of Deep Learning network structures and layers. Calculations are pushed into the Python-based backend libraries, and so you lot tin can leverage the computing ability of GPUs and filigree environments.

The extension makes apply of an existing Keras installation. This article shows how to do a unproblematic deployment of Keras and how to configure the Keras extension to connect to it.

Warning: Equally of version 1.two, TensorFlow no longer provides GPU back up on macOS.

Alarm: Due to problems with package dependencies, it is not currently possible to install graphviz and pydot in a conda environment on Windows, and consequently to visualise the model graph in the results panel.

Only python 3.v.ii works for windows.

Try out a few sample processes from the "Keras Sample" in the repository view.

Keras Model seems to exist running on a CPU or on one GPU only, there is no way of controlling which GPU is to be used and to switch to another at any indicate in processing.

In that location is indeed no fashion to choose a GPU every bit of yet but in our test all the available gpu's were being used. are yous sure you could only apply 1?

There is no mode to utilise models saved as HDF5 checkpoints, I could not even read the HDF5 checkpoint files back into RM anyway.

The Python Scripting Extension, which the Keras extension relies on, currently doesn't support serialising to HDF5, then this volition take to wait.

Likewise not sure if Keras Model could accept annihilation merely a data frame, if so information technology is curious why the model requires the input shape (the shape for a data frame is always standard).

Indeed, the superoperator can simply handle ExampleSets. however, unlike input layers require unlike input shapes. if yous starting time with a dense layer, then the input shape could exist hands deduced. on the other paw convolutional or recurrent layers crave specifying an input shape unlike than the elementary number of features. for example, when using a conv1d layer, the input_shape needs to be (batch_size, timesteps, input_dim) and the pre-processing is done automatically past rapidminer. this is shown in the sample processes

Is it possible to call your own Python lawmaking in callbacks or optimizers.

I am not sure how to laissez passer multi-characterization examples.

1. Become to Anaconda prompt

2. Activate the last created environment by typing in the command line: activate Python35

3. Install pip past typing in the command line: conda install pip

4. Install graphviz by typing in the control line: pip install graphviz

five. Install pydot by typing in the control line: pip install pydot

6. Inside your Studio Customer go to Settings (Menu) >Preferences and navigate to "Keras" tab/folio on the left. Provide path to Python executable (the path to your new conda environment Python executable) and click examination to ensure it is successful.

More Installation Troubleshooting – courtesy @jacobcybulski

In my case installing Keras for RapidMiner on Win10 was a chip more tricky, and the main consequence are pydot and graphviz. When yous install them both from Anaconda, RapidMiner will encounter them just the necessary software is nevertheless non on the arrangement and will later neglect. Here is my advice, assuming you have the current version of Anaconda, Tensorflow and Keras.

Make certain you install Keras in the previously divers Tensorflow environment, in almost cases this was Python 3.v withal recently I have tried Python iii.6 with success. And then activate the environment.

• From the command line execute: activate tensorflow

Then install a number of packages, I.e. (the terminal two for visualisation only)

• cuDNN (if using GPU, see above)
• conda install HDF5
• conda install h5py (the previous may exist downgraded at this bespeak in fourth dimension)
• conda install graphviz (y'all may be lucky)
• pip install pydot (you may be lucky)

At present yous should be able to finish installing Keras.

• pip install keras

You lot tin at present attempt running RapidMiner, install Keras plugin and configure information technology by pointing to the python within "tensorflow" environent. Nearly likely RapidMiner will exist happy with the installation but may not exist able to brandish the graphs or it volition fail with an fault subsequently on.

If you were not lucky then graphviz and / or pydot need to be properly installed, effort these:

• Download "graphviz-2.38.msi" from
  http://www.graphviz.org/Download_windows.php
• Execute the "graphviz-2.38.msi" file
• Add together the graphviz bin folder to the PATH system environment variable
  (Example: "C:\Graphviz2.38\bin")
• You lot may need i more footstep, I.e. install a python-graphviz packet:
  conda install python-graphviz

You should be able to come across the graphs produced past Keras inside RapidMiner.

However, I have plant on a few systems this was not enough and I had to do the post-obit (I have no idea why merely I have found this remedy).

• Get to Anaconda Prompt using commencement carte (Make certain to right click and select "Run equally Ambassador". We may get permission issues if Prompt equally not opened as Administrator)
• Execute the command: conda install graphviz
• Execute the command: pip install git+https://github.com/nlhepler/pydot.git (You will need GIT for this)

In all cases, you may wish to check if things worked out.

• Execute the command "conda list" and make sure pydot and graphviz modules are listed.

More Installation Troubleshooting – courtesy @M_Martin

Equally far as setting up Keras in RapidMiner (and other related Python packages Keras needs), here'south what seems to exist working for me on several Dev boxes in my shop (caveat: all boxes are running Windows vii 64 bit, with SP1 - all machines have either xvi or 32 GB of RAM and I7 processors).

one. Install the Keras extension from the Rapid Miner Extensions Market place into RapidMiner Studio

2. Download and install Anaconda three (https://world wide web.anaconda.com/)  Get the appropriate version (64 or 32 chip).

iii. Run the Anaconda Navigator (should now exist in your Windows Plan Group)

4. Create a new environs using the Anaconda Navigator.  The Navigator (as of this writing) will suggest using Python 3.half dozen, but there is also an selection for Python 3.five,  Tick on Python 3.5 as I understand that the RapidMiner Keras extension was developed using Python three.5.  I named my Surroundings py35.

v.  After Anaconda creates the environment, open up upwards the Anaconda Prompt (should exist listed equally a shortcut from the Commencement Carte du jour, or within the Anaconda program group.  Though I didn't have to, you could left click on the icon for the Anaconda prompt and select "Run as Administrator"

6. Yous need to actuate the new surround you just created.  From the prompt type: activate <environment name>.  If you named your environment py35, you would type: activate py35.   Then striking Enter/Return.  Subsequently a few seconds, the Anaconda prompt will return, and the environment will be active.  The new surroundings proper name should now exist part of the Anaconda prompt.

7. To see a listing of existing Python packages in your new environment, type conda listing and so Enter/Render.  You lot should see a short list of packages.

viii. You lot now need to install a few more Python packages.  Type conda install pandas and then Enter.  Later a few seconds, you will be asked to confirm that y'all want to do the installation.  Type y and the downloading and installation of pandas (and other dependent packages) will begin. When the installation has finished, you lot'll exist returned to the Anaconda prompt for your environment.

9.  Type conda install scikit-learn and so Enter. Confirm that you want to do the install, and so it should first.  When the install is washed, yous'll be returned to the prompt for your Anaconda surroundings.

10.  Yous now need to install a package named Graphviz which requires some actress steps.  Go to http://world wide web.graphviz.org/ and download_windows.php and download graphviz-238.msi.  Then run the msi file you lot accept downloaded to install graphviz (which is a Windows Forms awarding).

xi. So open up the Windows Control Panel, select the System App, and and so Avant-garde Organisation Settings  --> Environment Variables.  Add the path to the Graphviz executable to (at the least) the PATH environs variable for your user account.  The value to append to your existing PATH is C:\Program Files (x86)\Graphviz2.38\bin   Type in a semicolon in forepart of C:\Programme Files (x86)\Graphviz2.38\bin in social club to seperate it from the previous entry in your PATH statement.   For good measure out (though it may not exist strictly necessary, I too added the post-obit directories to my path argument:

C:\Users\YourUserName\Anaconda3\envs\py35;C:\Users\YourUserNamel\Anaconda3\Scripts;C:\Users\YourUserName\Anaconda3\envs\py35\Lib\site-packages  (remember to type in a semicolon after C:\Program Files (x86)\Graphviz2.38\bin earlier typing in another entry).

Substitute your Windows User Account name for the YourUserName directly in a higher place.

11.  To confirm that your PATH surroundings variable value has been updated, open a Control Window and type path and then enter.  The value of your PATH environment variable volition repeat to the screen.  If what yous see doesn't include the entries you but added, you'll need to re-boot your system and check again.

12.  Bold your PATH has been updated, you can install graphviz (from within the Anaconda prompt for your surround - which should now also show upward as a shortcut from the Starting time Carte or from inside the anaconda Program Group) by typing conda install graphviz and so Enter.

13.  So install the pydot package by typing pip install pydot and and so Enter

fourteen.  Concluding but not to the lowest degree, install Keras (recently updated to version 2.0.6) by typing conda install -c conda-forge keras and then Enter.   After confirming that y'all want to do the install, Keras and numerous dependent packages will be installed, and you'll exist back at the Anaconda prompt for your environment.

15.  If yous want to employ Tensorboard to visualize your models install the latest version of Tensorflow and Tensorboard by typing

           pip install --ignore-installed --upgrade tensorflow

and and then Enter.  Quite a few packages will be installed, and yous'll exist dorsum at the Anaconda prompt.

For info re: Tensorflow and Tensorboard, visit https://www.tensorflow.org

If you blazon conda list and and then Enter, you will see that your environment now contains many more packages.

The terminal configuration pace needs to occur inside RapidMiner Studio past selecting Settings -> Preferences and telling RapidMiner Studio where python.exe is within your Python environment.  Past default, the complete path should be:

 C:\Users\YourUserName\Anaconda3\envs\YourEnvironmentName\python.exe

Click on the disk icon to the left of the Test command button and navigate to python.exe within your environs twice - in one case for the "Keras" choice and once for the "Python Scripting" pick in the Preferences dialog.  Be sure to click on the "Test" button both times.  If at that place are no errors, you lot'll get a message box stating that Python has been detected within Anaconda.  On all my Dev boxes, there were no errors, hopefully there will be no errors on your organisation.

Some or all of the gear up commands above may not piece of work with Windows 10, but Windows 10 does allow you to set compatibility mode to run diverse programs, so possibly experimenting with compatibility settings would assistance.

The installation described above is a CPU installation as opposed to a GPU installation.  GPU installations will run keras models quicker, but have hardware requirements and the install is tricky.  For more info on this subject visit https://world wide web.google.ca/search?q=keras+gpu+installation&oq=keras+gpu+installation&aqs=chrome..69i57j69...

You should (hopefully) now be able to run the Keras samples provided with RapidMiner which are in the repository nether the entry Keras Samples.

If you want to requite Tensorboard a spin, you will need to arrange a few default settings of the Keras Model operator in the process.  If you don't want to try Tensorboard, you can run the process and see the outputs in the RapidMiner Results panel.

I fastened some screenshots with some instance settings if you want to effort Tensorboard.   Start with the screenshot of the process parameters console below:

Select a loss metric from the dropdown opposite the loss parameter (I selected mean_squared_error).

Tick on the "use metric" label below the decay parameter.  Then and then lick on the "Edit enumeration" button reverse the "metric" parameter.  A dialog will open, and if yous similar, you can select an additional metric to visualize.  Theoretically, you lot should be able to select additional metrics, just selecting more than one causes (on my systems) the process to crash.  The fault message states that the desired metric proper noun (a concatenation of metrics in the enumeration) is invalid, even though the process XML would announced to prevent that type of error message.  After selecting a single metric from the enumeration, (I chose mape) click on OK.

Enter .25 for the "validation split" parameter (just below the verbose parameter) - I think that setting the validation split up parameter to a non zip value enables the brandish of histograms and distributions in Tensorboard.

Click on the "Edit enumeration" button reverse the callbacks parameter.  Another dialog will open.  Clicking on the dropdown card volition expose several default template callback statements.  The fastened screenshot shows 3 different callback types (RM allows multiple choices for callbacks) that I set.   I don't fully sympathise how to construct callbacks, peculiarly what you need to specify in order to see embeddings and checkpoints.  You will see that one of the callbacks creates a checkpoint file, only it doesn't display in Tensorboard, and I'g non sure why. I would appreciate whatsoever guidance on this point.  The CSV Logger outputs a csv file containing information re: the values of the metrics you selected during the training process.  The screenshot below shows the 3 callbacks I configured:

As configured in the screenshot, y'all should exist able to see scalar values, images, graphs, distributions, and histograms in Tensorboard.  I think that setting the histogram_freq value to 1 and write_grads=True enables histograms and distributions to display in Tensorflow every bit long equally the validation split up parameter (run across first screen shot above) is set to a non zero value.

The next pace is to create a directory using Windows Explorer where the callbacks that Tensorboard volition read will be written to deejay when RapidMiner executes the process.  On my systems, it'south C:\TensorboardLogDir

Below is a screenshot of the s&p 500 -regression sample process with a few additions - I added a Performance operator, and I continued the "his" and "exa" ports of the Keras Model operator to process "res" ports.  The his (for history) delivers the same information in the csv file generated by the CSV Logger that is referenced in a callback.

Procedure Design View

Subsequently configuring the procedure, you can run it - which will have a few moments.  If y'all go to your Tensorboard log directory, y'all should see iii files assuming you lot configured the Tensorboard callback as per the screenshot.   In that location volition be an "events out" file, a csv file, and a checkpoint (.ckpt) file.  If you set the "write_images" flag to True in the Tensorboard callback, the file will be quite big - several hundred megabytes.  If you set it to No, it volition be around 100 megabytes (that's what the file sizes were on my systems).

Create a sub-directory (a new folder) within your Tensorboard log directory and move the three files to that new folder.

The next step is to start Tensorboard.  From inside your Anaconda prompt for your Python environment, blazon:

tensorboard --logdir="Your Tensorboard Log Directory Name" --host=127.0.0.1

and then Enter.

I needed to put quotes around the log directory name.  On my systems, I typed:

tensorboard --logdir=C:\"TensorboardLogDir" --host=127.0.0.one

Afterwards a few seconds, Tensorboard will load and display a message to the effect that you should open up a browser and navigate to http://127.0.0.i:6006

After inbound that URL in your browser, Tensorboard should load later on a few seconds.   On the left hand side of the screen, about the middle, y'all'll see the discussion "runs".  You should see a list that has two items, C\ and C\<subdirectory name>.  On my systems, its C\1.  Click on the SCALARS heading at the superlative of the browser window and and click on C\<Sun-directory Name> beneath "runs".  Four visualizations of scalar values should appear on your screen.  On my screen, these four values are loss, mean_absolute_percentage_error, val_loss, and _val_mean_absolute_percentage_error.  I'thou not certain why I get four metrics as opposed to two, and I don't understand the difference between "loss" and "val_loss" and "mean_absolute_percentage_error" and "val_mean_absolute_percentage_error".  Any guidance on this would be appreciated.  The values for all of the visualizations you lot will see in Tensorboard come from the "events out" file.

If your callback included images, click on IMAGES at the top of the browser window will evidence images representing your model.  I think images are almost useful in text mining, but perhaps I may be missing something.  Clicking on GRAPHS shows a Graph realization of the neural network, and clicking on DISTRIBUTIONS and HISTOGRAMS shows metadata related to the training progress (the behaviors or layers in the network) over the 256 epochs the grooming ran.

There is an option called INACTIVE next to HISTOGRAMS.  If yous click on the INACTIVE selection and then click on Projector, you'll get an fault message stating that a checkpoint file has not been saved, even though I configured a callback to write a checkpoint file.  I'one thousand sure I'm missing something, any suggestions appreciated.

Yous can then go dorsum to RapidMiner, change the process in some way, and so run the process again.  Three more than files will exist written to your Tensorboard logging directory.  Create a new subfolder and move the new files into that subfolder.

Go to Tensorboard in your browser and reload the page.  You will so see both of your sub-folders nether "runs" near the middle of the left hand side of your browser window. You click single or multiple select these subfolders and the appropriate visualisation(s) will appear.  I haven't plant a manner to toggle between vizzes except by putting files related to each run in its ain sub-directory underneath the main Tensorboard log directory.

I hope the above has been helpful.  In that location is still quite a bit of material I don't actually yet empathise (especially virtually callbacks), but at the very least, I hope the above will help with getting one through the setup so that ane tin can at least get a feel for what'southward going on.  There'southward a very informative webinar about Keras and RapidMiner at https://rapidminer.com/resource/state-deep-learning/.  Information technology's also on YouTube.  There are besides many practiced resource on the web regarding Tensorflow and Tensorboard, one of the best existence tensorflow.org.

Notes:

I described how one should modify the PATH environs variable every bit part of installing the Graphviz packet.  I also said that for good mensurate (though information technology may not be admittedly required) that one should add the following directories to the PATH environment variable:

C:\Users\YourUserName\Anaconda3\envs\py35;C:\Users\YourUserNamel\Anaconda3\Scripts;C:\Users\YourUserName\Anaconda3\envs\py35\Lib\site-packages  (remember to type in a semicolon after C:\Program Files (x86)\Graphviz2.38\bin before typing in another entry).

The in a higher place should substitute your Python environment proper noun for my environment proper name (py35) in the statement above.

There was i type pertaining to what histograms and distributions testify in Tensorflow.  As far as I can tell these elements describe activity in the various layers of the network.

Best wishes, Michael

How to prepare Keras on Ubuntu sixteen:04 LTS - courtesy @jacobcybulski

It is important that you install the versions the documentation says to install and not annihilation "better".

NVIDIA CUDA Toolkit (only needed for GPU support)

• CUDA 8 spider web site (at this stage Tensorflow dos not work with CUDA 9):
  https://programmer.nvidia.com/cuda-downloads
• Check that y'all have a CUDA compatible GPU, I.e.
  See the list onhttps://programmer.nvidia.com/cuda-gpus
• Download CUDA viii GA2 x86_64 Deb for Ubuntu 16.04 (ane.9Gb) + Patch 2 (128 Mb)
  https://developer.nvidia.com/cuda-80-ga2-download-archive
• Follow instructions to install drivers and toolkit
  If y'all have a newer driver, install the toolkit manually and skip the driver installation,
  place it in <cudapath> (due east.thousand. /usr/local/, alter to yours)
• Ready CUDA variables in your ~/.contour (or ~/.bash_profile), e.yard. to:
  export PATH=
     <cudapath>/cuda/bin${PATH:+:${PATH}}
  consign LD_LIBRARY_PATH=
     <cudapath>/cuda/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
  export LD_LIBRARY_PATH=
     <cudapath>/cuda/extras/CUPTI/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
  export CUDA_HOME=<cudapath>/cuda
     (yous may need to log out and log in again after editing this file)
• And then install cuDNN 6, from web site:https://developer.nvidia.com/cudnn
  Annotation that I have not tested Tensorflow with cuDNN 7 simply you could requite it a become
  You may demand to annals for download, identify it in <cudnnpath> (change information technology to yours)
• Copy the post-obit files into the CUDA Toolkit directory:
  $ cd <cudnnpath>
  $ sudo cp -P include/cudnn.h <cudapath>/cuda/include
  $ sudo cp -P lib64/libcudnn* <cudapath>/cuda/lib64
  $ sudo chmod a+r <cudapath>/cuda/lib64/libcudnn*

Anaconda

• Web site:
  https://world wide web.continuum.io/
• Download for Python 3.vi+, 64bit, from:
  https://www.continuum.io/downloads
• Install in easily accessible location, east.g.:
  ~/anaconda3
• Notation that in the process of adding Anaconda, you will be prompted to add it to the PATH. If not add it to your ~/.contour:
  PATH="<condapath>/anaconda3/bin:$HOME/bin:$HOME/.local/bin:$PATH"
  (you lot may demand to log out and log in once again after editing this file)
• Open a new command line and examination information technology, I.east.
  $ conda –version

Tensorflow (It now works with Python 3.6+)

• Web site:https://www.tensorflow.org/
• Follow instructions for Anaconda, I.e. from command line (recently updated):
  $ conda create -northward tensorflow python=three.six (or lower, east.grand. v3.5)
  $ source activate tensorflow (you switch to Tensorflow environment)
• Install for CPU just:
  (tensorflow) $ pip install --ignore-installed --upgrade tensorflow
• Install for GPU merely:
  (tensorflow) $ pip install --ignore-installed --upgrade tensorflow-gpu
• Test your installation by writing a brusque plan, east.g.
  (tensorflow) $ python
  >>> import tensorflow as tf
  >>> hello = tf.constant('Hello, TensorFlow!')
  >>> sess = tf.Session()
  >>> impress(sess.run(hello))
  >>> ^D
• Yous may also wish to optionally install in that surroundings (esp. if yous decided to use a version of Python dissimilar from that in the root):
  (tensorflow) $ conda install numpy
  (tensorflow) $ conda install scipy
  (tensorflow) $ conda install scikit-learn
  (tensorflow) $ conda install pandas
  (tensorflow) $ conda install matplotlib
  (tensorflow) $ conda install jupyter

Keras

• Make certain you lot install Keras in the previously defined Tensorflow environment, i.e. from the command line execute:
  $ source activate tensorflow
• Then install a number of packages, I.east.
  Already installed cuDNN (if using GPU, encounter above)
  (tensorflow) $ conda install HDF5
  (tensorflow) $ conda install h5py (the previous may exist downgraded)
  (tensorflow) $ conda install graphviz
  (tensorflow) $ conda install python-graphviz
  (tensorflow) $ pip install pydot
  (tensorflow) $ conda list (brand sure pydot and graphviz are listed)
• If you lot were not lucky with graphviz and / or pydot, you can go out their installation for afterwards as both are needed just for charting of Keras models. If I always had whatever issues with the installation of Keras, these ii were the primary crusade of problems. If all fails, effort googling around. You may nevertheless endeavour this workaround to install graphviz software separately (Anaconda only provides an interface to the software), i.e.
  $ sudo apt-become update
  $ sudo apt-go install graphviz
• Stop installation with:
  (tensorflow) $ pip install Keras
• You are at present prepare to use Keras in Python

RapidMiner Studio

• Download and install RapidMiner Studio
• Install Keras extension from the RapidMiner Marketplace
• In Settings > Preferences > Keras tab,
  prepare Path to Python executable to Python inside the Tensorflow surroundings, e.g.
  ~/anaconda3/envs/tensorflow/bin/python
• You tin can start modeling with Keras in RapidMiner Studio

How to set up Keras using Microsoft Cognitive Tookit – courtesy @pschlunder

1. Follow the instructions over at Microsofts installation guide to install their Cerebral Toolkit for Python. Make sure to cull the version matching your python version and selecting the ane with GPU back up, if you want to execute your procedure on GPUs also.
2. Install Keras by running `conda install keras` if you are using Anaconda or `pip install keras` if non.
3. Run Keras in one case. Due east.g. by opening up a command prompt, starting python and running `import keras`.
4. Now a `keras.json` file should exists in a subconscious folder called `.keras` in your users home directory. Information technology might await like this
   

   {      "backend": "tensorflow",      "floatx": "float32",      "image_data_format": "channels_last",      "epsilon": 1e-07  }

5. Modify the 'backend' value in the json file to 'cntk', salvage the file.
6. Point the RapidMiner Keras Extension to the Python y'all are using for CNTK (Cerebral Toolkit).

The Missing MNIST Example in Keras for RapidMiner – courtesy @jacobcybulski

As I was reading @kakkad2 comment on convolutional neural nets in Keras, I take realised that we do not accept a working example anywhere to evidence how to deal with CNN in Keras for RM, specially when the application is in epitome recognition - the very staple of CNN. So I have quickly produced a CNN RM process (run into attached at the end). To brand it simpler, I accept reproduced the Keras Python instance from the Francois Challet github, see:

• https://github.com/fchollet/keras/blob/master/examples/mnist_cnn.py

The problems of replicating the MNIST logic in RM are as follows:

1. Nosotros cannot read epitome data into RM;
2. RM wants all data to be in tabular format;
3. Some of the Keras operator's defaults are not the same every bit those for Python.

To bargain with reading images into RM we could utilize the IMMI extension, yet at the moment I have no access to IMMI for RM 7.six. The next best choice is to get the image data using Python and export it as a Pandas data frame with extra meta info, which is a valid example set. The 2d issue can be easily handled past unfolding the four dimensional image data (examples 10 pixel rows X pixel columns 10 color channels) into ii dimensional tables of RM examples (examples X pixel color channel) - the main trouble would be to fold back this representation for convolution to happen, also we need to scout for the internal representation of images as passed into RM through Tensorflow or Theano, which could be channel first or last. Finally, we need to check what defaults are given to us by RM Keras (e.k. for optimizers) vs what defaults are divers for the same functions in Python, or amend experiment with different settings.

The Python lawmaking to read in information is very simple. Annotation that to mirror exactly what was washed in the github instance, the data was read from Keras standard information set "mnist", its shape saved, data transformed into floats, and finally both training and test "x" and "y" vectors take been "unfolded" and merged into Pandas data frames with "y" column defined as the RM "label" (using rm_metadata attribute). The shape information was also returned equally a data frame, so that it could later be used to set prototype sizes and shapes in the convolutional nets.

from __future__ import print_function  import os  import numpy as np  import pandas as pd    import keras  from keras.datasets import mnist  from keras import backend equally K      ### Loads and returns MNIST data set in Pandas format  def rm_main():            # input image dimensions      img_rows, img_cols, ch_no = 28, 28, 1      num_classes = 10            # the information, shuffled and split up between train and exam sets      (x_train, y_train), (x_test, y_test) = mnist.load_data()            if Chiliad.image_data_format() == 'channels_first':          input_shape = (ch_no, img_rows, img_cols)      else:          input_shape = (img_rows, img_cols, ch_no)            x_train = x_train.reshape(x_train.shape[0], img_rows*img_cols*ch_no).astype('float32')      x_test = x_test.reshape(x_test.shape[0], img_rows*img_cols*ch_no).astype('float32')      x_train /= 255      x_test /= 255            # convert epitome vectors to information frames      df_train = pd.concat([pd.DataFrame(data={'y': y_train}), pd.DataFrame.from_dict(x_train)], axis=1)      setattr(df_train, "rm_metadata", {})      df_train.rm_metadata['y'] = ("nominal","label")      df_test = pd.concat([pd.DataFrame(data={'y': y_test}), pd.DataFrame.from_dict(x_test)], axis=ane)      setattr(df_test, "rm_metadata", {})      df_test.rm_metadata['y'] = ("nominal","characterization")        # Set shape info      shape_data = np.array([['', 'rows', 'cols', 'ch', 'shape'],                            ['', img_rows, img_cols, ch_no, str(input_shape)]])            shape_result = pd.DataFrame(information=shape_data[1:,i:],                         alphabetize=shape_data[ane:,0],                         columns=shape_data[0,one:])      setattr(shape_result, "rm_metadata", {})      shape_result.rm_metadata['rows'] = ("integer",None)      shape_result.rm_metadata['cols'] = ("integer",None)      shape_result.rm_metadata['ch'] = ("integer",None)      shape_result.rm_metadata['shape'] = ("text",None)            # Render results      return df_train, df_test, shape_result          

The RM process is very simple - it reads images data in, passes the grooming and validation data sets to Keras sequence so checks the model performance. The architecture of the Keras network is slightly unlike from that in the github case, equally we need to include an extra initial step to fold the data dorsum into its original course based on the size and shape info passed into RM. So the model looks like this:

All other network elements are identical to those in the Python code. When the procedure runs information technology gives an near verbal functioning as the aforementioned code in Python, which could exist plotted in RM or watched in existent-time using Tensorflow, e.grand.

Bask convolutional neural nets processing images in RapidMiner.

The whole process yous can find in the post-obit RMP.

<?xml version="i.0" encoding="UTF-eight"?><process version="seven.6.001">    <context>      <input/>      <output/>      <macros/>    </context>    <operator activated="true" class="process" compatibility="7.6.001" expanded="true" name="Process">      <process expanded="true">        <operator activated="true" form="python_scripting:execute_python" compatibility="7.iv.000" expanded="true" height="124" proper name="Execute Python" width="xc" x="45" y="187">          <parameter key="script" value="from __future__ import print_function&#10;import bone&#ten;import numpy as np&#10;import pandas as pd&#10;&#ten;import keras&#10;from keras.datasets import mnist&#10;from keras import backend as K&#10;&#10;&#10;### Loads and returns MNIST data set up in Pandas format&#10;def rm_main():&#10;    &#10;    # input image dimensions&#10;    img_rows, img_cols, ch_no = 28, 28, 1&#x;    num_classes = 10&#ten;    &#x;    # the information, shuffled and split up betwixt railroad train and test sets&#x;    (x_train, y_train), (x_test, y_test) = mnist.load_data()&#x;    &#10;    if Thou.image_data_format() == 'channels_first':&#10;        input_shape = (ch_no, img_rows, img_cols)&#10;    else:&#10;        input_shape = (img_rows, img_cols, ch_no)&#10;    &#10;    x_train = x_train.reshape(x_train.shape[0], img_rows*img_cols*ch_no).astype('float32')&#10;    x_test = x_test.reshape(x_test.shape[0], img_rows*img_cols*ch_no).astype('float32')&#ten;    x_train /= 255&#10;    x_test /= 255&#10;    &#x;    # catechumen image vectors to data frames&#ten;    df_train = pd.concat([pd.DataFrame(information={'y': y_train}), pd.DataFrame.from_dict(x_train)], axis=1)&#10;    setattr(df_train, &quot;rm_metadata&quot;, {})&#10;    df_train.rm_metadata['y'] = (&quot;nominal&quot;,&quot;label&quot;)&#10;    df_test = pd.concat([pd.DataFrame(data={'y': y_test}), pd.DataFrame.from_dict(x_test)], centrality=1)&#x;    setattr(df_test, &quot;rm_metadata&quot;, {})&#10;    df_test.rm_metadata['y'] = (&quot;nominal&quot;,&quot;characterization&quot;)&#ten;&#10;    # Prepare shape info&#x;    shape_data = np.array([['', 'rows', 'cols', 'ch', 'shape'],&#10;                          ['', img_rows, img_cols, ch_no, str(input_shape)]])&#10;    &#10;    shape_result = pd.DataFrame(data=shape_data[ane:,i:], &#x;                      index=shape_data[i:,0], &#ten;                      columns=shape_data[0,1:])&#x;    setattr(shape_result, &quot;rm_metadata&quot;, {})&#10;    shape_result.rm_metadata['rows'] = (&quot;integer&quot;,None)&#ten;    shape_result.rm_metadata['cols'] = (&quot;integer&quot;,None)&#10;    shape_result.rm_metadata['ch'] = (&quot;integer&quot;,None)&#10;    shape_result.rm_metadata['shape'] = (&quot;text&quot;,None)&#10;    &#ten;    # Return results&#10;    return df_train, df_test, shape_result&#10;    "/>        </operator>        <operator activated="true" class="extract_macro" compatibility="7.half-dozen.001" expanded="true" meridian="68" name="Extract Macro" width="ninety" 10="246" y="391">          <parameter key="macro" value="img_shape"/>          <parameter key="macro_type" value="data_value"/>          <parameter key="attribute_name" value="shape"/>          <parameter central="example_index" value="1"/>          <list key="additional_macros">            <parameter central="img_rows" value="rows"/>            <parameter primal="img_cols" value="cols"/>            <parameter key="img_channels" value="ch"/>          </listing>        </operator>        <operator activated="true" class="generate_macro" compatibility="7.6.001" expanded="truthful" meridian="82" name="Generate Macro" width="ninety" x="380" y="391">          <list fundamental="function_descriptions">            <parameter key="img_size" value="eval(%{img_rows})*eval(%{img_cols})*eval(%{img_channels})"/>          </list>        </operator>        <operator activated="true" class="multiply" compatibility="vii.half dozen.001" expanded="true" tiptop="103" name="Multiply" width="90" x="246" y="238"/>        <operator activated="truthful" class="keras:sequential" compatibility="i.0.003" expanded="true" tiptop="166" name="Keras Model" width="xc" 10="380" y="34">          <parameter key="input shape" value="(%{img_size},)"/>          <parameter cardinal="loss" value="categorical_crossentropy"/>          <parameter central="optimizer" value="Adadelta"/>          <parameter key="learning charge per unit" value="1.0"/>          <parameter cardinal="rho" value="0.95"/>          <parameter key="use metric" value="true"/>          <enumeration fundamental="metric">            <parameter fundamental="metric" value="categorical_accuracy"/>          </enumeration>          <parameter primal="epochs" value="12"/>          <parameter key="batch size" value="128"/>          <enumeration key="callbacks">            <parameter key="callbacks" value="TensorBoard(log_dir='/tmp/keras_logs/MNIST_RM', histogram_freq=0, write_graph=Truthful, write_images=True, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None)"/>          </enumeration>          <parameter key="verbose" value="ii"/>          <parameter key="shuffle" value="true"/>          <process expanded="true">            <operator activated="true" grade="keras:core_layer" compatibility="ane.0.003" expanded="truthful" pinnacle="82" proper name="Add Reshape" width="90" x="45" y="34">              <parameter key="layer_type" value="Reshape"/>              <parameter key="target_shape" value="%{img_shape}"/>              <parameter fundamental="dims" value="1.1"/>            </operator>            <operator activated="true" class="keras:conv_layer" compatibility="ane.0.003" expanded="truthful" elevation="82" name="Add Conv2D 1" width="xc" x="179" y="34">              <parameter key="layer_type" value="Conv2D"/>              <parameter key="filters" value="32"/>              <parameter key="kernel_size_2d" value="3.iii"/>              <parameter key="kernel_size_3d" value="ane.1.one"/>              <parameter key="strides_2d" value="ane.ane"/>              <parameter key="strides_3d" value="i.1.ane"/>              <parameter key="padding_1d" value="1.1"/>              <parameter key="cropping_1d" value="i.1"/>              <parameter key="size_2d" value="2.2"/>              <parameter key="size_3d" value="ii.2.two"/>              <parameter key="dilation_rate_2d" value="one.i"/>              <parameter key="dilation_rate_3d" value="1.1.1"/>              <parameter fundamental="activation_function" value="'relu'"/>            </operator>            <operator activated="truthful" class="keras:conv_layer" compatibility="one.0.003" expanded="truthful" height="82" proper name="Add Conv2D 2" width="90" x="313" y="34">              <parameter key="layer_type" value="Conv2D"/>              <parameter primal="filters" value="64"/>              <parameter primal="kernel_size_2d" value="3.3"/>              <parameter key="kernel_size_3d" value="1.ane.1"/>              <parameter key="strides_2d" value="1.1"/>              <parameter central="strides_3d" value="1.1.one"/>              <parameter fundamental="padding_1d" value="1.1"/>              <parameter key="cropping_1d" value="1.1"/>              <parameter key="size_2d" value="2.2"/>              <parameter key="size_3d" value="2.2.2"/>              <parameter central="dilation_rate_2d" value="one.1"/>              <parameter fundamental="dilation_rate_3d" value="1.1.1"/>              <parameter key="activation_function" value="'relu'"/>            </operator>            <operator activated="true" class="keras:pooling_layer" compatibility="1.0.003" expanded="true" height="82" proper name="Add Pooling Layer" width="90" x="447" y="34">              <parameter key="layer_type" value="MaxPooling2D"/>              <parameter key="pool_size_2d" value="ii.2"/>              <parameter key="pool_size_3d" value="ii.2.ii"/>              <parameter key="strides_2d" value="2.2"/>              <parameter cardinal="strides_3d" value="2.2.two"/>            </operator>            <operator activated="true" grade="keras:core_layer" compatibility="1.0.003" expanded="true" height="82" name="Add Dropout 1" width="xc" x="581" y="34">              <parameter key="layer_type" value="Dropout"/>              <parameter primal="rate" value="0.25"/>              <parameter key="dims" value="1.1"/>            </operator>            <operator activated="truthful" class="keras:core_layer" compatibility="1.0.003" expanded="true" height="82" name="Add Flatten" width="90" x="179" y="238">              <parameter key="layer_type" value="Flatten"/>              <parameter central="dims" value="1.i"/>            </operator>            <operator activated="true" class="keras:core_layer" compatibility="1.0.003" expanded="truthful" height="82" name="Add Dense 1" width="xc" ten="313" y="238">              <parameter cardinal="no_units" value="128"/>              <parameter key="activation_function" value="'relu'"/>              <parameter cardinal="dims" value="1.1"/>            </operator>            <operator activated="true" form="keras:core_layer" compatibility="1.0.003" expanded="true" elevation="82" proper name="Add Dropout 2" width="90" ten="447" y="238">              <parameter cardinal="layer_type" value="Dropout"/>              <parameter key="rate" value="0.5"/>              <parameter key="dims" value="1.1"/>            </operator>            <operator activated="true" class="keras:core_layer" compatibility="1.0.003" expanded="true" elevation="82" name="Add Dense Softmax" width="90" x="581" y="238">              <parameter key="no_units" value="10"/>              <parameter primal="activation_function" value="'softmax'"/>              <parameter key="dims" value="ane.i"/>            </operator>            <connect from_op="Add Reshape" from_port="layers i" to_op="Add Conv2D one" to_port="layers"/>            <connect from_op="Add Conv2D ane" from_port="layers one" to_op="Add Conv2D 2" to_port="layers"/>            <connect from_op="Add Conv2D 2" from_port="layers 1" to_op="Add Pooling Layer" to_port="layers"/>            <connect from_op="Add Pooling Layer" from_port="layers 1" to_op="Add Dropout 1" to_port="layers"/>            <connect from_op="Add Dropout 1" from_port="layers ane" to_op="Add Flatten" to_port="layers"/>            <connect from_op="Add Flatten" from_port="layers one" to_op="Add Dense 1" to_port="layers"/>            <connect from_op="Add Dense 1" from_port="layers 1" to_op="Add Dropout two" to_port="layers"/>            <connect from_op="Add Dropout 2" from_port="layers 1" to_op="Add Dumbo Softmax" to_port="layers"/>            <connect from_op="Add Dumbo Softmax" from_port="layers one" to_port="layers 1"/>            <portSpacing port="sink_layers i" spacing="0"/>            <portSpacing port="sink_layers ii" spacing="0"/>          </procedure>        </operator>        <operator activated="true" class="generate_id" compatibility="7.six.001" expanded="true" height="82" proper name="Generate ID" width="90" x="581" y="34"/>        <operator activated="true" class="keras:apply" compatibility="1.0.003" expanded="true" top="82" name="Apply Keras Model" width="ninety" 10="581" y="238">          <parameter key="batch_size" value="8"/>          <parameter primal="verbose" value="1"/>        </operator>        <operator activated="true" class="performance_classification" compatibility="7.6.001" expanded="true" acme="82" proper name="Performance" width="90" x="715" y="136">          <parameter central="kappa" value="truthful"/>          <parameter key="correlation" value="truthful"/>          <listing key="class_weights"/>        </operator>        <connect from_op="Execute Python" from_port="output 1" to_op="Keras Model" to_port="training gear up"/>        <connect from_op="Execute Python" from_port="output 2" to_op="Multiply" to_port="input"/>        <connect from_op="Execute Python" from_port="output 3" to_op="Excerpt Macro" to_port="case set"/>        <connect from_op="Extract Macro" from_port="case set" to_op="Generate Macro" to_port="through ane"/>        <connect from_op="Multiply" from_port="output 1" to_op="Keras Model" to_port="validation set"/>        <connect from_op="Multiply" from_port="output 2" to_op="Apply Keras Model" to_port="unlabelled data"/>        <connect from_op="Keras Model" from_port="model" to_op="Employ Keras Model" to_port="model"/>        <connect from_op="Keras Model" from_port="history" to_op="Generate ID" to_port="example set input"/>        <connect from_op="Generate ID" from_port="instance set output" to_port="result 1"/>        <connect from_op="Apply Keras Model" from_port="labelled data" to_op="Performance" to_port="labelled data"/>        <connect from_op="Utilise Keras Model" from_port="model" to_port="issue 4"/>        <connect from_op="Performance" from_port="functioning" to_port="result two"/>        <connect from_op="Performance" from_port="example fix" to_port="result iii"/>        <portSpacing port="source_input 1" spacing="0"/>        <portSpacing port="sink_result 1" spacing="0"/>        <portSpacing port="sink_result two" spacing="21"/>        <portSpacing port="sink_result 3" spacing="189"/>        <portSpacing port="sink_result iv" spacing="126"/>        <portSpacing port="sink_result five" spacing="0"/>      </process>    </operator>  </process>          

[ADDED Later on] I accept been playing with a standard MNIST case and comparing the same model performance against those running on R/R Studio and Python/Anaconda. I have stumbled on an issue while plotting the results using Tensorboard. The common metric used in measuring the classifier is "accurateness" or "acc", which will be then translated by Keras into something more advisable depending on the output shape, so in MNIST it will be "categorical_accuracy". The RM Keras plugin is trying to be smarter than humans working with Python and R and it eliminates "accuracy" and "acc" every bit an option for such models. This causes problems with Tensorboard, as then the Python and R generated logs volition testify every bit "acc" and "val_acc" panels and the RM logs will exist placed in carve up panels "categorical_accuracy" and "val_categorical_accuracy". We need to bring the "accuracy" back to the Keras plugin metric options! By the style, the result tin can be "stock-still" by finding the offending pick in XML and irresolute it there, then the RM Keras logs will rejoin the rest of the world

Jacob

P.Due south. Interestingly when running MNIST over 30 epochs, compared with R (orange and dark blue) and Python (dark-brown and light blue), RM (majestic) consistently produces all-time validation loss just its validation accuracy places it in the heart. The Python beats all, R is the loser.

rimmervicke1964.blogspot.com

Source: https://community.rapidminer.com/discussion/54550/keras-deep-learning-extension

Share this post