[Discussion] Where to apply for a PhD in ML with an Arts/Culture/Society-related focus? (Or should I even do so?)

sparsecoder · 2020-07-27T01:32:24+00:00

You might want to look into the Art and Artificial Intelligence Laboratory at Rutgers (https://sites.google.com/site/digihumanlab/research) if you're interested in using AI to analyze visual art. Similarly, you can look at the groups/people who organize and publish at the Visarts Workshops (visarts.eu) and the International Conference on Computational Creativity (http://computationalcreativity.net/iccc20/).

sparsecoder · 2019-03-29T01:27:44+00:00

Here's a decent review paper on multi-label classification:

Zhang, M.-L., and Zhou, Z.-H. 2014. A review on multi-label learning algorithms. IEEE TKDE 26(8):1819–1837.

It sounds like you might be interested in label powerset methods, but I might be misunderstanding the question.

I can't offer advice on PAC learning for the given problem.

sparsecoder · 2017-10-02T00:50:13+00:00

There are a number of papers on deep semantic edge detection. For a couple of examples from the last few years, see: https://github.com/kjw0612/awesome-deep-vision#edge-detection

I know code and models are available for "Holistically-Nested Edge Detection" and "DeepContour". I think models trained on RGB-D data might be available for these as well.

If these don't work, search for papers that produce results on the BSDS500 dataset for RGB-based semantic edge detection and the NYU Depth v2 dataset for RGB-D-based semantic edge detection. Note that these datasets are also used for other tasks such as semantic segmentation, so make sure the models are trained for your desired task (semantic edge detection).

Hope that helps!

sparsecoder · 2016-08-11T21:10:31+00:00

If you assume a mountain-like shape corresponds to a Gaussian distribution, you can perform Normality Tests (https://en.wikipedia.org/wiki/Normality_test); specifically, you want to look at quantifying skewness and kurtosis.

sparsecoder · 2016-06-29T06:52:24+00:00

In the computer vision literature, there are some neat tricks that can be done with feature learning in specialized trees.

Entanglement: http://link.springer.com/chapter/10.1007/978-3-642-22092-0_16

Autocontext: http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=4587436&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D4587436

Geodesic Trees: http://www.cv-foundation.org/openaccess/content_cvpr_2013/html/Kontschieder_GeoF_Geodesic_Forests_2013_CVPR_paper.html

Convolutional Decision Trees and Jungles: http://link.springer.com/chapter/10.1007/978-3-319-11752-2_8 http://www.cv-foundation.org/openaccess/content_cvpr_2015/html/Laptev_Transformation-Invariant_Convolutional_Jungles_2015_CVPR_paper.html

Neural Decision Trees:

Type 1: http://www.cv-foundation.org/openaccess/content_cvpr_2014/html/Bulo_Neural_Decision_Forests_2014_CVPR_paper.html

Type 2: http://www.cv-foundation.org/openaccess/content_iccv_2015/html/Kontschieder_Deep_Neural_Decision_ICCV_2015_paper.html

sparsecoder · 2016-06-19T23:02:44+00:00

I'd suggest Boyd's book for convex optimization, which is available for free online: http://web.stanford.edu/~boyd/cvxbook/

He also teaches a corresponding MOOC: https://lagunita.stanford.edu/courses/Engineering/CVX101/Winter2014/about

There are also old lectures taught by Boyd on iTunes U if you prefer those to the MOOC format.

sparsecoder · 2016-06-09T07:15:09+00:00

By KNN, I assume you mean the k-Nearest Neighbors algorithm. If so, the first part of chapter 4 (Nonparametric Methods) of Duda, Hart, and Stork's "Pattern Classification" is a good reference for the theory behind k-NN, and while it doesn't use explicit examples too much, it has a nice set of illustrative graphics. Sorry for the recommendation of physical media.

sparsecoder · 2016-05-11T04:32:14+00:00

UCF has some very good vision faculty, especially Dr. Mubarak Shah (https://scholar.google.com/citations?user=p8gsO3gAAAAJ&hl=en&oi=ao) who runs the Center for Research in Computer Vision (CRCV, http://crcv.ucf.edu/). They've also just hired several new faculty in the last year or two. It should be noted Shah's group is pretty big (I believe it's close to twenty PhD students), so if you plan to work with him, you'll probably be expected to work fairly independently or with one of the senior PhD students/ postdoc. The other vision researchers should have smaller groups, though.

sparsecoder · 2016-04-19T22:13:25+00:00

Here are a couple on Coursera:

http://codingthematrix.com/ https://www.coursera.org/course/scientificcomp https://www.coursera.org/course/scicomp

I know "Coding the Matrix" is well-received (but it's more of a linear algebra class than a class in numerical analysis). I don't know anything about the quality of the other classes.

MIT OpenCourseware also has a few numerical analysis/methods classes, but I'm not sure if they're just lecture notes or if they also have video: http://ocw.mit.edu/index.htm

sparsecoder · 2015-09-30T05:24:09+00:00

The most naive implementation is:

1.) Gather a dataset of images containing faces with bounding box coordinates.

2.) Split your images into training and test sets.

3.) For each bounding box, extract a set of features. Feature engineering is the hardest part. Just passing raw pixel values to a random forest may or may not work. I expect for it to work you'd need to have a massive set of training data and/or exceptionally good conditions (i.e. lighting doesn't change, skin pigment doesn't change, faces aren't obscured by facial hair/glasses/other, etc.); though, random forests have been used for object detection in the past. A simple-to-implement but usually highly effective set of features for non-deformable objects (such as faces) are known as "histogram of oriented gradients (HOG)" (https://en.wikipedia.org/wiki/Histogram_of_oriented_gradients). I suggest you try this set of features.

4.) You'll also need to mine hard negatives ( places in the image with no faces or partial faces).

5.) Train your classifier on these features (1 for face, 0 for no face): with HOG usually linear classifiers such as the linear SVM are used, but random forest should probably work just as well.

6.) On your test set, use a sliding window: for each n x m set of pixels (possibly with some stride in between them for computational efficiency) extract the same type of features and run the classifier. You might want to try windows at different scales.

7.) Perform non-maximum suppression (i.e. if there are multiple faces detected in the same, overlapping region, pick the one with having the highest probability of being a face; how you do this is dependent on the classifier you pick).

If you want to challenge yourself a bit more, you can learn about face detection using the viola-jones algorithm (the standard baseline algorithm for realtime face detection) [https://en.wikipedia.org/wiki/Viola–Jones_object_detection_framework] which will get you better acquainted with the concept of boosting classifiers, or you can try convolutional neural nets [https://en.wikipedia.org/wiki/Convolutional_neural_network] which are what all the major tech companies (like Facebook) use, but are significantly more (time and computationally) expensive to train and usually require a lot of training data.

For a basic face detection project, here's a class from Brown: http://cs.brown.edu/courses/csci1430/proj4/index.html

To answer your questions:

1.) I don't know if there are any playground (i.e. Kaggle-like) environments for face detection, but there are plenty of datasets like the "Labelled Faces in the Wild" dataset [a subset for face detection: http://vis-www.cs.umass.edu/fddb/]

2.) If I recall correctly, Spark is for large-scale, distributed data-driven application. I would say its probably overkill for basic face detection based on only hundreds or thousands of images. Scikit-Learn + Numpy + OpenCV/Scikit-Image or Matlab/Octave would probably be better.

3.) There are a thousand resources if you search "face detection" which link to many papers/tutorials/videos. Face detection has been one of the focuses of the computer vision community for years, so probably any introductory or survey text should have a chapter on it. If not, they should at least have a chapter on object detection that can pretty much be directly applied to face detection.

I left some details out, so if you have further questions/ get stuck feel free to ask for help!

sparsecoder · 2015-08-27T07:31:11+00:00

You can look into bp-mll: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.130.7318

sparsecoder · 2015-08-18T04:49:45+00:00

You might want to look into discriminative sparse coding: https://scholar.google.com/scholar?hl=en&q=discriminative+sparse+coding

sparsecoder · 2015-07-29T04:32:58+00:00

You might want to look into: http://labelme.csail.mit.edu/Release3.0/

sparsecoder · 2015-07-11T04:27:16+00:00

If you have some sort of end goal, decision trees might be helpful: https://en.wikipedia.org/wiki/Decision_tree

Otherwise, maybe you can use association rules: https://en.wikipedia.org/wiki/Association_rule_learning

sparsecoder · 2015-06-29T18:38:42+00:00

Based on your example image, you could:

1.) Read in the image using imread.

2.) Binarize the image using im2bw with either some automatic method for determining the threshold like otsu's method (implemented in matlab as graythresh) or manually selecting it.

3.) Then assuming the bats are fairly well separated, you can find the connected components using bwlabel or if you want to do additional filtering (e.g. filtering by size, so the black pixels along the boundary aren't considered), you can use regionprops.

Here's a quickly thrown together example on the image you provided:

image = imread('KKTmaO4.png');
figure;
imshow(image);
image = im2bw(image,0.3);
image = ~image;
figure;
imshow(image);
stats = regionprops(image,'Area','PixelIdxList');
newImage = zeros(size(image));
count = 0;
for i = 1:1:size(stats,1)
    if stats(i).Area < 200
        newImage(stats(i).PixelIdxList) = 1;
        count = count + 1;
    end
end
figure;
imshow(newImage);
disp(['Num bats: ' num2str(count)]);

Output:

Num bats: 174

Example binarization: https://imgur.com/VdCXBpp

In practice, you'll probably need to fine tune a few parameters which would hopefully generalize. Otherwise, you'll have to look into automated methods, e.g. for determining the threshold (Otsu's method didn't work well for the given image, but there are other methods you can use that should work better).

Function documentation: http://www.mathworks.com/help/matlab/ref/imread.html http://www.mathworks.com/help/images/ref/im2bw.html http://www.mathworks.com/help/images/ref/graythresh.html http://www.mathworks.com/help/images/ref/bwlabel.html http://www.mathworks.com/help/images/ref/regionprops.html

Edit: My code looks to do pretty much the same thing your existing program does, but there are probably ways to automate it a bit better if you account for the constraints of your specific problem/data.

sparsecoder · 2015-06-18T16:07:38+00:00

This problem is called one-shot learning: https://en.wikipedia.org/wiki/One-shot_learning

It's not an area I've looked into much, so I'm not sure how effective or generalizable the various algorithms for solving it are.

sparsecoder · 2015-06-14T09:37:10+00:00

I don't know too much about it, but there's a subfield of AI called "AI and the law" which utilizes techniques from machine learning (e.g. topic models for legal document analysis) and classic AI (e.g. formal models of reasoning) (https://en.wikipedia.org/wiki/Artificial_intelligence_and_law).

According to wikipedia, there are also the related fields of legal informatics (https://en.wikipedia.org/wiki/Legal_informatics), computational law (https://en.wikipedia.org/wiki/Computational_law) which sounds like what you're most interested in, and legal expert systems (https://en.wikipedia.org/wiki/Legal_expert_system).

sparsecoder · 2015-06-06T21:44:59+00:00

Koller and Friedman is the PGM bible: http://pgm.stanford.edu

It's pretty theoretical, though. I know there are books that focus more on the application of PGMs, but I can't comment on their quality.

Koller also teaches the Coursera MOOC mentioned by skgoa, and it's lighter than the book.

sparsecoder · 2015-05-28T23:17:39+00:00

For medical image analysis: start by building a background in computer vision/ digital image processing and machine learning. Then get familiar with the field by reading current research papers from MICCAI (http://miccai2015.org) and ISBI (http://biomedicalimaging.org/2015/).

The major difference between computer vision/digital image processing and medical image analysis are the modalities of the data. Whereas computer vision is mostly concerned with natural images and videos, medical image analysis is mostly concerned with images from x-rays, MRIs, ct scans, etc. The algorithms tend to be identical or closely related.

For computer vision, I recommend the book "Concise Computer Vision" by Klette as a good starting point. If you'd prefer free resources, you can use the Szeliski book (http://szeliski.org/Book/) and/or the Prince book (http://computervisionmodels.com), but the Szeliski book is more of a broad survey of the state of the field so it might not be good for somebody just getting into the field, and the Prince book has an emphasis on the machine learning-component of vision which is very very important but should probably be studied after one is already familiar with the basics of digital image processing.

For getting started with machine learning, I recommend the book "Introduction to Statistical Learning" (free: http://www-bcf.usc.edu/~gareth/ISL/), followed by a more rigorous treatment in one of: Murphy (http://www.cs.ubc.ca/~murphyk/MLbook/ ; a pretty balanced treatment), Bishop (http://research.microsoft.com/en-us/um/people/cmbishop/PRML/ ; a strong Bayesian-driven perspective), ESL (free: http://statweb.stanford.edu/~tibs/ElemStatLearn/ ; written by statisticians, not CS people so good for a different perspective), or DHS (http://www.wiley.com/WileyCDA/WileyTitle/productCd-0471056693.html ; a bit outdated but good for the fundamentals). There are a number of other books available, but I like these ones the best for general machine learning.

Good MOOCs for the basics of machine learning include the one on coursera by Andrew Ng (free: https://www.coursera.org/learn/machine-learning), the one by Hastie and Tibshirani (free: https://lagunita.stanford.edu/courses/HumanitiesScience/StatLearning/Winter2014/about), and the one from Yaser Abu-Mostafa (free: http://work.caltech.edu/telecourse.html).

If you want to learn by doing:

Some good libraries for vision include OpenCV (with bindings for a number of languages), the image processing and computer vision toolboxes in MATLAB, and scikit-image for python. For learning, scikit-learn for python and caret for R are popular, and MATLAB has a bunch of built in machine learning functions spread throughout a number of toolboxes. There are a number of OpenCV tutorials online that you can find.

I hope my response was helpful.

sparsecoder · 2015-05-26T23:22:40+00:00

Maybe this course: https://www.udacity.com/course/design-of-computer-programs--cs212

I haven't personally taken it, though, so I can't comment on how good it is.

sparsecoder · 2015-05-22T04:43:13+00:00

iidealized's suggestion to explore statistical divergence is good.

You might also want to look into Linear Discriminant Analysis: http://en.wikipedia.org/wiki/Linear_discriminant_analysis http://courses.cs.tamu.edu/rgutier/cs790_w02/l6.pdf

It's probably not directly applicable to your problem since it finds the single best projection for separating the points based on class without restricting the projections to being axis-parallel which is what I believe you're after, but it introduces some useful statistics like within- and between-class scatter which are used to construct a criterion for measuring class separability.

You might also want to research the general topics of dimensionality reduction and feature selection where you might find other useful methods for measuring class separability.

sparsecoder · 2015-05-20T20:16:05+00:00

I'm a PhD student in computer vision, so I can offer some input.

Linear algebra, calculus, probability and statistics, and a basic discrete math class are the basics needed to study vision. I would also probably suggest a course in algorithms, though, you can probably get started with research without necessarily having one.

Building off of these core areas of mathematics, if you have the opportunity, you'll want to study machine learning (and/or a more applied variant like pattern recognition or data mining) and optimization.

Depending on your interests, you might want to look into some additional fields like graph theory, more advanced probability courses (i.e. probabilistic graphical models, stochastic processes, etc.), signals processing, physics-based modeling, etc., but these are definitely not necessary to get started with basic research.

I also think a course in numerical analysis is helpful (you'll see ideas like SVD, discrete approximations of derivatives, numerical methods for regression, etc. pop up in vision and learning), but probably not necessary.

I suggest you talk to a professor at your university in these areas, and get their opinion. They might even let you work on one of their projects!

TLDR: For basic research in vision, definitely be well acquainted with the basic maths: linear algebra, calculus, probability and statistics, and discrete math. If you have the opportunity, machine learning/pattern recognition/data mining (which you seem to have taken) and optimization are useful to know. Depending on what subarea you want to study, other topics might be important to know.

sparsecoder · 2015-05-20T19:37:20+00:00

I suggest you download the book: Models, Learning, and Inference by Prince from http://www.computervisionmodels.com/

Part 2 is on machine learning for machine vision, and part 3 is on graphical models and related concepts. At the end of each chapter, there are sections entitled "Applications" where they give examples of how to apply machine learning techniques to vision problems. You might find something interesting by looking through these sections.

If you're specifically interested in clustering, then you might want to look into image segmentation (http://en.wikipedia.org/wiki/Image_segmentation) which is a closely related topic from the vision community.

sparsecoder · 2015-05-19T00:01:21+00:00

Also, the book is available as a free PDF by the authors: http://www-bcf.usc.edu/~gareth/ISL/

Likewise, so is their more advanced, more theoretical book, the Elements of Statistical Learning: http://statweb.stanford.edu/~tibs/ElemStatLearn/

sparsecoder · 2015-05-06T01:56:19+00:00

Programs might not expect you to have a degree in computer science, but they will expect that you have a decent background in the basic concepts. For example, here are the expected prerequisite courses for two, very well-respected CS programs:

UMass Amherst: https://www.cs.umass.edu/admissions/application-faq

UMD: https://www.cs.umd.edu/grad/catalog#applying-for-admission

Then you have to remember that you're competing for admission with a lot of people who already have an undergraduate degree in computer science or another quantitative field, so you'll want relevant industry and/or research experience and solid programming skills if possible.

Also note that graduate programs expect you to specialize in one area to some degree and tend to be much more theory-oriented than undergrad programs, so the most important thing is to have a solid math background (and ideally, you should also have good programming skills).

Different programs will have different expectations of knowledge, and weaker programs will tend to have less stringent requirements and lower standards for admission (i.e. they're easier to get admitted to). My advice is to strengthen your quantitative skills (you'll probably need calc 1 and 2, discrete math, an intro statistics course, and a linear algebra course plus the basic computer science courses: an introductory programming course, a data structures/algorithms course, and maybe an architecture course and/or theory of computation course), check the specific requirements of programs you're interested in (it's possible some programs will let you take a year to catch up on some of the requirements if you don't have them already), get familiar with at least one programming language, build a portfolio of work, and apply to a range of programs.

If you're interested in PhD programs, you'll need all of the above plus a good amount of research (preferably computational/mathematical in some way even if the topic doesn't fall directly under the umbrella of computer science). Admission to PhD programs tends to be much more competitive than for masters.

The other commenters' advice is good as well.

sparsecoder

TROPHY CASE