diff --git a/Iphone Detection/Iphone+Detection+(Bezhenar).ipynb b/Iphone Detection/Iphone+Detection+(Bezhenar).ipynb new file mode 100644 index 0000000..6ad287e --- /dev/null +++ b/Iphone Detection/Iphone+Detection+(Bezhenar).ipynb @@ -0,0 +1,564 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Iphone or not Iphone detection\n", + "*Bezhenaer OLga*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data collection:\n", + "I honestly did not cope with the data collection, so my colleagues shared it with me. However, I carried out the primary cleaning of data from garbage (pictures downloaded from avito on the subject of \"iPhone\" that do not contain photos of iPhones)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Preparation stage" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "#import of libraries \n", + "from keras.preprocessing import image\n", + "from keras.applications import resnet50, inception_v3, vgg16\n", + "from keras.models import Model\n", + "from keras.layers import Dense, GlobalAveragePooling2D, Input\n", + "from keras.optimizers import Adam\n", + "import numpy as np\n", + "from keras import backend as K\n", + "from keras.preprocessing.image import ImageDataGenerator\n", + "from keras.models import load_model\n", + "import tensorflow as tf\n", + "from tensorflow.contrib import lite\n", + "import os\n", + "from sklearn.metrics import average_precision_score\n", + "from sklearn.metrics import precision_recall_curve\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/qubvel/classification_models.git\n", + " Cloning https://github.com/qubvel/classification_models.git to /tmp/pip-925gaong-build\n", + " Requirement already satisfied (use --upgrade to upgrade): image-classifiers==0.2.2 from git+https://github.com/qubvel/classification_models.git in ./anaconda3/lib/python3.6/site-packages\n", + "Requirement already satisfied: keras>=2.1.0 in ./anaconda3/lib/python3.6/site-packages (from image-classifiers==0.2.2)\n", + "Requirement already satisfied: numpy>=1.9.1 in ./anaconda3/lib/python3.6/site-packages (from keras>=2.1.0->image-classifiers==0.2.2)\n", + "Requirement already satisfied: scipy>=0.14 in ./anaconda3/lib/python3.6/site-packages (from keras>=2.1.0->image-classifiers==0.2.2)\n", + "Requirement already satisfied: six>=1.9.0 in ./anaconda3/lib/python3.6/site-packages (from keras>=2.1.0->image-classifiers==0.2.2)\n", + "Requirement already satisfied: pyyaml in ./anaconda3/lib/python3.6/site-packages (from keras>=2.1.0->image-classifiers==0.2.2)\n", + "Requirement already satisfied: h5py in ./anaconda3/lib/python3.6/site-packages (from keras>=2.1.0->image-classifiers==0.2.2)\n", + "Requirement already satisfied: keras_applications>=1.0.6 in ./anaconda3/lib/python3.6/site-packages (from keras>=2.1.0->image-classifiers==0.2.2)\n", + "Requirement already satisfied: keras_preprocessing>=1.0.5 in ./anaconda3/lib/python3.6/site-packages (from keras>=2.1.0->image-classifiers==0.2.2)\n", + "\u001b[33mYou are using pip version 9.0.1, however version 19.1.1 is available.\n", + "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n" + ] + } + ], + "source": [ + "#installing Resnet18\n", + "!pip install git+https://github.com/qubvel/classification_models.git" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model creation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Loading model " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#importing Resnet18\n", + "from classification_models.resnet import ResNet18" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/st039712/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Colocations handled automatically by placer.\n" + ] + } + ], + "source": [ + "#Loading the model (RESNET18) with pre-trained weights\n", + "\n", + "num_classes = 2 \n", + "\n", + "base_model = ResNet18 \n", + "base_model = ResNet18(weights='imagenet',input_shape=(224,224,3), include_top=False) \n", + "\n", + "x = GlobalAveragePooling2D()(base_model.output) \n", + "predictions = Dense(512, activation='relu')(x) \n", + "predictions = Dense(num_classes, activation='softmax')(predictions) \n", + "model = Model(inputs=[base_model.input], outputs=predictions) \n", + "\n", + "for layer in model.layers: \n", + " layer.trainable = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Image transformation & data loaders" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true, + "scrolled": true + }, + "outputs": [], + "source": [ + "#Creating rule for images random transformation (ramdom transformation)\n", + "train_datagen = ImageDataGenerator(\n", + " rotation_range=15,\n", + " width_shift_range=0.2,\n", + " height_shift_range=0.2,\n", + " rescale=1./255,\n", + " shear_range=0.2,\n", + " zoom_range=0.2,\n", + " horizontal_flip=True,\n", + " fill_mode='nearest')\n", + "\n", + "val_datagen = ImageDataGenerator(\n", + " rotation_range=15,\n", + " width_shift_range=0.2,\n", + " height_shift_range=0.2,\n", + " rescale=1./255,\n", + " shear_range=0.2,\n", + " zoom_range=0.2,\n", + " horizontal_flip=True,\n", + " fill_mode='nearest')\n", + "\n", + "test_datagen = ImageDataGenerator(\n", + " rescale=1./255,\n", + " fill_mode='nearest')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#chosing batch size - parameter for modael tunning \n", + "batch_size=64" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 48902 images belonging to 2 classes.\n", + "Found 2035 images belonging to 2 classes.\n", + "Found 2000 images belonging to 2 classes.\n" + ] + } + ], + "source": [ + "#Setting the path to images (creating data loaders)\n", + "train_generator = train_datagen.flow_from_directory(\n", + " 'full dataset/train', # this is the target directory\n", + " target_size=(224, 224), # all images will be resized to 150x150\n", + " batch_size=batch_size,\n", + " class_mode='binary')\n", + "val_generator = val_datagen.flow_from_directory(\n", + " 'full dataset/val', # this is the target directory\n", + " target_size=(224, 224), # all images will be resized to 150x150\n", + " batch_size=batch_size,\n", + " class_mode='binary')\n", + "test_generator = test_datagen.flow_from_directory(\n", + " 'full dataset/test', # this is the target directory\n", + " target_size=(224, 224), # all images will be resized to 150x150\n", + "# batch_size=batch_size,\n", + " class_mode='binary')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'AOther': 0, 'Iphones': 1}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#positive - Iphones, negative - Not iphones \n", + "train_generator.class_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#Define sample sizes for further calculations \n", + "nb_samples_train = len(train_generator.filenames)\n", + "nb_samples_val= len(val_generator.filenames)\n", + "nb_samples_test = len(test_generator.filenames)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "#### Final step of the model building " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Final step of model building (main hyperparameter for tunning)\n", + "model.compile(loss='sparse_categorical_crossentropy',\n", + " optimizer=Adam(lr=0.001),\n", + " metrics=['acc']) # \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#loading weights (was used to save the results of previous model training)\n", + "model.load_weights('model.hdf5')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/st039712/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.cast instead.\n", + "Epoch 1/1\n", + "765/764 [==============================] - 688s 900ms/step - loss: 0.0410 - acc: 0.9845 - val_loss: 0.2530 - val_acc: 0.9283\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Train the model \n", + "model.fit_generator(\n", + " train_generator,\n", + " steps_per_epoch=nb_samples_train/batch_size,\n", + " epochs=200,\n", + " validation_data=val_generator,\n", + " validation_steps=nb_samples_val/batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "model.save_weights(\"model.hdf5\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "model.save('model.hdf5') " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reduction of the file size (compressing the model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I use Tensorflow Lite, as the way to solve problem with loading large files in GitHub." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/st039712/anaconda3/lib/python3.6/site-packages/tensorflow/lite/python/lite.py:591: convert_variables_to_constants (from tensorflow.python.framework.graph_util_impl) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.compat.v1.graph_util.convert_variables_to_constants\n", + "WARNING:tensorflow:From /home/st039712/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/graph_util_impl.py:245: extract_sub_graph (from tensorflow.python.framework.graph_util_impl) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.compat.v1.graph_util.extract_sub_graph\n", + "INFO:tensorflow:Froze 100 variables.\n", + "INFO:tensorflow:Converted 100 variables to const ops.\n" + ] + }, + { + "data": { + "text/plain": [ + "45785876" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Converting keras model to tflite model\n", + "converter = lite.TFLiteConverter.from_keras_model_file('model.hdf5')\n", + "tflite_model = converter.convert()\n", + "open(\"converted_model.tflite\", \"wb\").write(tflite_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model \"size\" now is about 45MB." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Measurement of the model quality" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# function for loading and rescaling images\n", + "def load_image(img_path):\n", + "\n", + " img = image.load_img(img_path, target_size=(224, 224))\n", + " img_tensor = image.img_to_array(img) \n", + " img_tensor = np.expand_dims(img_tensor, axis=0) \n", + " img_tensor /= 255.\n", + " \n", + " return img_tensor" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "val_dir='full dataset/val'" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# Load TFLite model and allocate tensors.\n", + "interpreter = tf.lite.Interpreter(model_path=\"converted_model.tflite\")\n", + "interpreter.allocate_tensors()\n", + "\n", + "# Get input and output tensors.\n", + "input_details = interpreter.get_input_details()\n", + "output_details = interpreter.get_output_details()\n", + "\n", + "#walking through our validation set and get predictions for each photo\n", + "compr_pred = []\n", + "for subdir, dirs, files in os.walk(val_dir):\n", + " for file in files:\n", + " input_data = load_image(os.path.join(subdir, file))\n", + " interpreter.set_tensor(input_details[0]['index'], input_data)\n", + " interpreter.invoke()\n", + " output_data = interpreter.get_tensor(output_details[0]['index'])\n", + " compr_pred.append(output_data[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average precision-recall score for compressed model: 0.9850241076\n" + ] + } + ], + "source": [ + "#result's check \n", + "average_precision_compr = average_precision_score(val_generator.classes, [x[1] for x in compr_pred])\n", + "print('Average precision-recall score for compressed model: {0:0.10f}'.format(average_precision_compr))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the precision-recall curve\n", + "precision, recall, _ = precision_recall_curve(val_generator.classes, [x[1] for x in compr_pred])\n", + "plt.fill_between(recall, precision, alpha=0.2, color='b')\n", + "plt.xlabel('Recall')\n", + "plt.ylabel('Precision')\n", + "plt.ylim([0.0, 1.0])\n", + "plt.xlim([0.0, 1.0])\n", + "plt.title('2-class Precision-Recall curve: AP={0:0.4f}'.format(average_precision_compr))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "! conda list -e > requirements.txt" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Iphone Detection/converted_model.tflite b/Iphone Detection/converted_model.tflite new file mode 100644 index 0000000..4ae3a9e Binary files /dev/null and b/Iphone Detection/converted_model.tflite differ diff --git a/Iphone Detection/link to dataset.txt b/Iphone Detection/link to dataset.txt new file mode 100644 index 0000000..b066407 --- /dev/null +++ b/Iphone Detection/link to dataset.txt @@ -0,0 +1,2 @@ +Link to test and val parts of the dataset:https://drive.google.com/drive/folders/1G2IMr5U1_B0qztbM_TAeoSe9MGbW6_iv?usp=sharing +* train part is quiete huge, so there was no sense to download it. \ No newline at end of file diff --git a/Iphone Detection/predict.py b/Iphone Detection/predict.py new file mode 100644 index 0000000..295a15c --- /dev/null +++ b/Iphone Detection/predict.py @@ -0,0 +1,94 @@ + +# coding: utf-8 + +# In[2]: + + +# import libraries +import argparse +import pandas as pd +import numpy as np +import os +import tensorflow as tf +from keras.preprocessing import image + + +# In[3]: + + +# create function for loading and rescaling images +def load_image(img_path): + img = image.load_img(img_path, target_size=(224, 224)) + img_tensor = image.img_to_array(img) + img_tensor = np.expand_dims(img_tensor, axis=0) + img_tensor /= 255. + return img_tensor + + +# In[4]: + + +# create function for calculating probabilities +def predict_proba(model_path, in_folder, out_file): + + print('Start image processing...') + + # Load TFLite model and allocate tensors. + interpreter = tf.lite.Interpreter(model_path=model_path) + interpreter.allocate_tensors() + + # Get input and output tensors. + input_details = interpreter.get_input_details() + output_details = interpreter.get_output_details() + + # initialize variables + preds = [] + filenames = [] + count = 0 + + #getting predictions for each photo + for subdir, dirs, files in os.walk(in_folder): + for file in files: + input_data = load_image(os.path.join(subdir, file)) + interpreter.set_tensor(input_details[0]['index'], input_data) + interpreter.invoke() + output_data = interpreter.get_tensor(output_details[0]['index']) + + # save results + preds.append(output_data[0]) + filenames.append(file) + + # print message every 100 images + count += 1 + if count % 100 == 0: + print('First', str(count), 'images done!') + + # create dataframe with filenames and iphone probabilities + out_df = pd.DataFrame() + out_df['image_name'] = filenames + out_df['iphone_probability'] = [pred[0] for pred in preds] + + # save dataframe with answer + out_df.to_csv(out_file, index=False) + + +# In[5]: + + +if __name__ == '__main__': + # disable warnings + os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' + + # parse arguments + parser = argparse.ArgumentParser(description='Iphone detector') + parser.add_argument('--model', type=str, default='converted_model.tflite', help='path to model') + parser.add_argument('--input', type=str, default='test', help='path to folder with pictures') + parser.add_argument('--output', type=str, default='predictions.csv', help='path to file with model output') + args = parser.parse_args() + print("model= {0} input_data= {1} output_data= {2}".format(args.model, args.input, args.output)) + + # get predictions + predict_proba(args.model, args.input, args.output) + print() + print('Predictions file is created successfully!') + diff --git a/Iphone Detection/requirements.txt b/Iphone Detection/requirements.txt new file mode 100644 index 0000000..0b4caac --- /dev/null +++ b/Iphone Detection/requirements.txt @@ -0,0 +1,270 @@ +# This file may be used to create an environment using: +# $ conda create --name --file +# platform: linux-64 +_ipyw_jlab_nb_ext_conf=0.1.0=py36he11e457_0 +_tflow_select=2.1.0=gpu +absl-py=0.7.1=py36_0 +alabaster=0.7.10=py36h306e16b_0 +anaconda=custom=py36hbbc8b67_0 +anaconda-client=1.6.5=py36h19c0dcd_0 +anaconda-navigator=1.6.9=py36h11ddaaa_0 +anaconda-project=0.8.0=py36h29abdf5_0 +asn1crypto=0.22.0=py36h265ca7c_1 +astor=0.7.1=py36_0 +astroid=1.5.3=py36hbdb9df2_0 +astropy=2.0.2=py36ha51211e_4 +babel=2.5.0=py36h7d14adf_0 +backports=1.0=py36hfa02d7e_1 +backports.shutil_get_terminal_size=1.0.0=py36hfea85ff_2 +beautifulsoup4=4.6.0=py36h49b8c8c_1 +bitarray=0.8.1=py36h5834eb8_0 +bkcharts=0.2=py36h735825a_0 +blas=1.0=mkl +blaze=0.11.3=py36h4e06776_0 +bleach=2.0.0=py36h688b259_0 +bokeh=0.12.10=py36hbb0e44a_0 +boto=2.48.0=py36h6e4cd66_1 +bottleneck=1.2.1=py36haac1ea0_0 +bzip2=1.0.6=h0376d23_1 +ca-certificates=2019.1.23=0 +cairo=1.14.12=h8948797_3 +certifi=2019.3.9=py36_0 +cffi=1.10.0=py36had8d393_1 +chardet=3.0.4=py36h0f667ec_1 +click=6.7=py36h5253387_0 +cloudpickle=0.4.0=py36h30f8c20_0 +clyent=1.2.2=py36h7e57e65_1 +colorama=0.3.9=py36h489cec4_0 +conda=4.6.14=py36_0 +conda-build=3.0.27=py36h940a66d_0 +conda-env=2.6.0=1 +conda-verify=2.0.0=py36h98955d8_0 +contextlib2=0.5.5=py36h6c84a62_0 +cryptography=2.6.1=py36h1ba5d50_0 +cudatoolkit=10.0.130=0 +cudnn=7.3.1=cuda10.0_0 +cupti=10.0.130=0 +curl=7.64.0=hbc83047_2 +cycler=0.10.0=py36h93f1223_0 +cython=0.26.1=py36h21c49d0_0 +cytoolz=0.8.2=py36h708bfd4_0 +dask=0.15.3=py36hdc2c8aa_0 +dask-core=0.15.3=py36h10e6167_0 +datashape=0.5.4=py36h3ad6b5c_0 +dbus=1.13.6=h746ee38_0 +decorator=4.1.2=py36hd076ac8_0 +distributed=1.19.1=py36h25f3894_0 +docutils=0.14=py36hb0f60f5_0 +entrypoints=0.2.3=py36h1aec115_2 +et_xmlfile=1.0.1=py36hd6bccc3_0 +expat=2.2.6=he6710b0_0 +fastcache=1.0.2=py36h5b0c431_0 +filelock=2.0.12=py36hacfa1f5_0 +flask=0.12.2=py36hb24657c_0 +flask-cors=3.0.3=py36h2d857d3_0 +fontconfig=2.13.0=h9420a91_0 +freetype=2.9.1=h8a8886c_1 +fribidi=1.0.5=h7b6447c_0 +gast=0.2.2=py36_0 +get_terminal_size=1.0.0=haa9412d_0 +gevent=1.2.2=py36h2fe25dc_0 +glib=2.56.2=hd408876_0 +glob2=0.5=py36h2c1b292_1 +gmp=6.1.2=hb3b607b_0 +gmpy2=2.0.8=py36h55090d7_1 +graphite2=1.3.13=h23475e2_0 +greenlet=0.4.12=py36h2d503a6_0 +grpcio=1.12.1=py36hdbcaa40_0 +gst-plugins-base=1.14.0=hbbd80ab_1 +gstreamer=1.14.0=hb453b48_1 +h5py=2.7.0=py36he81ebca_1 +harfbuzz=1.8.8=hffaf4a1_0 +hdf5=1.10.1=hb0523eb_0 +heapdict=1.0.0=py36h79797d7_0 +html5lib=0.999999999=py36h2cfc398_0 +icu=58.2=h211956c_0 +idna=2.6=py36h82fb2a8_1 +image-classifiers=0.2.2=pypi_0 +imageio=2.2.0=py36he555465_0 +imagesize=0.7.1=py36h52d8127_0 +intel-openmp=2018.0.0=h15fc484_7 +ipykernel=4.6.1=py36hbf841aa_0 +ipython=6.1.0=py36hc72a948_1 +ipython_genutils=0.2.0=py36hb52b0d5_0 +ipywidgets=7.0.0=py36h7b55c3a_0 +isort=4.2.15=py36had401c0_0 +itsdangerous=0.24=py36h93cc618_1 +jbig=2.1=hdba287a_0 +jdcal=1.3=py36h4c697fb_0 +jedi=0.10.2=py36h552def0_0 +jinja2=2.9.6=py36h489bce4_1 +jpeg=9b=habf39ab_1 +jsonschema=2.6.0=py36h006f8b5_0 +jupyter=1.0.0=py36h9896ce5_0 +jupyter_client=5.1.0=py36h614e9ea_0 +jupyter_console=5.2.0=py36he59e554_1 +jupyter_core=4.3.0=py36h357a921_0 +jupyterlab=0.27.0=py36h86377d0_2 +jupyterlab_launcher=0.4.0=py36h4d8058d_0 +keras=2.2.4=0 +keras-applications=1.0.7=py_0 +keras-base=2.2.4=py36_0 +keras-preprocessing=1.0.9=py_0 +kiwisolver=1.1.0=py36he6710b0_0 +krb5=1.16.1=h173b8e3_7 +lazy-object-proxy=1.3.1=py36h10fcdad_0 +libcurl=7.64.0=h20c2e04_2 +libedit=3.1.20181209=hc058e9b_0 +libffi=3.2.1=h4deb6c0_3 +libgcc-ng=8.2.0=hdf63c60_1 +libgfortran-ng=7.2.0=h9f7466a_2 +libpng=1.6.37=hbc83047_0 +libprotobuf=3.7.1=hd408876_0 +libsodium=1.0.13=h31c71d8_2 +libssh2=1.8.0=h8c220ad_2 +libstdcxx-ng=8.2.0=hdf63c60_1 +libtiff=4.0.10=h2733197_2 +libtool=2.4.6=hd50d1a6_0 +libuuid=1.0.3=h1bed415_2 +libxcb=1.13=h1bed415_1 +libxml2=2.9.9=he19cac6_0 +libxslt=1.1.29=hcf9102b_5 +llvmlite=0.20.0=py36_0 +locket=0.2.0=py36h787c0ad_1 +lxml=4.1.0=py36h5b66e50_0 +lzo=2.10=h1bfc0ba_1 +markdown=3.1=py36_0 +markupsafe=1.0=py36hd9260cd_1 +matplotlib=2.2.2=py36hb69df0a_2 +mccabe=0.6.1=py36h5ad9710_1 +mistune=0.7.4=py36hbab8784_0 +mkl=2018.0.0=hb491cac_4 +mkl-service=1.1.2=py36h17a0993_4 +mock=2.0.0=py36_0 +mpc=1.0.3=hf803216_4 +mpfr=3.1.5=h12ff648_1 +mpmath=0.19=py36h8cc018b_2 +msgpack-python=0.4.8=py36hec4c5d1_0 +multipledispatch=0.4.9=py36h41da3fb_0 +navigator-updater=0.1.0=py36h14770f7_0 +nbconvert=5.3.1=py36hb41ffb7_0 +nbformat=4.4.0=py36h31c9010_0 +ncurses=6.1=he6710b0_1 +networkx=2.0=py36h7e96fb8_0 +nltk=3.2.4=py36h1a0979f_0 +nose=1.3.7=py36hcdf7029_2 +notebook=5.0.0=py36h0b20546_2 +numba=0.35.0=np113py36_10 +numexpr=2.6.2=py36hdd3393f_1 +numpy=1.13.3=py36ha12f23b_0 +numpydoc=0.7.0=py36h18f165f_0 +odo=0.5.1=py36h90ed295_0 +olefile=0.44=py36h79f9f78_0 +openpyxl=2.4.8=py36h41dd2a8_1 +openssl=1.1.1b=h7b6447c_1 +packaging=16.8=py36ha668100_1 +pandas=0.20.3=py36h842e28d_2 +pandoc=1.19.2.1=hea2e7c5_1 +pandocfilters=1.4.2=py36ha6701b7_1 +pango=1.42.4=h049681c_0 +partd=0.3.8=py36h36fd896_0 +patchelf=0.9=hf79760b_2 +path.py=10.3.1=py36he0c6f6d_0 +pathlib2=2.3.0=py36h49efa8e_0 +patsy=0.4.1=py36ha3be15e_0 +pbr=5.1.3=py_0 +pcre=8.43=he6710b0_0 +pep8=1.7.0=py36h26ade29_0 +pexpect=4.2.1=py36h3b9d41b_0 +pickleshare=0.7.4=py36h63277f8_0 +pillow=6.0.0=py36h34e0f95_0 +pip=9.0.1=py36h8ec8b28_3 +pixman=0.34.0=h83dc358_2 +pkginfo=1.4.1=py36h215d178_1 +ply=3.10=py36hed35086_0 +prompt_toolkit=1.0.15=py36h17d85b1_0 +protobuf=3.7.1=py36he6710b0_0 +psutil=5.4.0=py36h84c53db_0 +ptyprocess=0.5.2=py36h69acd42_0 +py=1.4.34=py36h0712aa3_1 +pycodestyle=2.3.1=py36hf609f19_0 +pycosat=0.6.3=py36h14c3975_0 +pycparser=2.18=py36hf9f622e_1 +pycrypto=2.6.1=py36h6998063_1 +pycurl=7.43.0.2=py36h1ba5d50_0 +pyflakes=1.6.0=py36h7bd6a15_0 +pygments=2.2.0=py36h0d3125c_0 +pylint=1.7.4=py36hb9d4533_0 +pyodbc=4.0.17=py36h999153c_0 +pyopenssl=17.2.0=py36h5cc804b_0 +pyparsing=2.2.0=py36hee85983_1 +pyqt=5.6.0=py36h0386399_5 +pysocks=1.6.7=py36hd97a5b1_1 +pytables=3.4.2=py36h3b5282a_2 +pytest=3.2.1=py36h11ad3bb_1 +python=3.6.8=h0371630_0 +python-dateutil=2.6.1=py36h88d3b88_1 +pytz=2017.2=py36hc2ccc2a_1 +pywavelets=0.5.2=py36he602eb0_0 +pyyaml=3.12=py36hafb9ca4_1 +pyzmq=16.0.2=py36h3b0cf96_2 +qt=5.6.3=h8bf5577_3 +qtawesome=0.4.4=py36h609ed8c_0 +qtconsole=4.3.1=py36h8f73b5b_0 +qtpy=1.3.1=py36h3691cc8_0 +readline=7.0=h7b6447c_5 +requests=2.18.4=py36he2e5f8d_1 +rope=0.10.5=py36h1f8c17e_0 +ruamel_yaml=0.11.14=py36ha2fb22d_2 +scikit-image=0.13.0=py36had3c07a_1 +scikit-learn=0.19.1=py36h7aa7ec6_0 +scipy=0.19.1=py36h9976243_3 +seaborn=0.8.0=py36h197244f_0 +setuptools=36.5.0=py36he42e2e1_0 +simplegeneric=0.8.1=py36h2cb9092_0 +singledispatch=3.4.0.3=py36h7a266c3_0 +sip=4.18.1=py36h51ed4ed_2 +six=1.11.0=py36h372c433_1 +snowballstemmer=1.2.1=py36h6febd40_0 +sortedcollections=0.5.3=py36h3c761f9_0 +sortedcontainers=1.5.7=py36hdf89491_0 +sphinx=1.6.3=py36he5f0bdb_0 +sphinxcontrib=1.0=py36h6d0f590_1 +sphinxcontrib-websupport=1.0.1=py36hb5cb234_1 +spyder=3.2.4=py36hbe6152b_0 +sqlalchemy=1.1.13=py36hfb5efd7_0 +sqlite=3.28.0=h7b6447c_0 +statsmodels=0.8.0=py36h8533d0b_0 +sympy=1.1.1=py36hc6d1c1c_0 +tblib=1.3.2=py36h34cf8b6_0 +tensorboard=1.13.1=py36hf484d3e_0 +tensorflow=1.13.1=gpu_py36h3991807_0 +tensorflow-base=1.13.1=gpu_py36h8d69cac_0 +tensorflow-estimator=1.13.0=py_0 +tensorflow-gpu=1.13.1=h0d30ee6_0 +termcolor=1.1.0=py36_1 +terminado=0.6=py36ha25a19f_0 +testpath=0.3.1=py36h8cadb63_0 +tk=8.6.8=hbc83047_0 +toolz=0.8.2=py36h81f2dff_0 +tornado=4.5.2=py36h1283b2a_0 +traitlets=4.3.2=py36h674d592_0 +typing=3.6.2=py36h7da032a_0 +unicodecsv=0.14.1=py36ha668878_0 +unixodbc=2.3.4=hc36303a_1 +urllib3=1.22=py36hbe7ace6_0 +wcwidth=0.1.7=py36hdf4376a_0 +webencodings=0.5.1=py36h800622e_1 +werkzeug=0.12.2=py36hc703753_0 +wheel=0.29.0=py36he7f4e38_1 +widgetsnbextension=3.0.2=py36hd01bb71_1 +wrapt=1.10.11=py36h28b7045_0 +xlrd=1.1.0=py36h1db9f0c_1 +xlsxwriter=1.0.2=py36h3de1aca_0 +xlwt=1.3.0=py36h7b00a1f_0 +xz=5.2.4=h14c3975_4 +yaml=0.1.7=h96e3832_1 +zeromq=4.2.2=hb0b69da_1 +zict=0.1.3=py36h3a3bf81_0 +zlib=1.2.11=hfbfcf68_1 +zstd=1.3.7=h0b5b093_0