This script removes outputs of a given notebook so that you can load smoothly.
This script removes outputs of a given notebook so that you can load smoothly.
This is from my stackoverflow question. Thanks to “bitoiu”. Here is the real thread.
How to pick up a single commit from a remote repo
Assuming you have a local clone of the repo you forked if you type in the following you should get a single origin:
> git show remote origin
Unless you’ve added the original’s repo location, you won’t have access to the commit you want to pick into your local one. So we need to add that, let’s assume this repo ishttps://github.com/GitbookIO/gitbook.git. Notice this is an HTTPS clone URL because you won’t have write access to this repo. Let’s name it original_repo:
> git remote add original_repo https://github.com/GitbookIO/gitbook.git
And now let’s get all the refs back:
> git fetch origina_repo
At this point you have all you need locally, you’ll just need to merge the commit into one of your branches, let’s assume your local master.
Find the commit you want to merge. This implies finding it in one of the branches the team used. Could be already merged to master or you could be picking it up from the branch that was used for the pull request. Either way, just run a series of
git log to check what commit you want if you don’t know the reference. When you do simply go to the branch where you want to merge the commit to and run:
> git cherry-pick COMMIT_ID
This will bring the commit to whatever branch you are at the moment.
How to merge a branch from a remote repo
The only difference in this steps is that instead of doing the cherry-pick you will be doing a merge. So imagine the contents of the pull request are in a branch named
so-pr, you would simply do:
> git merge original_repo/so-pr
And that would merge the contents of
so-pr into your working branch.
# Add the remote, call it "upstream": git remote add upstream https://github.com/whoever/whatever.git # Fetch all the branches of that remote into remote-tracking branches, # such as upstream/master: git fetch upstream # Make sure that you're on your master branch: git checkout master # Rewrite your master branch so that any commits of yours that # aren't already in upstream/master are replayed on top of that # other branch: git rebase upstream/master #If you don't want to rewrite the history of your master branch, (for # example because other people may have cloned it) then you should # replace the last command with However, for making further pull # requests that are as clean as possible, it's probably better to # rebase. git merge upstream/master.
Contractive Auto-Encoder is a variation of well-known Auto-Encoder algorithm that has a solid background in the information theory and lately deep learning community. The simple Auto-Encoder targets to compress information of the given data as keeping the reconstruction cost lower as much as possible. However another use is to enlarge the given input’s representation. In that case, you learn over-complete representation of the given data instead of compressing it. Most common implication is Sparse Auto-Encoder that learns over-complete representation but in a sparse (smart) manner. That means, for a given instance only informative set of units are activated, therefore you are able to capture more discriminative representation, especially if you use AE for pre-training of your deep neural network.
After this intro. what is special about Contraction Auto-Encoder (CAE)? CAE simply targets to learn invariant representations to unimportant transformations for the given data. It only learns transformations that are exactly in the given dataset and try to avoid more. For instance, if you have set of car images and they have left and right view points in the dataset, then CAE is sensitive to those changes but it is insensitive to frontal view point. What it means that if you give a frontal car image to CAE after the training phase, it tries to contract its representation to one of the left or right view point car representation at the hidden layer. In that way you obtain some level of view point in-variance. (I know, this is not very good example for a cannier guy but I only try to give some intuition for CAE).
From the mathematical point of view, it gives the effect of contraction by adding an additional term to reconstruction cost. This addition is the Sqrt Frobenius norm of Jacobian of the hidden layer representation with respect to input values. If this value is zero, it means, as we change input values, we don’t observe any change on the learned hidden representations. If we get very large values then the learned representation is unstable as the input values change.
This was just a small intro to CAE, if you like the idea please follow the below videos of Hugo Larochelle’s lecture and Pascal Vincent’s talk at ICML 2011 for the paper.
Here is the G. Hinton’s talk at MIT about t inabilities of Convolutional Neural Networks and 4 basic arguments to solve these.
I just watched it with a slight distraction and I need to reiterate. However these are the basic arguments in which G. Hinton is proposed whilst the speech.
1. CNN + Max Pooling is not the way of handling visual information as the human brain does. Yes, it works in practice for the current state of the art but, especially view point changes of the target objects are still unsolved.
2. Apply Equivariance instead of Invariance. Instead of learning invariant representations to the view point changes, learn changing representations correlated with the view point changes.
3. In the space of CNN weight matrices, view point changes are totally non-linear and therefore hard to learn. However, if we transfer instances into a space where the view point changes are globally linear, we can ease the problem. ( Use graphics representation uses explicit pose coordinates)
4. Route information to right set of neurons instead of unguided forward and backward passes. Define certain neuron groups ( called capsules ) that are receptive to particular set of data clusters in the instance space and each of these capsules contributes to the whole model as much as the given instance’s membership to neuron’s cluster.
We already discussed first four steps of ML work-flow. So far, we preprocessed crude data by DICTR (Discretization, Integration, Cleaning, Transformation, Reduction), then applied a way of feature extraction procedure to convert data into machine understandable representation, and finally divided data into different bunches like train and test sets . Now, it is time to preprocess feature values and make them ready for the state of art ML model ;).
We need Feature Preprocessing in order to:
You may ask “Why are we so concerned about these?” Because
Okay, I hope now we are clear why we are concerned about these. Henceforth, I’ll try to emphasis some basic stuff in our toolkit for feature preprocessing.
: for each dimension (instance), subtract the mean and divide by the variance of that dimension (instance) so that each dimension is kept inside a mean = 0 , variance = 1 curve.
Min Max Scaling
: Find max and min values of the feature dimension and apply the formula.
Caveat 1: One common problem of Scaling and Standardization is you need to keep min and max for Scaling, mean and variance values for Standardization for the novel data and the test time. We estimate these values from only the training data and assume that these are still valid for the test and real world data. This assumption might be true for small problems but especially for online environment this caveat should be dealt with a great importance.
Caveat 2: How to choose and what to choose are very problem dependent questions. However, if you have a clustering problem then standardization seems more reasonable for better similarity measure between instance and if you intend to use Neural Networks then some particular kind of NN demands [0,1] scaled data (or even more interesting scale ranges for better gradient propagation on the NN model). Also, I personally use sigmoid function for simple problems in order to get fast result by SVM without complex investigation.
Zero Phase Component Analysis (ZCA Whitening)
I tried to touch some methods and common concerns of feature preprocessing, by no means complete. Nevertheless, a couple of takeaways from this post are; do not ignore normalizing your feature values before going into training phase and choose the correct method by investigating the values painstakingly.
PS: I actually promised to write a post per week but I am as busy as a bee right now and I barely find some time to write a new stuff. Sorry about it 🙁
I always stumble upon questions that request a way of computing prediction probabilities through LinearSVC model of Sklearn. I am also the one of these people :). Here I come up with a simple subclass of LinearSVC model predicting probabilities by Platt’s scaling.
I’ve read a great paper by Delgado et al. namely “Do we Need Hundreds of Classifiers to Solve Real World Classication Problems?” in which they compare 179 different classifiers from 17 families on 121 data sets composed by the whole UCI data base and some real-world problems. Classifiers are from R with and without caret pack, C and Matlab (I wish I could see Sklearn as well).
I really recommend you to read the paper in detail but I will share some of the highlights here. The most impressive result is the performance of Random Forests (RF) Implementations. For each dataset, RF is always at the top places. It gets 94.1% of max accuracy and goes by 90% in the 84.3% of the data sets. Also, 3 out of 5 best classifiers are RF for any data set. This is pretty impressive, I guess. The runner-up is SVM with Gaussian kernel implemented in LibSVM and it archives 92.3% max accuracy. The paper points RF, SVM with Gaussian and Polynomial kernels, Extreme Learning Machines with Gaussian kernel, C5.0 and avNNet (a committe of MLPs implemented in R with caret package) as the top list algorithms after their experiments.
One shortcoming of the paper, from my beloved NN perspective, is used Neural Network models are not very up-to-date versions such as drop-out, max-out networks. Therefore, it is hard to evaluate algorithms against these advance NN models. However, for anyone in the darn dark of algorithms, it is a quite good guideline that shows the power of RF and SVM against the others.