At ruumi we are building grassland and grazing management tools to give farmers actionable insights on how to manage their land sustainably and reduce their carbon emissions.
We are hiring for various roles
1. Engineers for web apps; React, TypeScript, Express, Postgres
2. Engineers for iOS and Android; Swift, SwiftUI, Jetpack, Jetpack Compose
3. Product owner for our apps and tools for farmers and carbon emissions
To apply see https://robofarm.jobs.personio.com or mail us at [email protected] and include your favorite animal emoji in the subject.
Learn more
- https://www.youtube.com/watch?v=fSEtiixgRJI
- https://www.imdb.com/title/tt8618654/
In the style of "Scalability! At What COST?" I've started a side-project bringing succinct data structures (rank/select [2], elias-fano coding) and modern instruction sets (popcount, pdep) to graphs.
For some reason the article doesn't mention the field of graph compression and I think it shows: for example most if not all popular open source routing engines don't do anything regarding graph compression. It's time to change that! Reach out to me (preferably on the Github project) if you want try some ideas :)
[1] https://tinygraph.org [2] http://www.cs.cmu.edu/~dga/papers/zhou-sea2013.pdf
At ruumi we help farmers with rotational grazing: a managed grazing technique that regenerates soil, increases biodiversity, minimizes agro-chemicals, sequesters carbon, and improves profitability at the same time.
We are bringing multi-spectral and radar satellite imagery, geo-spatial tech, and machine learning to regenerative agriculture. We tell farmers actionable insights for example: when and where to move their animals to maximize soil regeneration and carbon sequestration.
We are looking for someone to work with us on our applications, with a strong focus on iOS.
Check out https://www.notion.so/ruumi/ruumi-jobs-86745c0df9834395b27f0... https://eng.ruumi.io and send me your favorite animal emoji!
At ruumi we help farmers with rotational grazing: a managed grazing technique that regenerates soil, increases biodiversity, minimizes agro-chemicals, and improves profitability at the same time.
We are bringing multi-spectral and radar satellite imagery, geo-spatial tech, and machine learning to regenerative agriculture. We tell farmers actionable insights for example: when and where to move their animals to maximize soil regeneration.
We are looking for someone to work with us on web and mobile applications. For the frontend we are using Typescript, React and Redux; for the backend we are using Typescript and Express.js.
Check it out! https://www.notion.so/ruumi-jobs-86745c0df9834395b27f018fec8... and https://eng.ruumi.io
At ruumi we help farmers with rotational grazing: a managed grazing technique that regenerates soil, increases biodiversity, minimizes agro-chemicals, and improves profitability at the same time.
We are bringing multi-spectral and radar satellite imagery, geo-spatial tech, and machine learning to regenerative agriculture. We tell farmers actionable insights for example: when and where to move their animals to maximize soil regeneration.
We are looking for someone to work with us on web and mobile applications. For the frontend we are using Typescript, React and Redux; for the backend we are using Typescript and Express.js.
Check it out! https://www.notion.so/ruumi-jobs-86745c0df9834395b27f018fec8... and https://eng.ruumi.io
We are looking for someone to work with us on web and mobile applications. For the frontend we are using Typescript, React and Redux; for the backend we are using Typescript and Express.js.
At ruumi we help farmers with rotational grazing: a managed grazing technique that regenerates soil, increases biodiversity, minimizes agro-chemicals, and improves profitability at the same time.
We are bringing multi-spectral and radar satellite imagery, geo-spatial tech, and machine learning to regenerative agriculture. We tell farmers actionable insights for example when and where to move their animals to maximize soil regeneration.
Check it out at http://jobs.ruumi.io
We are looking for someone to work with us on web and mobile applications. For the frontend we are using Typescript, React and Redux; for the backend we are using Typescript and Express.js.
At ruumi we help farmers with rotational grazing: a managed grazing technique that regenerates soil, increases biodiversity, minimizes agro-chemicals, and improves profitability at the same time.
We are bringing multi-spectral and radar satellite imagery, geo-spatial tech, and machine learning to regenerative agriculture. We tell farmers actionable insights for example when and where to move their animals to maximize soil regeneration.
Check it out at http://jobs.ruumi.io
Think: resnet+imagenet but for videos: https://github.com/moabitcoin/ig65m-pytorchWe ported the r(2+1)d model (from CVPR 2018, see https://arxiv.org/abs/1711.11248) and the weights pre-trained by Facebook Research on over 65 million Instagram videos (from CVPR 2019, https://arxiv.org/abs/1905.00561) to PyTorch and released architecture, weights, tools for conversion, and feature extraction...
We are building AV-enabled routing and mapping capabilities to help ride-hailers and car manufacturers around the world shape the future of autonomous mobility. Together with Daimler's autonomous and vehicle teams our goal is not simply to get our customers from A to B but to get them there with the quality and safety they have come to expect from our brand.
We are hiring for:
* Backend - Node.js, Swagger/OpenAPI, k8s; to work on our services and the underlying infrastructure
* Routing & Maps - Python, C++, Rust; to work on graphs, shortest path algorithms, machine maps / lane-level maps
* Machine Learning - PyTorch, TensorFlow; to work on feature extraction, graph embeddings, traffic models, and demand prediction
Some example projects our engineers have worked on before:
* https://github.com/Project-OSRM/osrm-backend
* https://github.com/mapbox/robosat
Bonus points if you have worked professionally with geospatial data and software before and/or have contributed to OpenStreetMap, be it code or map edits.
Write me a note at daniel(dot)hofmann(at)daimler(dot)com telling me about what projects you've worked on that fit what we're looking for. Include a robot emoji in the subject to confirm you are not a robot ;) You can also find us and talk to us engineers at local meetups such as Geo Berlin.
There is not a single feature this model is most suited for: you can add arbitrary features (e.g. tennis courts, swimming pools) in pre-processing and train your model. Then the imagery quality depends on your feature, for example it will be hard to impossible to spot swimming pools in Landsat imagery.
The model architecture is kept simple on purpose. It used to be an encoder-decoder U-Net'ish architecture which we trained from scratch. Recently (https://github.com/mapbox/robosat/pull/46) I switched out the encoder to a pre-trained ResNet, as proposed by Alexander Buslaev. It's a mix of the papers listed in the docstring at the top with a focus on simplicity and maintainability:
https://github.com/mapbox/robosat/blob/1e687552fe9b254a14d55...
Internally we were also exploring a multi-class PSPNet but decided not to move forward with it right now: the RoboSat model is currently a binary model (feature vs. background) which makes a few things easier in practice, such as efficiently storing results which is needed when scaling it up e.g. to all of North America.
We are mostly focusing on making the process accessible to a broader audience in the geo space, building a solid production-ready end-to-end project.
There are more resources and a step-by-step guide for running on openly available drone imagery in Tanzania:
https://www.openstreetmap.org/user/daniel-j-h/diary/44145 https://www.openstreetmap.org/user/daniel-j-h/diary/44321
I can also recommend http://openaerialmap.org for playing around with openly available drone imagery. I did this last week as a side-project on my evenings for drone imagery provided by http://www.zanzibarmapping.com. Here is a step-by-step guide for giving it a try on the Tanzania drone imagery: https://www.openstreetmap.org/user/daniel-j-h/diary/44321
https://gist.github.com/daniel-j-h/b410dd21d4949a54c83d0c386...
The build script needs slight adaptions between major TensorFlow releases; otherwise works great for me so far.
During boot time you can then figure out the instance architecture you are and fetch the appropriate wheel. Hope it helps.
I stumbled upon metric trees for nearest neighbor queries in metric spaces some months ago and wrote down notes here:
http://daniel-j-h.github.io/post/nearest-neighbors-in-metric...
Hope that helps.
New misc-move-forwarding-reference check Warns when std::move is applied to a forwarding reference instead of std::forward.
http://clang.llvm.org/extra/clang-tidy/checks/misc-move-forw...
New misc-use-after-move check Warns if an object is used after it has been moved, without an intervening reinitialization.
http://clang.llvm.org/extra/clang-tidy/checks/misc-use-after...
The use-after-move check has its limitations which make sense considering the "unspecified but valid state" moved from objects are in. From reading the design document the cases they handle should catch common ownership issues, though. Great step in the right direction for sure.
Implementation: https://github.com/llvm-mirror/clang-tools-extra/blob/master...
Now have a look at the codegen [2] without and with -ffast-math.
With -ffast-math the compiler rewrites the Kahan summation algorithm to a simple sum, completely screwing the code's semantic (since we told the compiler to do so!). Keep this in mind.
1 https://en.wikipedia.org/wiki/Kahan_summation_algorithm 2 https://godbolt.org/g/uWZgW2
Once you realize there's not much a difference between Microkernels are the recent microservices architectures, they become interesting again. Then you might want to look in recent advances such as Unikernels or Anykernels.
Here's a good start summarizing lessons in Microkernels learned in the last decades: http://dl.acm.org/citation.cfm?id=2522720
I'm thinking about what this scenario means for road networks and if it makes sense there at all (not considering the algorithm's assumptions). I guess it would answer the question of how bad traffic jams have to be on certain roads in the shortest path in order to force the route over a specific road.
On a sidenote: in the caption for figure 2, it has to be "link ef is cut" instead of "link eg is cut" in b) if I understand it correctly.
In my opinion this comes from two simple facts: 1/ it's easier to throw a OpenMP #pragma on your loop after detecting the bottleneck with a profiler and 2/ you need to understand some TBB concepts like partitioning/splitting to implement your own algorithms. That is, TBB much more integrates into the language (modern C++ with lambdas etc.).
I won't tell you much about TBB's concurrent containers (maps, queues, vectors, ...), parallel algorithms (sort, scan, reduce, ...), or memory allocators. Those are explained in detail in the documentation. What I want to tell you about is TBB's Pipeline and FlowGraph feature, because of how powerful they are and how often they are simply ignored.
TBB's pipeline lets you build a pipeline of parallel or serial stages. On a high level it really is function composition, with the benefit of TBB deciding on the level of parallelism.
Here is an example of using TBB's pipeline to receive from the network, deserialize the blob and merge the results concurrently and potentially in parallel:
https://github.com/daniel-j-h/DistributedSearch/blob/97224b1...
You can find a quick explanation in this blog post:
https://daniel-j-h.github.io/post/intuitive-monadic-bind-kle...
All you have to do is create your stages as functions: take input from stage n-1, process it and move ownership of the item over to stage n. Note: C++11's move semantics do not require you to pass raw pointers around or do the memory management yourself, as it is done in TBB's documentation!
As you can see, you only need the parallel_pipeline function (and make_filter<In, Out> for when the stages are not passed directly as lambdas):
https://www.threadingbuildingblocks.org/docs/help/reference/...
TBB's pipeline is really powerful for scenarios where a linear processing chain is needed, e.g. face detection with OpenCV where you have to 1/ grab a frame 2/ do some histogram corrections 3/ apply gaussian blur 4/ apply a face detection algorithm 5/ merge face's position into circular buffer 6/ do average over this buffer to estimate face position.
TBB's FlowGraph is for when your dependencies are more difficult to express as a simple pipeline. In the OpenCV example, maybe you need to buffer 5 frames for the face detection, maybe you need to join inputs from a camera and a video and react on when a face is found in a camera frame.
An example for expressing arbitrary dependencies is here:
https://www.threadingbuildingblocks.org/docs/help/reference/...
And an example for joining two nodes:
https://www.threadingbuildingblocks.org/docs/help/reference/...
This is the documentation's starting point for FlowGraph:
https://www.threadingbuildingblocks.org/docs/help/index.htm#...
There is also a book about TBB out there and it contains some additional examples. But as it is with most of the documentation, those examples are not written in modern C++ (C++11/C++14) and the book is a bit dated.
I'm playing around with what is now my second iteration of Monadic Bind and Kleisli Composition for boost::optional, which looks something like this right now:
// tag dispatch work around for void returning functions (that make no sense in a purely functional world)
namespace detail {
template <typename A, typename Fn>
auto monadicBindImpl(const boost::optional<A>& a, Fn f, std::false_type) -> decltype(f(*a)) {
if (a) return f(*a); else return {};
}
template <typename A, typename Fn>
auto monadicBindImpl(const boost::optional<A>& a, Fn f, std::true_type) -> void {
if (a) f(*a);
}
}
template <typename A>
auto pure(A&& a) { return boost::optional<A>(std::forward<A>(a)); }
template <typename A, typename Fn>
auto operator>>=(const boost::optional<A>& a, Fn f) -> decltype(f(*a)) {
return detail::monadicBindImpl(a, f, typename std::is_same<decltype(f(*a)), void>{});
}
There are other articles on the web for Monads in C++, that probably do a better job at an actual implementation. Please see this as my personal playground code :)
You see, it heavily depends on your preferred environment.