TL;DR: Tensorflow fashion mnist example only quicker running on GPU if I increase the number of nodes in the hidden layer.

​

Just spent a good day replacing my AMD gpu with an nvidia one and installing cuda and whatnot. Finally got it working and loaded up Tensorflow’s fashion mnist example, fully expecting training with my new setup to be miles quicker. To my horror, it was slower. Much slower: cpu=12s, gpu=20s.

​

The example only has 128 nodes in the hidden layer. If I increase that to 2048, the gpu is much faster (cpu=162s, gpu=31s). Increasing the number of layers (without changing nodes per layer) results in cpu being faster, even with 10 hidden layers.

​

Is this surprising? What with all the hype around ML with GPUs, I expected it to be way quicker even with relatively few nodes per layer. Is there something wrong with my setup or do you only feel the benefit of the GPU’s parallel computing if you’re using layers with large numbers of nodes?

Hi guys.

We recently open sourced a project, BentoML that packaging and deploying ML models to production. We would love to hear your thoughts.

Quick pitch: From model in Jupyter notebook to production in 5 minutes.

BentoML is a python library for packaging and deploying ML models. It does two things without any changes to your training workflow: 1. It standardize how to package your models, including preprocessing / feature fetching code, dependencies/env, and configuration. 2. It easily distributes your model as Pypi package, API server(local /docker image), CLI tool or spark UDF.

We think there should be a simple way for data scientists to ship models to production. Our vision is empower them to own models ‘end-to-end’ for production service, just like software engineers do.

Here is a quick look of how it works:

In your notebook, you have trained your scikit-learn model: from sklearn import svm from sklearn import datasets

 clf = svm.SVC(gamma='scale') iris = datasets.load_iris() X, y = iris.data, iris.target clf.fit(X, y) 

To package this model with BentoML, you will need to create a new BentoService by subclassing it, and provides artifacts and env definition for it:

 %%writefile iris_classifier.py from bentoml import BentoService, api, env, artifacts from bentoml.artifact import PickleArtifact from bentoml.handlers import DataframeHandler @artifacts([PickleArtifact('model')]) @env(conda_dependencies=["scikit-learn"]) class IrisClassifier(BentoService): @api(DataframeHandler) def predict(self, df): return self.artifacts.model.predict(df) 

Now, to save your trained model for prodcution use, simply import your BentoService class and pack it with required artifacts: from iris_classifier import IrisClassifier

 svc = IrisClassifier.pack(model=clf) svc.save('./saved_bento', version='v0.0.1') # Saving archive to ./saved_bento/IrisClassifier/v0.0.1/ 

That’s it. Now you have created your first BentoArchive. It’s a directory containing all the source code, data and configurations files required to run this model in production.

Couple ways to use this packaged model archive.

Serve the model as local REST API endpoint:

 bentoml serve --archive-path="./saved_bento/IrisClassifier/v0.0.1/" 

Build API server Docker Image from BentoArchive

 $cd ./saved_bento/IrisClassifier/v0.0.1/ $docker build -t myorg/iris-classifier . # After docker build finish $docker run -p 5000:5000 myorg/iris-classifier 

Load your packaged archive in Python:

 import bentoml bento_svc = bentoml.load('./saved_bento/IrisClassifier/v0.0.1/') bento_svc.predict(X[0]) 

Install BentoArchive as PyPI package

 pip install ./saved_bento/IrisClassifier/v0.0.1/ 

Now you can use it as module in your python code

 from IrisClassifier import IrisClassifier installed_svc = IrisClassifier() installed_svc.predict(X[0]) 

Use archived package as CLI tool:

$pip install ./saved_bento/IrisClassifier/v0.0.1/ $IrisClassifier info $IrisClassifier predict --input='./test.csv' 

Alternatively, you can also use the bentoml cli to load and run the package directly:

bentoml predict ./saved_bento/IrisClassifier/v0.0.1/ --input='./test.csv' 

Feel free to ping me and ask any questions. I love to get you guys feedback and improve this project.

Cheers!

edit: formatting

Hi redditors,

​

I am currently working on a project which includes a topic extraction pipeline and now I want to create document embeddings using the Google BERT model instead of good old Tf-Idf. Sadly BERT has a limit on the input size and therefore I cannot push whole texts into it. Now I need to encode each sentence and generate a document feature vector out of it. I had a look at the literature, but that does not seem to be an active research problem. Are you aware of any techniques which encode e.g. the semantic structure of the sequence into such a vector?

I trained a convolutional neural net to recognize latin alphabet characters, and numbers (0-9, A-Z, a-z), then let it predict the category of all characters of a single font, then extracted that into 62 vectors, each describing how the computer sees those pictures of characters. I fed those 62 vectors into a self organizing map.

This is the map I got: map

The CNN had the accuracy of 98-99% (maybe overfitted but idc), and outputs were 128 dimensional vectors, the first layer after flattening. Flattened -> layer -> output layer w 62 categories

Overall I’m pretty happy with how it turned out, here I marked some groups I noticed. Also I think its cool how it separated the curvy from sharp-angled symbols into 2 “main” groups.

This is one of my first machine learning projects, and the first one w SOM’s and CNN’s. Any feedback is appreciated 🙂

Also, I noticed how every time the map is generated, the outlying datapoints are closer to nodes. Specially corners. Does anyone know why would that be? Maybe the data is “spherical”, in it’s 128 dimensions… That recurs every time the map is generated (using random weights initialization)

I did this only to see what I’ll get. I explained that to my mom, saying how it’s interesting but useless. She said “You’ve made a tool, you just have to figure out its use” hahaha. So yea, I have a tool, but I have no idea on what/how to use it. Could you, people of reddit, think of something that would benefit from CNN-SOM hybrids?

Hi r/MachineLearning! Let’s discuss PyTorch best practices.

I recently finished a PyTorch re-implementation (with help from various sources) for the paper Zero-shot User Intent Detection via Capsule Neural Networks, which originally had Python 2 code for TensorFlow.

I’d like to request perhaps a critique on the code I’ve written so far (it’s not perfect, yet!) and any suggestions if there are best practices specifically in PyTorch, for implementing directly from research papers as well as converting them from other frameworks.

Some thoughts I had while programming (feel free to raise more!):

1. I’ve been implementing a Dataset class and custom batch functions for every dataset I’ve been working with. Is this the PyTorch best practice?

2. Where is the optimal place to shift Tensors to .cuda()? I’ve been doing this in the training loop, just before feeding it into the model.

3. How to manage the use of both numpy and torch, seeing as PyTorch aims to reinvent many of the basic operations in numpy?

If you’re a fellow PyTorch user/contributor please share a little!

Hey All,

I’ve recently started a series of Instagram posts showing how we can derive many of the inner workings of deep learning from first principles. I find too many deep learning courses that gloss over fundamentals, and it’s probably due to the industry’s prioritization to churn out workers to train models and produce results quickly. But if we want to master our craft and move behind equations and code with ease, I believe we need to understand the fundamental principles.

Another reason why I’m doing this is because I’m a firm believer of Feynman’s “What I cannot create, I do not understand.” This project is also a way for me to solidify my understanding of deep learning.

Check it out:

https://www.instagram.com/learnsohdeep/

I recently posted this competition we are running; do a 5-min video of any ML paper for a chance to win a prize. Here is an update (link for more details):

1- deadline for submission is April 29th now

2- the first place prize is $400 (+ more prizes)

3- you get points for challenging others to participate (they have to write your name when they submit)

4- you can submit as a team

5- we will hold more office hours to help you figure out any challenges you face

​

Any thoughts, questions, feedback? don’t hesitate to let me know

more detail: https://aisc.a-i.science/5-min-challenge/

The winner of VQA 2017 Challenge, “Bottom-up and Top-down Attention for VQA” is a simple model and used for various researches.

However, there was no tensorflow implementation.

So, I implemented and reproduced the result.

https://github.com/LeeDoYup/bottom-up-attention-tf

What’s going on here? I have not found a single paper that reproduces or compares against the results shown in Table 4 of the original residual network paper. All papers report significantly worse numbers.

​

https://arxiv.org/pdf/1512.03385.pdf

top1 err numbers from the paper:

ResNet-50 @ 20.74

ResNet-101 @ 19.87

ResNet-152 @ 19.38

​

This paper have 20,000+ citations. DenseNet (https://arxiv.org/abs/1608.06993, 3000+ citations) and Wide ResNets (https://arxiv.org/abs/1605.07146, ~1000 citations) don’t use this result. Not even one of Kaiming He’s recent papers (https://arxiv.org/abs/1904.01569) use this result. Since I’m new to the community, maybe I’m missing something here. But isn’t this paper one of the most cited pieces of work in the field??