Analytics Vidhya is a Medium publication where data scientists and students post tutorials and experiments on machine learning and data science.
HN links it for assorted ML and data science write-ups, such as visualizing sudoku backtracking and explaining Google's T5 transformer.
Basically instead of FROM python:3.9, you do FROM scratch. This represents an empty container with nothing.
It's quite easy to use with statically compiled languages, and a bit less so with interpreted ones like Python, but you need to use a multi-step build with first an image containing your dependencies to compile, and then a stage from scratch copying just the resulting artifacts. That way your production image is extremely light and has no attack surface or stuff to update outside of your own code. The main downside is that debugging live is not easy (if you have some networking errors, you can't just exec inside and do some ping/curl/netstat/etc. to check stuff, because you can't even exec inside due to no shell being present), and requires extra tooling like cntr/cdebug or Kubernetes Ephemeral Containers which will attach a fuller container (e.g. busybox) to the running scratch one to be able to debug.
https://chemidy.medium.com/create-the-smallest-and-secured-golang-docker-image-based-on-scratch-4752223b7324
https://medium.com/analytics-vidhya/dockerizing-a-rest-api-in-python-less-than-9-mb-and-based-on-scratch-image-ef0ee3ad3f0a
> The metric is also very human friendly: think of it as 30% of players in the given position, at the given game’s stage and state, successfully continued on to a victory
What I am trying to say is that this is a meaningless piece of information, because that's not how games work. You can't freeze the game state and say "I have a xx% chance to win here", because the state of the game continues evolving over time.
If you were actually estimating your chance to win, it would be a forecast. Except if it's anything like this kind of NN [0], then it is literally just estimating based on a snapshot of game state and not the context of the game. At best, this "win probability" is snapshot estimate of the current game state and has nothing to do with the actual outcome of the game.
This value is also impossible to falsify, so it could be spitting out any random number and you can't say that it's wrong.
[0] https://medium.com/analytics-vidhya/a-simple-neural-network-for-in-game-win-probability-modeling-of-ncaa-basketball-games-58ab4e3ca0f9
Hi all,
This was a fun project exploring the Raspberry Pi Zero W hardware, Go, modern JS APIs, and 3D Printing.
I wanted to be able to get highlights of activity from my birdfeeder, and eventually run an onboard image classifier [0] to figure out which one of my neighbors have not been cleaning up after their dog.
Compared to most other RPi motion detection projects, this runs more efficently by streaming H.264 video instead of MJPEG, and detection is based on motion vectors instead of image difference techniques.
After testing a few other projects in this space, I'd recommend taking a look at PiKrellCam [1] if you really need to pinch CPU cycles on a RPi. For reference PiKrellCam runs at least twice as fast as Sentry-Picam, and has even better motion detection.
[0] https://medium.com/analytics-vidhya/towards-gpu-accelerated-image-classification-on-low-end-hardware-ec592e125ad9
[1] http://billw2.github.io/pikrellcam/pikrellcam.html
If you can’t fit the model on your resources you can leverage DeepSpeed’s ZeRO-offload which will let you train GPT2 on a single V100 (32gb).
Alternatively, if you’re researching (with the caveat that you have to either publish, open source or share your results in a blog post) you can also get access to Google’s TPU research cloud which gives you a few v3-8s for 30 days (can’t do distributed training on devices but can run workloads in parallel). You can also ask nicely for a pod, I’ve been granted access to a v3-32 for 14 days pretty trivially which (if optimized) has more throughput than 8xA100 on transformer models.
TPUs and moreso pods are a bit harder to work with and TF performs far better than PyTorch on them.
https://www.deepspeed.ai/tutorials/zero-offload/
https://medium.com/analytics-vidhya/googles-tpu-research-cloud-free-tpu-hardware-for-deep-learning-projects-7dfecd82b024
>"...Graphics programming has this intriguing concept of 4D vectors used to represent 3D objects..."
Intriguing indeed!
Related:
https://www.popularmechanics.com/science/math/a27737/visualize-higher-dimensions/
https://www.quora.com/What-fields-of-mathematics-deal-with-higher-dimensions-What-are-the-prerequisites
https://medium.com/analytics-vidhya/understanding-the-mathematics-of-higher-dimensions-ab180e0bb45f
https://piggsboson.medium.com/higher-dimensions-for-dummies-147011dc3094
https://www.cs.cmu.edu/~venkatg/teaching/CStheory-infoage/chap1-high-dim-space.pdf
https://encyclopediaofmath.org/wiki/Higher-dimensional_geometry
https://yashkant.github.io/spad/
https://en.wikipedia.org/wiki/Pl%C3%BCcker_embedding
https://en.wikipedia.org/wiki/Grassmannian
It seems like he was one of the people advocating using CUDA for deep learning before Krizhevsky’s big breakthrough in 2012.
Not a primary source: https://medium.com/analytics-vidhya/gpu-for-deep-learning-7f4ef099b702
Alex Krizhevsky’s home page has a bunch of CUDA ConvNet stuff from ~2010
https://www.cs.toronto.edu/~kriz/
Edit: found a better source. Deep learning on GPUs dates to 2005, and Ng’s group has the first GPGPU ConvNet report in 2009, and Krizhevsky has the breakthrough in 2011/2
https://www.deeplearningbook.org/contents/applications.html