duckling
syntaxdot
Our great sponsors
duckling | syntaxdot | |
---|---|---|
13 | 4 | |
4,015 | 65 | |
0.6% | - | |
0.0 | 6.2 | |
2 months ago | 6 months ago | |
Haskell | Rust | |
BSD 3-clause "New" or "Revised" License | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
duckling
-
Experimental library for scraping websites using OpenAI's GPT API
For the reasons others have said I don't see it replacing 'traditional' scraping soon. But I am looking forward to it replacing current methods of extracting data from the scraped content.
I've been using Duckling [0] for extracting fuzzy dates and times from text. It does a good job but I needed a custom build with extra rules to make that into a great job. And that's just for dates, 1 of 13 dimensions supported. Being able to use an AI that handles them with better accuracy will be fantastic.
Does a specialised model trained to extract times and dates already exist? It's entity tagging but a specialised form (especially when dealing with historical documents where you may need Gregorian and Julian calendars).
[0] https://github.com/facebook/duckling
-
Automatisiert Kalendereinträge erstellen aus Mails mit Formatlosen Datumsangaben
Ah, sorry: https://github.com/facebook/duckling
-
Transforming free-form geospatial directions into addresses - SOTA?
To understand what relative distance and direction is indicated from the reference point, I'd look into something like Facebook & Wit.AI's Duckling, and a custom classifier to identify if it's on the reference point ("corner of"), or some distance from ("200 meters southwest"). If you can parse out a distance and direction, then it's all logic to plot the point.
-
Programming languages endorsed for server-side use at Meta
It also powers the backend of Wit.ai which FB owns. Wit's open-source entity parser, duckling, is written entirely in Haskell. https://github.com/facebook/duckling
- Data Cleaning using Machine Learning?
-
Unsplash chatbot for Discord, Pt. 2: more ways to bring pictures to Discord
Our RandomPicForLater intent will have one slot called reminderTime and will be of type @duckling.time. Duckling is a library that extracts entities from text, and it is one of the tools used in JAICP for this purpose. Entity types in Duckling are called dimensions and there's a number of them built in, among them is Time which suits us perfectly since we need to ask users when they want us to schedule a post for and then parse a text input into a datetime object.
-
Dependencies difference between cabal and stack
I'm working on a pretty interesting project right now and I'm having different results depending on the build tool used: with cabal, the test suite fails but it passes with stack.
-
Running Duckling on Windows
Try downloading the v0.2.0.0 release, extracting it somewhere, opening that location in powershell, and running these commands:
-
[ANN] Duckling v0.2.0.0 released
Duckling (https://github.com/facebook/duckling) is a library for parsing text into structured data.
-
Extract name:value relationships from plain text
If you really want high precision, Duckling is a good project to check out https://github.com/facebook/duckling
syntaxdot
-
Candle: Torch Replacement in Rust
I am so happy about them releasing this. A few years ago I wrote a multi-task syntax annotator in Rust using Laurent Mazare's excellent tch-rs binding (it seems like he is also working on Candle):
https://github.com/tensordot/syntaxdot
However, the deployment story was always quite difficult. The PyTorch C++ API is not stable, so a particular version of tch-rs will only work with a particular PyTorch version. So, anyone wanting to use SyntaxDot always had to get exactly the right version of libtorch (and set some environment variables) to build the project.
The idea of making an abstraction over Torch and Rust ndarray (similar to Burn) crossed my mind several times, but there is only so much that I could do as a solo developer. So Candle would be a god-given if I was still working on this project.
Seeing Candle wants to make me port curated-transformers to Candle for fun:
https://github.com/explosion/curated-transformers
-
Ask HN: What is the job market like, for niche languages (Nim, crystal)?
They are obviously not as good as in Python, but if you are willing to invest time, it's definitely doable. E.g. I made a multi-task transformer-based syntax annotator in Rust using the tch Torch binding:
https://github.com/tensordot/syntaxdot
In my current job, I do NLP with Python, Cython, and some C++. I don't think doing it in Rust was much more work. Once you are beyond the stage of implementing a small research project or toy model, most systems are going to contain a lot of custom, specialized code. You will have to do that work in any language.
-
PyTorch 1.8 release with AMD ROCm support
What I like about PyTorch is that most of the functionality is actually available through the C++ API as well, which has 'beta API stability' as they call it. So, there are good bindings for some other languages as well. E.g., I have been using the Rust bindings in a larger project [1], and they have been awesome. A precursor to the project was implemented using Tensorflow, which was a world of pain.
Even things like mixed-precision training are fairly easy to do through the API.
[1] https://github.com/tensordot/syntaxdot
-
SpaCy v3.0 Released (Python Natural Language Processing)
Huggingface fills the need for task based prediction when you have a GPU.
With model distillation, it should be possible to annotate hundreds of sentences per second on a single CPU with a library like Huggingface Transformers.
For instance, one of my distilled Dutch multi-task syntax models (UD POS, language-specific POS, lemmatization, morphology, dependency parsing) annotates 316 sentences per second with 4 threads on a Ryzen 3700X. This distilled model has virtually no loss in accuracy, compared to the finetuned XLM-RoBERTa base model.
I don't use Huggingface Transformers, but ported some of their implementations to Rust [1], but that should not make a big difference since all the heavy lifting happens in C++ in libtorch anyway.
tl;dr: it is not true that tranformers are only useful for GPU prediction. You can get high CPU prediction speeds with some tricks (distillation, length-based bucketing in batches, etc.).
[1] https://github.com/tensordot/syntaxdot/tree/main/syntaxdot-t...
What are some alternatives?
spaCy - 💫 Industrial-strength Natural Language Processing (NLP) in Python
laserembeddings - LASER multilingual sentence embeddings as a pip package
ctparse - Parse natural language time expressions in python
Giveme5W1H - Extraction of the journalistic five W and one H questions (5W1H) from news articles: who did what, when, where, why, and how?
projects - 🪐 End-to-end NLP workflows from prototype to production
Kornia - Geometric Computer Vision Library for Spatial AI
tensorflow - An Open Source Machine Learning Framework for Everyone
BLINK - Entity Linker solution
candle - Minimalist ML framework for Rust
semantic-source - Parsing, analyzing, and comparing source code across many languages