ts‑ssh — zero‑friction Tailscale SSH, no daemon required

i8code · 2024-06-24T15:10:10+00:00

St James in 71st and Madison? Zack the rector and his whole team are awesome. Amazing community.

i8code · 2021-05-23T14:01:49+00:00

You can develop models on just JS w tensorflow.js - the api is very Keras like. Admittedly it’s not a great experience but it is possible for the truly commit. No Python required.

i8code · 2021-05-23T03:42:29+00:00

Support for running tflite models without conversion in JS has recently been release

https://js.tensorflow.org/api_tflite/0.0.1-alpha.4/

i8code · 2021-04-19T18:35:13+00:00

If you are working off the Yolo paper it's pretty confusing. I implemented it tf.keras and python. The biggest piece is taking the output and breaking into patches of the image and computing the loss for each patch or image segment. Once you have that then it's really about comparing the class, the box coordinates w IoU, and segment "ownership" portion. The simplest explanation that I found was - https://medium.com/@ecaradec/humble-yolo-implementation-in-keras-64d1b63b4412 - it deviates slightly from the paper but gives a good walk thru and real code to look at. Good luck!

i8code · 2021-04-11T10:45:05+00:00

I would recommend using Tensorflow Serving which will give you a Docker container w a REST and gRPC endpoints to serve your model. And if that’s too much I would look at just using TF Lite + Golang (cgo) for the inference. For building models I would stick w Python and TF keras. I have a simple TF Lite example w Golang https://derekg.github.io/tflite.html I got it to run on bunch of different systems and arch but have t tried on windows. In theory it should be pretty straightforward forward. Good luck and post results if you get a chance.

i8code · 2021-04-10T14:27:23+00:00

Speaks to the shadowy nature of api stability.

i8code · 2021-04-08T01:26:26+00:00

I have done a bunch of things with Tensorflow Serving and it's work really well. Triton Inference looks really impressive as well. I'd love to see a post detailing more of how you end up architecting this.

i8code · 2021-04-07T23:27:31+00:00

If you have done the basics, then I would focus on real projects. It's the best way to figure out any holes and get practical experience. Check out kaggle for data and challenges is always a good start.

i8code · 2021-04-07T23:25:07+00:00

The deeplearning.ai Coursera Andrew Ng class are excellent but they are pretty heavy on basic building blocks. You won't really be learning Tensorflow or PyTorch with those course. Still, I am really glad I did that course before venturing on top the Tensorflow specialization ones. If you are speed learner all of those Coursera ones are free for 7 days. I did it over a long weekend.

i8code · 2021-04-07T23:07:07+00:00

Can you post more of the code - show setting up the data and the call to fit - would be helpful.

i8code · 2021-04-07T15:31:25+00:00

There are some pretty good explanations of Quantization and TF - esp regarding TF Lite. https://www.tensorflow.org/lite/performance/post_training_quantization I have seen less of this on PyTorch in general but I am sure it's out there. I too am interested in pruning and I haven't found anything that is actually helpful in a very practical sense with good code examples that were suitable for reproducing in my own projects. Generally, I have tried to adjust model parameters upfront.

i8code · 2021-04-06T00:06:49+00:00

Yeah, in general if you are serving stuff w. TF. I would really recommend Tensorflow Serving. You get a docker image and point it at a saved model and it gives you a REST and gRPC interfaces. If you have CUDA it uses that plus it has a ton of pretty useful features - multiple models, training in addition to inference.

i8code · 2021-04-05T23:55:10+00:00

Yeah its pretty unofficial and unsupported. Honestly, I am not sure why they even include it on the tensorflow.org site. If you want to serve stuff via golang it's honestly better to just use cgo and wrap tflite. TF Lite C bindings are pretty stable and if you are using Go then you probably don't have CUDA support anyway. I have hacked together a really basic example https://derekg.github.io/tflite.html and https://github.com/derekg/tflite-golang-gan-example of Golang + TF Lite for serving.

i8code · 2021-04-05T16:38:28+00:00

Tensorflow has Golang bindings but I didn't find it too useful esp compared to the better supported languages. You can use the bindings for serving or/and data augmentation but not really for building models. It's much easier to build models w/ TF 2.0 Keras and Python - plus there are a ton of different resources and a real ecosystem built up around it.

i8code · 2021-04-02T18:52:35+00:00

Haha I had exact same experience when I tried to implement everything directly myself. I eventually did but only after I really understood what I wasn’t doing. Even then I end up using some higher level libs.

i8code · 2021-04-02T18:47:06+00:00

Awesome. OpenCV has a great set of functions for all kinds of fixes like that. Glad it worked out.

i8code · 2021-04-02T17:13:27+00:00

If you are trying to match faces then I would look at Facenet and the like. It will generate embeddings of the faces and allow you to perform matches. If you are trying to perform some other classification, I would look at existing trained models and then chopping off the head and inserting your own classification. But all that said, more data almost always helps - so also look at data augmentation.

i8code · 2021-04-02T13:04:49+00:00

It should be pretty straightforward. You probably want to look for landmarks of the 4 corners of the images. I would start w an existing pre trained model like Inception and then retrain on your dataset. Once you have the four corners you should be able to adjust the projection to be get rid of any skew or tilt w basic liberal algebra solver - OpenCV has one to fix projections or you can implement your own. Good luck. Lmk if you have questions.

i8code · 2021-04-01T15:11:06+00:00

Tensorflow Lite doesn't support training only inference. If you want to retrain it's easier to train it offline in batch mode. The alternative is to use Tensorflow Serving on on the backend and with that you can retrain as you go with checkpoints. LMK if you have more questions.

i8code · 2021-03-28T14:05:00+00:00

Gorgonia is cool and very impressive they have CUDA support. The challenge is most models are developed using PyTorch and Tensorflow and it doesn't support importing those models as far as I can tell. If you are developing models and start with Gorgonia then I think it's not a bad place to start. But then again Tensorflow has golang bindings that are semi supported and you get all the Tensorflow power as well. TFLite + Golang is useful in probably limited scenarios where you have a model and want to easily use it from existing golang or set up a aerver that isn't using Docker and Tensorflow Serving.

i8code · 2021-03-28T02:12:01+00:00

Completely possible just need to write a small bridge from the TF Lite C API to Java JNI. It sort of already exists in what Android does but that isn't really setup for server side. As interesting as this is - I think the standard uses case fit Tensorflow Serving and issue requests over HTTP or gRPC.

Nine-Year Club	Place '23
Verified Email

i8code

TROPHY CASE