Hi All, as a thank you to this community, we’re giving away 5 free tickets to MLconf SF. The event is almost sold out so first to register gets the tickets: https://www.eventbrite.com/e/mlconf-sf-2019-tickets-52641374769

For free registration use code: slashmlfree

Note: The code will expire once the 5 free tickets are registered, they’re gone. First come first served. If the code stops working you may still be able to use to 50% off code: slashml19

*Please don’t share the code, we’re like these tickets to go to community members.

**If you’ve already purchased a ticket, you’re not eligible for a refund.

For video from past events see: https://www.youtube.com/channel/UCjeM1xxYb_37bZfyparLS3Q/videos

Hi, Reddit. I’m excited to share confident learning for characterizing, finding, and learning with label errors in datasets. To promote and standardize future research in learning with noisy labels and weak supervision, I’ve also open-sourced the cleanlab Python package: https://pypi.org/project/cleanlab/

Post: https://l7.curtisnorthcutt.com/confident-learning

Title: Confident Learning: Uncertainty Estimation for Dataset Labels

Abstract: Learning exists in the context of data, yet notions of confidence typically focus on model predictions, not label quality. Confident learning (CL) has emerged as an approach for characterizing, identifying, and learning with noisy labels in datasets, based on the principles of pruning noisy data, counting to estimate noise, and ranking examples to train with confidence. Here, we generalize CL, building on the assumption of a classification noise process, to directly estimate the joint distribution between noisy (given) labels and uncorrupted (unknown) labels. This generalized CL, open-sourced as cleanlab, is provably consistent under reasonable conditions, and experimentally performant on ImageNet and CIFAR, outperforming recent approaches, e.g. MentorNet, by 30% or more, when label noise is non-uniform. cleanlab also quantifies ontological class overlap, and can increase model accuracy (e.g. ResNet) by providing clean data for training.

Paper: https://arxiv.org/abs/1911.00068
Code: https://github.com/cgnorthcutt/cleanlab/

Hello everyone! I’m looking into building a machine learning Excel Add-In. Here is how it works (roughly):

1. Prepare a sheet of training data, one of the columns contain the target or label, other columns are features.
2. Open the add-in. Select relevant columns for training. For each column, choose whether it is categorical or numerical.
3. The data is submitted to a cluster of servers and the servers automatically try different types of models and hyperparameters to produce the most accurate results.
4. Then the user can use the add-in to make predictions on new data in another Excel sheet.

Would this be useful for people who don’t know how to train machine learning models?

Hello!

I have a bunch of video that I have annotated using CVAT. Then I exported the annotation. How can I train (and test) a model based on this using tensorflow?

I’ve done it with images before, but now I’m working with a video file and not a sequence of images, and there is only one annotation file, not one per image.

I was wondering if there is any work that studies the relation of learned weights between two neural nets.

For example, suppose we have a simple regression task, and we trained an MLP with one hidden layer with 20 neurons. If we train another MLP with 15 neurons in the hidden layer, what would the relation of the weight matrices be between these two networks?

I found some related works on neural network compression literature that start with the bigger model and use matrix pruning with factorization and/or decomposition to reach a smaller model. But, I’m not sure if the obtained parameters will be close to the weights a neural network(with the same parameters as the smaller model) will learn if trained from scratch. I mean, the fact that we can use pruning methods and get good accuracy doesn’t necessarily mean that that is the true relation between the bigger model and the smaller one. What do you think?

How Not to Fail Your Machine Learning Interview — Getting an interview is easy, not mucking it up can be hard

https://medium.com/ai%C2%B3-theory-practice-business/how-not-to-fail-your-machine-learning-interview-9545a67b35bc

Hi There! 🍪

2 years into PyTorch-NLP and another 6 months from the previous release, I am releasing PyTorch-NLP 0.5.0. Also, with your help, we’ll break 50,000 downloads! Thank you 🙂 I love helping the community because I myself benefit from the hard work of other open source contributors!

As always, the theme of PyTorch-NLP is to be small, extensible and intuitive much like PyTorch is! And the goal is to extend PyTorch with basic NLP utilities.

Here are the release notes highlights: 🐕

Python 3.5 Support, Sampler Pipelining, Finer Control of Random State

Major Updates

• Updated my README emoji game to be more ambiguous while maintaining fun and heartwarming vibe.
• Support for Python 3.5.
• Extensive rewrite of README.md to focus on new users and building an NLP pipeline. See here.
• Support for Pytorch 1.2.
• Added torchnlp.random for finer grain control of random state building on PyTorch’s fork_rng. This module controls the random state of torch, numpy and random. “`python import random import numpy import torch

from torchnlp.random import fork_rng

with fork_rng(seed=123): # Ensure determinism print(‘Random:’, random.randint(1, 231)) print(‘Numpy:’, numpy.random.randint(1, 231)) print(‘Torch:’, int(torch.randint(1, 2**31, (1,)))) - Refactored `torchnlp.samplers` enabling pipelining. For example: python from torchnlp.samplers import DeterministicSampler from torchnlp.samplers import BalancedSampler

data = [‘a’, ‘b’, ‘c’] + [‘c’] * 100 sampler = BalancedSampler(data, num_samples=3) sampler = DeterministicSampler(sampler, random_seed=12) print([data[i] for i in sampler]) # [‘c’, ‘b’, ‘a’] - Added `torchnlp.samplers.balanced_sampler` for balanced sampling extending Pytorch's `WeightedRandomSampler`. - Added `torchnlp.samplers.deterministic_sampler` for deterministic sampling based on `torchnlp.random`. - Added `torchnlp.samplers.distributed_batch_sampler` for distributed batch sampling that's more extensible and less restrictive than PyTorch's version. - Added `torchnlp.samplers.oom_batch_sampler` to sample large batches first in order to force an out-of-memory error earlier rather than later into training. - Added `torchnlp.utils.get_total_parameters` to measure the number of parameters in a model. - Added `torchnlp.utils.get_tensors` to measure the size of an object in number of tensor elements. This is useful for dynamic batch sizing and for `torchnlp.samplers.oom_batch_sampler`. python from torchnlp.utils import get_tensors

randomobject = tuple([{‘t’: torch.tensor([1, 2])}, torch.tensor([2, 3])]) tensors = gettensors(random_object) assert len(tensors) == 2 “`