by

Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Activity
  • May 20 05:04

    ocramz on gh-pages

    Add `sampling` (compare)

  • May 19 09:03

    ocramz on gh-pages

    Add kdt, Supervised Learning se… (compare)

  • Apr 14 01:32
    tonyday567 removed as member
  • Jan 30 07:37

    ocramz on gh-pages

    Add arrayfire (compare)

  • Jan 02 12:51

    ocramz on gh-pages

    add inliterate (compare)

  • Jan 02 12:43

    ocramz on gh-pages

    update hvega entry (compare)

  • Jul 01 2019 09:43
    dmvianna added as member
  • Jun 15 2019 04:55

    ocramz on gh-pages

    Add pcg-random (compare)

  • Jun 14 2019 16:08
    ocramz labeled #42
  • Jun 14 2019 16:08
    ocramz labeled #42
  • Jun 14 2019 16:08
    ocramz labeled #42
  • Jun 14 2019 16:08
    ocramz labeled #42
  • Jun 14 2019 16:08
    ocramz labeled #42
  • Jun 14 2019 16:08
    ocramz labeled #42
  • Jun 14 2019 16:08
    ocramz opened #42
  • Jun 14 2019 16:08
    ocramz opened #42
  • Jun 06 2019 18:21

    ocramz on gh-pages

    Fix graphite link Merge pull request #41 from alx… (compare)

  • Jun 06 2019 18:21
    ocramz closed #41
  • Jun 06 2019 18:21
    ocramz closed #41
  • Jun 06 2019 17:32
    alx741 opened #41
Adam Conner-Sax
@adamConnerSax
Anyway, the lens thing is cool! I wonder how easy/hard it would be to have conversions between the Control.Foldl versions of these things. The applicative instance of Folds is useful for combining one-pass operations on the same data. Is there some equally straightforward way to combine meanOf folded and sumOf folded so that the fold only happens once? That might go back to the idea of “meanOf” as the optic and then maybe there’s a way to compose the optics?
Aleksey Khudyakov
@Shimuuar
Thanks for the pointer. I haven't seen that post!

As for foldl-like functionality I'm not sure seems difficult since accumulator type leaks in type signatures. But could be possible.

Another problem is one frequently needs multiple passes over data to avoid precision loss. Numerically stable computation of variance requires computing mean first

Adam Conner-Sax
@adamConnerSax
Foldl dodges that accumulator-type-leaking problem by quantifying over it and then adding an extra bit to the data type so you can return something else, thus separating the accumulator type from the return type. Then it is an Applicative in that returned type rather than the accumulator type.
Not sure how the multi-pass part could work but it’d be very cool if two multi-pass computations could be composed such that they need only do the max of the indivudual number of passes each needs. I wonder of there is a way to stack them, as a type-level list, like a list of effect handlers?
Yves Parès
@YPares
@Shimuuar Yep, I think what @adamConnerSax is mentionning is realizable via foldOver http://hackage.haskell.org/package/foldl-1.4.5/docs/Control-Foldl.html#v:foldOver to which you give any lens/prism/traversal, and a Fold from http://hackage.haskell.org/package/foldl-statistics
(cc @MMesch didn't you use that pattern in the past?)
Aleksey Khudyakov
@Shimuuar
Another question is what to do with statistics that couldn't be expressed as folds cleanly. Median for example. I can think only about building temporary vector, work on it and then discard
Tony Day
@tonyday567
I think that’s all there is for an exact median but there are approximate methods eg https://github.com/tonyday567/online/blob/master/online/src/Online/Medians.hs#L23
Aleksey Khudyakov
@Shimuuar
Both are needed
Torsten Scholak
@tscholak
hi, hugging face has released a new Rust implementation of their byte pair tokenizers: https://github.com/huggingface/tokenizers
they are looking for language binding contributions. Haskell bindings would be more than welcome. they would fill a gap we currently have with hasktorch where we work towards pre-trained Bert and gpt-2 models people can use in their projects
Marco Z
@ocramz
@tscholak do you work primarily within NLP?
Torsten Scholak
@tscholak
yes
Stefan Dresselhaus
@Drezil
thanks for the hint @tscholak .. i use that now in my pytorch thingy .. :)
last time i looked at hasktorch it was missing things (or at least i had the impression). I would prefer to migrate to hasktorch in the next months/years .. provided my supervisor is ok with that & i can train ppl. on the job with it.. ;)
But then there will maybe be more contributions from my side ..
Torsten Scholak
@tscholak
hehe, thanks @Drezil
I'm steadily working towards what I informally call "haskformers"...
watch it happen here: hasktorch/hasktorch#269
this is just a transformer language model (gpt-2 style) implementation.
later we want to be able to load hugging face transformers models and also use their tokenizers. hence the call for help
Torsten Scholak
@tscholak
the PR got merged, https://hasktorch.github.io/hasktorch-0.2.0.0/html/Torch-Typed-NN-Transformer.html
next I'm going to set up the training
Stefan Dresselhaus
@Drezil
:thumbsup:
@tscholak how complicated do you think wrapping the tokenizers will be? I never worked with bridging to rust from Haskell...
Torsten Scholak
@tscholak
@Drezil for someone who has (i) some experience in Rust, (ii) some experience in Haskell, and (iii) some experience in using the C FFI it should be fairly easy. I only check one of these boxes, unfortunately.
there's some old article on calling Rust from Haskell here: https://blog.mgattozzi.dev/haskell-rust/
Stefan Dresselhaus
@Drezil
well... i have no experience in rust either .. i was hoping that one could generate some C-Bindings/-Headers from the rust-code.. ;)
Yves Parès
@YPares
@tscholak you forgot "and (iv) some time"
Torsten Scholak
@tscholak
aye
whoever works on this, has to be ok with the cost of not working on something else. I don’t check that box at the moment
Compl Yue
@complyue
https://github.com/e-wrks/edh finally I can release this as a first version, the outcome is far beyond what I've imagined when I started working on it. anyway it reads the tape now :D
Austin Huang
@austinvhuang
Based on how easy this looks https://github.com/aisamanra/rust-haskell-ffi and the few bits I've read on rust making it a goal to slot in for C FFI easily, knowing rust may even be optional.
junji hashimoto
@junjihashimoto
I don't know how much demand there is. We can develop inline-rust instead of inline-c.
http://hackage.haskell.org/package/language-rust
https://hackage.haskell.org/package/inline-c
haskell-with-rust -(template haskell generates)-> haskell, rust and c
Torsten Scholak
@tscholak
if this stood truly in the way of writing haskell bindings for this huggingface library, I’d rather just do it all over again in haskell. Luckily, I don’t think that is the case.
Bryan Buecking
@buecking
Anyone have experience with porcupine?
buecking @buecking reading whatever docs he can find
Yves Parès
@YPares
@buecking I do
@buecking if you have questions, here or the gitter https://gitter.im/tweag/porcupine are good places :)
Alexey Kuleshevich
@lehins
This seems like a crowd that could potentially find use for this new library that I created: https://github.com/lehins/Color
Let me know what you guys think.
Gregory Schwartz
@GregorySchwartz
@lehins Interesting! How does it differ from http://hackage.haskell.org/package/colour-2.3.5 ?
Alexey Kuleshevich
@lehins
@GregorySchwartz Color has quite a bit more functionality, more type safety and is much-much faster than colour. There is a benchmark section in the library in case you are curious to see for yourself. Also I couldn't find a repo where colour package is maintained, which I think is a serious drawback.
And most importantly one is capitalized and has American spelling , where the other one is named with lower case and is spelled in British English. :D
Just as a sanity check I have tests that compare the values between the two libraries for the intersecting functionality.
RajaramRajamani
@RajaramRajamani
anybody is there from Bangalore?
Here..
Marco Z
@ocramz
hi @RajaramRajamani , welcome!
RajaramRajamani
@RajaramRajamani
Hi..happy to be here!
Stefan Dresselhaus
@Drezil
Anyone knows a good KNN-Implementation in haskell? Preferably just using indices into an hmatrix as i want to do other computations as well..
ideally some cover-tree-algorithm .. ;)
Stefan Dresselhaus
@Drezil
welp ... i tried https://hackage.haskell.org/package/KdTree but it is painfully slow ... i would have to rewrite it (no bangs, no optimizations anywhere..)
Kevin Brubeck Unhammer
@unhammer
Stefan Dresselhaus
@Drezil
both same author, HMM:2.0.1 looks identical to hmm:2.0.1 .. so maybe just an errernous upload?
Kevin Brubeck Unhammer
@unhammer
probably :/