The Primitives

asyncio is supposed to implement asynchronous IO with the help of coroutines. Originally implemented as a library around the yield andyield from expressions it's now a much more complex beast as the language evolved at the same time. So here is the current set of things that you need to know exist:

• event loops
• event loop policies
• awaitables
• coroutine functions
• old style coroutine functions
• coroutines
• coroutine wrappers
• generators
• futures
• concurrent futures
• tasks
• handles
• executors
• transports
• protocols

In addition the language gained a few special methods that are new:

There are many terrible modules in the Python standard library, but the Python re module is not one of them. While it's old and has not been updated in many years, it's one of the best of all dynamic languages I would argue.

Fixing up Groups

One annoying thing is that our group indexes are not local to our own regular expression but to the combined one. This means if you have a rule likeand you want to access that group by index, it will be wrong. This would require a bit of extra engineering with a class that wraps the SRE match object with a custom one that adjusts the indexes and group names. If you are curious about that I made a more complex version of the above solution that implements a proper match wrapper in a github repository together with some samples of what you can do with it.

Followings of @memming on X

Followings of @_Jaivardhan_ on X

• Nov 19, 2021

  Coin Vol-II Hedging your BTC/ETH - The basics

• Nov 13, 2021

  Coin Volatility Surfaces

• Sep 5, 2021

  The Crypto-Carry Trade

• Aug 5, 2021

  Woo, Quantum Storytelling, Time Crystals and Misallocation

• May 30, 2021

  Pricing Options with TorchSDE

• Apr 30, 2021

  Solving multidimensional PDEs in pytorch

• Apr 7, 2021

  Using simple mean-reversion to remove carry from a VIX futures position

• Mar 11, 2021

  Moving on from the Macbook Pro

• Mar 6, 2021

  Simply Extracting information out of your Stochastic Series

• Jan 6, 2021

  Copulas made simple with Pytorch Distributions

• Dec 5, 2020

  How to Size Bets. The Kelly Criterion in PyTorch

• Nov 5, 2020

  The #1 Reason to have a 3D Printer.

• Oct 5, 2020

  Modest Proposals to Make Science Great Again.

• Sep 21, 2020

  Some Robot Art

• Sep 5, 2020

  Quaternion Averaging in Pytorch

• Aug 5, 2020

  Yet another static blog!

At atomsandbits.ai we implement some seriously large formulas in TensorFlow. If we just went from LaTeX to tf. we wouldn't be able to do it. Here's a list of tricks and tools we use, applied to the problem of averaging rotations. Come for the tf. stay for the hypersphere.

The tensormol0.2 model chemistry reproduces a huge swath of chemistry (37 elements), which is in some sense a large fraction of our world. It's a big ole' formula for some geometry:

How does one use TensorFlow effectively to get something complicated done? It's not easy. I thought I'd write up an example a little simpler than modeling all of chemistry. How about averaging rotations/axis systems? Simple right? Well interesting story… The math is mostly due to Hamilton (~1843), however it wasn’t until the advent of computer graphics in 1985 that people even bothered to work out how to interpolate between rotations perfectly.

#Rotation & Quaternions

The rotational algebra of our world is a beautiful bedeviling thing. The reason is that although rotations act on a three dimensional space, when embedded in three dimensions, rotations are not smooth or unique. When represented with Euler angles or matrices, every rotation has multiple representations. Change the order of rotations and you also change the endpoint (rotations are non-commutative) Traveling smoothly along some paths of rotations using a three dimensional embedding, suddenly the third degree of freedom can become inaccessible (the phenomenon of “Gimbal lock”). If you try to define an average or interpolated point-of-view in a naive way (axes=> angles => interpolated angles) you will find gibberish zero axes, and jerky non-smooth behavior.

The rotational algebra of our world is a beautiful bedeviling thing. The reason is that although rotations act on a three dimensional space, when embedded in three dimensions, rotations are not smooth or unique. When represented with Euler angles or matrices, every rotation has multiple representations. Change the order of rotations and you also change the endpoint (rotations are non-commutative) Traveling smoothly along some paths of rotations using a three dimensional embedding, suddenly the third degree of freedom can become inaccessible (the phenomenon of “Gimbal lock”). If you try to define an average or interpolated point-of-view in a naive way (axes=> angles => interpolated angles) you will find gibberish zero axes, and jerky non-smooth behavior.

To have smooth topology rotations must be embedded within a four-dimensional hypersphere, so we can forgive your brain. In this space a rotation is a 4-dimensional point, a quaternion, whose components can be thought of as the angle and 3 axis components of the rotation. Given a 3x3 rotation matrix Q, one can parameterize a quaternion (w,x,y,z)

To have smooth topology rotations must be embedded within a four-dimensional hypersphere, so we can forgive your brain. In this space a rotation is a 4-dimensional point, a quaternion, whose components can be thought of as the angle and 3 axis components of the rotation. Given a 3x3 rotation matrix Q, one can parameterize a quaternion (w,x,y,z).

Given any set of orthogonal axes (rows of Q), Euler's theorem guarantees an axis-angle rotation which can map the natural xyz axes back and forth into the new frame. The formula above yields the natural 4-d form of that rotation.

Now suppose you have two, three or four systems of axes (ax_1, ax_2, ax_3). For example you want to look at the sun then the moon, or you want to fit 4 pretty objects in your field of vision, or define invariant axes for a cloud of points (the reason we use this math in TensorMol). Can you simply average the quaternion components q_av = (ax_1+ax_2+ax_3)/3? Sadly no… You can immediately understand why if you imagine averaging rotations around opposite axis vectors as an owl might when spinning his head. The “good, smooth” quaternions keep to the surface of the 4-d hypersphere (a curvy subset of 4d-euclidean space). To interpolate lines on that sphere, you can use SLERP. To average multiple quaternions we must construct the 4x4 matrix which is the outer product of the list of quaternions (Nx4) with itself, weighted if desired:

The largest eigenvector of this matrix is the desired average quaternion.

Implementing complex math in tf.

Again, my goal is to get rotationally invariant axes for a set of points which smooth, differentiable and local. I will walk through my whole implementation of this in tf. Step 1- Don't use tf. Write a simple test of your formulas in a notebook like math interface (mathematica, ipython/sage). Verify everything is working when you use all the fancy library routines tf. doesn't have (eigenvectors etc.). Here's what that looks like using mathematica.

Those fancy manipulate sliders are a nice way to get tangible faith that the point cloud is rotationally invariant when transformed using an averaged axis system depending on points in the cloud. It remains for us to do this same thing in tf. Were' ready for step 2:

def slerp(v0, v1, t=0.05):
    """
    Interpolate between quaternions v0 and v1.
    """
    v0 = safe_normalize(v0)
    v1 = safe_normalize(v1)
    dot = tf.reduce_sum(v0*v1,axis=-1,keepdims=True)
    # If the dot product is negative, slerp won't take
    # the shorter path. Note that v1 and -v1 are equivalent when
    # the negation is applied to all four components. Fix by
    # reversing one quaternion.
    signflip = tf.where(tf.less_equal(dot,0.),-1.*tf.ones_like(dot),tf.ones_like(dot))
    v1 *= signflip
    dot *= signflip
    # Linear answer.
    linq = safe_normalize(v0 + t*(v1-v0))
    #
    sdot = tf.clip_by_value(dot,-1.0,1.0)
    theta_0 = tf.acos(sdot)
    theta = theta_0*t
    sin_theta = tf.sin(theta)
    sin_theta_0 = tf.sin(theta_0)
    s0 = tf.cos(theta) - dot * sin_theta / (sin_theta_0+1e-19)
    s1 = sin_theta / (sin_theta_0+1e-19)
    sq = safe_normalize((s0 * v0) + (s1 * v1))
    #
    DOT_THRESHOLD = 0.9995
    tdot = tf.concat([dot,dot,dot,dot],axis=-1)
    slerpd = tf.where(tf.greater(tdot,DOT_THRESHOLD),linq,sq)
    ttiled = tf.concat([t,t,t,t],axis=-1)
    slerpdorv1 = tf.where(tf.greater(ttiled,1.0-1e-14),v1,slerpd)
    return tf.where(tf.less(ttiled,1e-14),v0,slerpdorv1)
def sftpluswparam(x):
    return tf.log(1.0 + tf.exp(100. * x)) / 100.0
def RotToQuat(axes_):
    """
    axes is a ... X 3 3 tensor of axes
    this generates a ... X 4 tensor of quaternions.
    which are 1:1 with those axes.
    """
    w = (1./2.)*tf.sqrt(1e-15+tf.abs(1 + axes_[...,0, 0] + axes_[...,1, 1] + axes_[...,2, 2]))
    x = tf.sign(axes_[...,2, 1] - axes_[...,1, 2])*tf.abs(0.5*tf.sqrt(1e-15+tf.abs(1.0 + axes_[...,0, 0] - axes_[...,1, 1] - axes_[...,2, 2])))
    y = tf.sign(axes_[...,0, 2] - axes_[...,2, 0])*tf.abs(0.5*tf.sqrt(1e-15+tf.abs(1.0 - axes_[...,0, 0] + axes_[...,1, 1] - axes_[...,2, 2])))
    z = tf.sign(axes_[...,1, 0] - axes_[...,0, 1])*tf.abs(0.5*tf.sqrt(1e-15+tf.abs(1.0 - axes_[...,0, 0] - axes_[...,1, 1] + axes_[...,2, 2])))
    return tf.stack([w,x,y,z],axis=-1)
def QuatToRot(q):
    """
    a_ ... X 4 tensor of quaternions
    this generates a ... X 3 X 3 of rotation matrices.
    """
    tmp=tf.stack([1 - 2.*(q[...,2]*q[...,2] + q[...,3]*q[...,3]), 2*(q[...,1]*q[...,2] - q[...,3]*q[...,0]),
    2*(q[...,1]*q[...,3] + q[...,2]*q[...,0]),2*(q[...,1]*q[...,2] + q[...,3]*q[...,0]), 1 - 2.*(q[...,1]*q[...,1] + q[...,3]*q[...,3]),
    2*(q[...,2]*q[...,3] - q[...,1]*q[...,0]),2*(q[...,1]*q[...,3] - q[...,2]*q[...,0]), 2*(q[...,2]*q[...,3] + q[...,1]*q[...,0]),
    1 - 2.*(q[...,1]*q[...,1] + q[...,2]*q[...,2])],axis=-1)
    return tf.reshape(tmp,[-1,3,3])
def VectorsToOrient(v1,v2):
    v1n = safe_normalize(v1)
    v2n = safe_normalize(v2)
    v3 = safe_normalize(tf.cross(v1n, v2n)+tf.constant(np.array([0., 0., 1e-19]), dtype=tf.float64))
    # Compute the average of v1, v2, and their projections onto the
    # plane.
    v_av = (v1n + v2n) / 2.0
    v_av = safe_normalize(v_av)
    # Rotate pi/4 cw and ccw to obtain v1,v2
    first = TF_AxisAngleRotation(v3, v_av, tf.constant(-Pi / 4., dtype=tf.float64))
    second = TF_AxisAngleRotation(v3, v_av,tf.constant(Pi / 4., dtype=tf.float64))
    vs = tf.concat([first[:, tf.newaxis, :], second[:, tf.newaxis, :],v3[:, tf.newaxis, :]],axis=1)
    return vs
def VectorsToAxisQs(v1,v2):
    return tf.reshape(RotToQuat(VectorsToOrient(v1,v2)),(-1, 4))
def safe_normalize(x_):
    nrm = tf.clip_by_value(tf.norm(x_,axis=-1,keepdims=True),1e-36,1e36)
    nrm_ok = tf.logical_and(tf.not_equal(nrm,0.),tf.logical_not(tf.is_nan(nrm)))
    safe_nrm = tf.where(nrm_ok,nrm,tf.ones_like(nrm))
    return x_*tf.where(nrm_ok,1.0/safe_nrm,tf.zeros_like(nrm))
def safe_inv_norm(x_):
    nrm = tf.clip_by_value(tf.norm(x_,axis=-1,keepdims=True),1e-36,1e36)
    nrm_ok = tf.logical_and(tf.not_equal(nrm,0.),tf.logical_not(tf.is_nan(nrm)))
    safe_nrm = tf.where(nrm_ok,nrm,tf.ones_like(nrm))
    return tf.where(nrm_ok,1.0/safe_nrm,tf.zeros_like(nrm))
def safe_norm(x_):
    nrm = tf.clip_by_value(tf.norm(x_, axis=-1, keepdims=True), 1e-36, 1e36)
    nrm_ok = tf.logical_and(
        tf.not_equal(nrm, 0.), tf.logical_not(tf.is_nan(nrm)))
    safe_nrm = tf.where(nrm_ok, nrm, tf.zeros_like(nrm))
    return safe_nrm
with tf.Graph().as_default():        
    xyzs = tf.Variable(np.random.random((batch_size,MaxNAtom,3))*7.0 - 5.0)
    init = tf.global_variables_initializer()
    sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
    sess.run(init)
    print sess.run(xyzs[0,:2])
    print sess.run(VectorsToOrient(xyzs[:,0],xyzs[:,1]))
    print sess.run(RotToQuat(VectorsToOrient(xyzs[:,0],xyzs[:,1])))
    print sess.run(QuatToRot(RotToQuat(VectorsToOrient(xyzs[:,0],xyzs[:,1]))))

Style notes about the tf. code given above:

• Each routine can be easily compared with the mathematica output, to quickly debug.
• In general it is best to choose an order of dimensions for your tensor which goes (least often contracted,…,most often contracted), because several helpful tf. functions assume the first dimension of a tensor is the batch dimension.
• tf.sqrt, and 1/(tensor) are both unstable operations in tf. They are unstable in a tricky way, because the implied chain-rule derivative graph (coming from tf.gradients(… op…, var) will still often evaluate NaN’s even when it appears that the arguments to the routine would always be in the well-behaved domain. One must make liberal use of tf.clip_by_value() , tf.where(), and infinitesimals to ensure both the routine and routine’s derivatives are well-behaved. Safe_norm is a good example.

Epilogue

So is all this serious rotational mathematics only good for defining axis systems for atomic positions. No! Facebook AI-Research and collaborators from the EPFL published a nice use of quaternions for skeletal motion planning last week

• The geometry of data: the missing metric tensor and the Stein score [Part II]
• Torch Titan distributed training code analysis
• Memory-mapped CPU tensor between Torch, Numpy, Jax and TensorFlow
• Generalisation, Kant’s schematism and Borges’ Funes el memorioso – Part I
• PyTorch 2 Internals – Talk
• Thoughts on Riemannian metrics and its connection with diffusion/score matching [Part I]
• Large language model data pipelines and Common Crawl (WARC/WAT/WET)
• Feste: composing NLP tasks with automatic parallelization and batching
• Couple of recent publications in uncertainty estimation and autonomous vehicles
• [pt-br] Dados das enchentes no Rio Grande do Sul (RS) em 2024
• Tutorial on using LLVM to JIT PyTorch fx graphs to native code (x86/arm/risc-v/w...)
• Arduino WAN, Helium network and cryptographic co-processor
• Episuite: epidemiology in Python

Early days #

A founding principle of OpenAI is that we value research and engineering equally — our goal is to build working systems that solve previously impossible tasks, so we need both. (In fact, our team is comprised of 25% people primarily using software skills, 25% primarily using machine learning skills, and 50% doing a hybrid of the two.) So from day one of OpenAI, my software skills were always in demand, and I kept procrastinating on picking up the machine learning skills I wanted.

After helping build OpenAI Gym, I was called to work on Universe. And as Universe was winding down, we decided to start working on Dota — and we needed someone to turn the game into a reinforcement learning environment before any machine learning could begin.

Dota #

Time out #

After we lost two games in The International in 2018, most observers thought we'd topped out what our approach could do. But we knew from our metrics that we were right on the edge of success and mostly needed more training. This meant the demands on my time had relented, and in November 2018, I felt I had an opening to take a gamble with three months of my time.

I learn best when I have something specific in mind to build. I decided to try building a chatbot. I started self-studying the curriculum we developed for our Fellows program, selecting only the NLP-relevant modules. For example, I wrote and trained an LSTM language model and then a Transformer-based one. I also read up on topics like information theory and read many papers, poring over each line until I fully absorbed it.

I learn best when I have something specific in mind to build. I decided to try building a chatbot. I started self-studying the curriculum we developed for our Fellows program, selecting only the NLP-relevant modules. For example, I wrote and trained an LSTM language model and then a Transformer-based one. I also read up on topics like information theory and read many papers, poring over each line until I fully absorbed it.

It was slow going, but this time I expected it. I didn't experience flow state. I was reminded of how I'd felt when I just started programming, and I kept thinking of how many years it had taken to achieve a feeling of mastery. I honestly wasn't confident that I would ever become good at machine learning. But I kept pushing because… well, honestly because I didn't want to be constrained to only understanding one part of my projects. I wanted to see the whole picture clearly.

It was slow going, but this time I expected it. I didn't experience flow state. I was reminded of how I'd felt when I just started programming, and I kept thinking of how many years it had taken to achieve a feeling of mastery. I honestly wasn't confident that I would ever become good at machine learning. But I kept pushing because… well, honestly because I didn't want to be constrained to only understanding one part of my projects. I wanted to see the whole picture clearly.

One important conceptual step was overcoming a barrier I'd been too timid to do with Dota: make substantive changes to someone else's machine learning code. I fine-tuned GPT-1 on chat datasets I'd found, and made a small change to add my own naive sampling code. But it became so painfully slow as I tried to generate longer messages that my frustration overwhelmed my fear, and I implemented GPU caching — a change which touched the entire model.

One important conceptual step was overcoming a barrier I'd been too timid to do with Dota: make substantive changes to someone else's machine learning code. I fine-tuned GPT-1 on chat datasets I'd found, and made a small change to add my own naive sampling code. But it became so painfully slow as I tried to generate longer messages that my frustration overwhelmed my fear, and I implemented GPU caching — a change which touched the entire model.

I had to try a few times, throwing out my changes as they exceeded the complexity I could hold in my head. By the time I got it working a few days later, I realized I'd learned something that I would have previously thought impossible: I now understood how the whole model was put together, down to small stylistic details like how the codebase elegantly handles TensorFlow variable scopes.

I had to try a few times, throwing out my changes as they exceeded the complexity I could hold in my head. By the time I got it working a few days later, I realized I'd learned something that I would have previously thought impossible: I now understood how the whole model was put together, down to small stylistic details like how the codebase elegantly handles TensorFlow variable scopes.

Binary IQ — A model of LLM capability

Lightweight property-based testing at Row Zero — How we verify correctness

Rust Macros: Zero to Hero — A comprehensive guide on Rust macros

Algorithms we develop software by — Pathfinding applied to the software solution domain

Building Filesystems — High level ideas in filesystem design

Quasirandom sequences — Cool method to generate non-clumping random points

How to write complex software — A general method

Bureaulogy — The study of bureaucracy

A peasant's plight — On the shackling of the peasantry

Every Man his own API — A sociotechnological trend

Culture is a set of social Schelling points — Solving coordination problems in community-building

Portals are Undertheorized — The importance of arrival

Binary IQ — A model of LLM capability

Designing bug-proof engines — A spectrum of engineering philosophies

Accidental Urbanism — How I got into the scene

How to Bootstrap a Town — A modest plan

Sports vs Games — An aesthetic distinction

Nobody Cares — A rant about caring

Lightweight property-based testing at Row Zero — How we verify correctness

Rust Macros: Zero to Hero — A comprehensive guide on Rust macros

Algorithms we develop software by — Pathfinding applied to the software solution domain

Status among whom? — An essay about status relativism

Ghost Side Control Escape System (BJJ) — A video instructional on my preferred side control escape system

Building Filesystems — High level ideas in filesystem design

AI follows auditability — An essay about the order AI will move through the economy

Book List — Stuff I've read

Onsen Unreality — Our experience at an onsen 'theme park' in Tokyo

Tesla Full Self-Driving — My experience with FSD

Internet Fiction — Collection of amateur stories — mainly sci-fi — that I like

All the way down — Very short story about simulation

Story Ideas — A collection of premises for stories

Things I wish I knew earlier — Collection of stuff I would tell my younger self if I could

Road Width Extremism — In favor of narrow roads

Links to See Also — Other "small web" personal sites I recommend

HTML5 Canvas simulations — A collection of little HTML5 canvas demos

Twitter — Essay about how getting on Twitter unexpectedly added a lot of value to my life

Shuttle — A useful concurrency checker library we used to verify our filesystem at AWS

Quasirandom sequences — Cool method to generate non-clumping random points

Book Review: 'The Perfectionists: How Precision Engineers Created the Modern World' — Excellent book about the history of precision machining

Markdown-ish — Writing a Markdown(ish) parser with the nom library

Bishal Santra Bishal Santra

Research Engineer @microsoft Research India | Working on Language Modeling for Retrieval | IIT KGP

103 repositories36 followers

• Aug 12, 2023

  Explaining Issues with Channel Method in LLM Prompt-based Classification

• Aug 12, 2023

  Explaining Issues with Channel Method in LLM Prompt-based Classification

• Feb 11, 2023

  Prove that the set of algebraic numbers are countable (using primes)

• Feb 10, 2023

  Is ∑_i=1ⁿ 1/n divergent?

• Oct 7, 2021

  How to Connect through an SSH Jump Server (For CNeRG project students)

• Oct 26, 2019

  Transformer Language Models and Pretraining

• Aug 31, 2019

  English to Hindi Transliteration using Seq2Seq Model

• Aug 31, 2019

  Deep Sentiment Analysis

• Jul 13, 2019

  Text Classification using Naive Bayes Method

• Jul 8, 2019

  Training a Language Model with a Xtra-Small Transformer (Transformer-XS)

• Jul 7, 2019

  Simple Reddit Dialogue Preprocessor

• Jul 3, 2019

  How I created this site using Jekyll?

• Jan 12, 2017

  Generating Gamma Random Variable in CUDA in Parallel

• Aug 6, 2016

  Minimum Mean Squared Error (MMSE) Estimator

• Mar 14, 2016

  DecycledJSON - Circular reference breakers for JSON

Charlie Marsh

Building Astral: high-performance tools for Python, starting with Ruff.

In the past: Staff software engineer at Spring Discovery, senior engineer at Khan Academy, and Computer Science major at Princeton.

These days, I write on Notion.

Check out some of my public projects:

• |Ruff ->An extremely fast Python linter, written in Rust
• |MegaMap ->Giving scientist superpowers
• |android-lite ->A 26 KB-take on the Khan Academy Android app
• |math-input ->Khan Academy's expression editor for the mobile web
• |Jasper ->An open source platform for developing always-on, voice-controlled applications
• |Script Playground ->An in-browser playground for the Bitcoin Script programming language
• |Intro to Hacking ->A weekly class taught at Princeton University to survey programming in the wild
• |Online Boosting ->A suite of online boosting and weak learning algorithms in Python
• |Quizzler ->An automatic quiz-question generator for iOS with a Python back-end

• Building a Really, Really Small Android App
• Writing a Reproducible Test Plan
• Reviewing Code from Both Sides
• Getting up and Running with Robolectric
• Learning Android in a Production Setting
• Exploring Flow, Facebook's JavaScript Type Checker (JavaScript Weekly)
• Bitcoin Script: An In-Browser Playground (Hacker News)
• Speeding up SVGs with CSS Transforms at Khan Academy (Hacker News)
• Rendering React Components on the Server
• Styling React Components: How to Escape Selector Hell (talk delivered @ Khan Academy)
• An Overly Thorough Guide to Python Class Attributes (Python Weekly)
• A Primer on Computational Geometry in Python (Python Weekly)
• Why Are There So Many Pythons? (Hacker News, Python Weekly, Pycoder's Weekly)
• Compiling to JavaScript: A Case-by-Case Guide to the *Scripts
• PhantomJS: Common Gotchas for Beginners
• The Idiot-Proof Guide to Setting up Your Personal AWS Instance
• An Introduction to Rule Optimization in Software Defined Networking
• Prefix vs. Ternary Rules in SDN
• Setting up an OCaml Environment on Mac OS X
• Programming Languages and the Solutions they Suggest
• First Thoughts on OCaml
• A Primer on Streams and Lazy Computation
• Binomial Heaps: Merge Better
• Performance Improvements in iOS
• NP != NOT P

kevin frans website v5

Hey, I'm Kevin. I am a PhD student at BAIRadvised by Pieter Abbeel andSergey Levine. I did my B.S. and M.Eng at MIT with Phillip Isola. I am interested in deep reinforcement learning, unsupervised learning, and AI-based creative tools. I also lead engineering at ParagraphAI. I have spent time atCross Labs, Sizigi,Autodesk Research, and OpenAI. In my free time, I like to design and build video games.

Stathis Kamperis Stathis Kamperis

I am a radiation oncologist and physicist. I like to build bridges between different scientific disciplines (medicine, physics, informatics).

15 repositories29 followers

• Featured - https://www.linkedin.com/in/stathis-kamperis/details/featured
• How to implement a Naive Bayes classifier with Tensorflow - 11 likes

11/2024: I won't be attending EMNLP or NeurIPS this year, but my co-authors will be presenting our work! Check out our papers onBenchmarking the Reproduction of Copyrighted Text^{(EMNLP Main, NeurIPS Regulatable ML Workshop Contributed Talk)},Scaling a Datastore in Retrieval-Based LMs^{(NeurIPS Main)}, andAn Open Mixture-of-Experts LM^{(NeurIPS Workshop on Efficient Natural Language and Speech Processing (ENLSP), Oral Talk)}.

11/2024: I am recruiting PhD students at UC Berkeley's EECS!If you're interested, please apply directly through the UC Berkeley admissions portal (details here). Kindly note that I cannot discuss applications outside the official admissions process.

12/2023: I am attending EMNLP and NeurIPS! At EMNLP, I will give an invited talk on Rethinking the Role of Demonstrations at the Big Picture Workshop on Dec 7th, and give an oral talk on FActScore on Dec 8th. At NeurIPS, I will give a spotlight talk on SILO at the Distribution Shifts Workshop on Dec 15th, and give an oral talk on SILO at the Regulatable ML Workshop on Dec 16th.

08/2023: Together with Suchin Gururangan, we present SILO, proposing to segregate the training data and the inference-time data in nonparametric LMs to mitigate legal risk in LMs.

07/2023: Our paper that examines the role of demonstrations in CoT prompting, led by Boshi Wang, won an Honorable Mention at ACL 2023.

07/2023: I co-taught a tutorial on retrieval-based LMs at ACL 2023. Slides & recordings are available on the website.

12/2022: Check out our new preprint,Nonparametric Masked Language Modeling. Code and model checkpoints available here.

09/2022: I was selected by the EECS Rising Stars Program.

08/2022: Together with Sang Michael Xie, we wrote a post on How does in-context learning work? A framework for understanding the differences from traditional supervised learning at Stanford AI Blog.

05/2022: I co-taught the ACL tutorial on Few-Shot NLP with Pretrained Language Models (slides, recordings).

02/2022: Check out our new preprint, Rethinking the Role of Demonstrations: What makes In-context Learning Work?All experiments reproducible from this code. (Update 10/2022: The paper was accepted to EMNLP 2022.)

02/2022: I am co-organizing two workshops at ACL 2022: Repl4NLP (CFP) andSpa-NLP (CFP).

10/2021: Our new preprint, MetaICL: Learning to Learn In Context is out (w/ code). Check out the demo! (Update 04/2022: The paper was accepted to NAACL 2022.)

08/2021: Our new preprint, Noisy Channel Language Model Prompting for Few-Shot Text Classification is out w/ code! (Update 02/2022: The paper was accepted to ACL 2022.)

07/2021: Our new preprint, FaVIQ: FAct Verification from Information-seeking Questions is out! Visit FaVIQ website to download data and see samples. (Update 02/2022: The paper was accepted to ACL 2022.)

07/2021: I am co-organizing The 2nd Workshop on Unstructured/Structured KBs, hosted at AKBC 2021.

06/2021: I co-taught the NAACL-HLT tutorial on Beyond Paragraphs: NLP for Long Sequences.

04/2021: Our new preprint, Joint Passage Ranking for Diverse Multi-Answer Retrievalis out! This is done as part of my internship at Google. (Update 08/2021: The paper was accepted to EMNLP.)

01/2021: We, the NeurIPS 2020 EfficientQA organizers, together with participants, wrote NeurIPS 2020 EfficientQA Competition: Systems, Analyses and Lessons Learned. The video of the NeuIPS event is also available here. (Update 05/2021: The paper was accepted to PMLR.)

12/2020: I am co-organizing The 3rd Workshop on Machine Reading for Question Answering, hosted at EMNLP 2021. Stay tuned for Call for papers!

09/2020: I made an Open-domain QA Demo using DPR. Give it a try!

06/2020: I am co-organizing Competition on Efficient Open-Domain Question Answering, hosted at NeurIPS 2020. [leaderboard]

06/2020: I am co-organizing Workshop on Unstructured/Structured KBs, hosted at AKBC 2020.

04/2020: Our new preprint, AmbigQA: Answering Ambiguous Open-domain Questionsis out! Visit AmbigQA website to download data and see samples.

04/2020: Our new preprint, Dense Passage Retrieval for Open-domain Question Answeringis out (w/ code)!

Here are some of the open source projects I have created or been involved with:

• Pkg.jl – Julia’s package manager.
• NearestNeighbors.jl – High performance nearest neighbor data structures and algorithms.
• Tensors.jl – Efficient computations with symmetric and non-symmetric tensors with support for automatic differentiation.
• OhMyREPL.jl – Syntax highlighting and other enhancements for the Julia REPL.
• Crayons.jl – Colored and styled strings for terminals.
• PGFPlotsX.jl – Seamlessly create plots in Julia using the PGFPlots LaTeX package.
• Pardiso.jl – Calling the PARDISO sparse solver library.
• Tokenize.jl –Tokenization for Julia source code.
• TimerOutputs.jl – Formatted output of timed sections.
• BlockArrays.jl – Interface for blocked arrays.
• Distances.jl – A Julia package for evaluating distances(metrics) between vectors.
• NLsolve.jl – Julia solvers for systems of nonlinear equations and mixed complementarity problems
• MMA.jl – The “Method of Moving Asymptotes”-algorithm. (old package)

Hi there! I’m Danielle Navarro. I’m adata scientist,generative artist, and a recovering academic living in Sydney with my two kids and a Netflix subscription. Once upon a time I was a mathematical psychologist. After that I was developer advocate and occasional software engineer. I’ve sometimes been accused of being a statistician.

djnavarro Danielle Navarro

Data scientist. Former academic. Occasional generative artist

233 repositories1.1k followers

• Email: djnavarro@protonmail.com
• GitHub: github.com/djnavarro
• Mastodon: hachyderm.io/@djnavarro
• LinkedIn: linkedin.com/in/djnavarro
• Orcid: orcid.org/0000-0001-7648-6578
• Scholar: scholar.google.com/citations?user=QPH_lRIAAAAJ

Hi there! I’m Danielle Navarro.

A blog by Danielle Navarro

Hi there! I’m Yihui Xie. I’m a Freelancer (open source programmer, contractor, blogger, and writer)

I’m currently a freelancer, and was a software engineer at Posit Software, PBC (2013-2023). I earned my PhD from the Department of Statistics, Iowa State University. My thesis was DynamicGraphics and Reporting for Statistics, advised by Di Cook and Heike Hofmann. I have developed a series of R packages either seriously or forfun (or both), such aslitedown, knitr, animation,bookdown,blogdown,pagedown,xaringan, and tinytex. I founded a Chinese website called “Capital of Statistics” in 2006, which has grown into a large online community on statistics. I initiated the China R conference in 2008. I’m a big fan ofGitHub, LyX andPandoc. I used to hate IE but no longer care since it has almost died. I fall asleep when I see beamer slides, and I yell at people who use \textbf to write \title. I know I cannot eat code, so I cook almost every day to stay away from my computer for two hours.

Author: Yihui Xie
I was introduced to this Author by this Mastodon post -hachyderm.io/@djnavarro/113477662963181887
by the Authorhachyderm.io/@djnavarro

yihui Yihui Xie

Hi there! I’m Yihui Xie. I’m a Freelancer (open source programmer, contractor, blogger, and writer)

89 repositories9.6k followers

2018

I got this tweet: Thomas Lumley on X: "Blog post, software, and preprint for my #JSM2018 talk/poster"
from this Author: Yihui Xie
from his blog post: Solving Statistical Computing Problems with SQL - Yihui Xie | 谢益辉

Hi there! I’m Prof Richard Xu. I’m a

I am a Professor at the Department of Mathematics, Hong Kong Baptist University (HKBU) 香港浸会大学数学系教授

roboticcam Prof Richard Xu 徐亦达教授

I am a Professor at the Department of Mathematics, Hong Kong Baptist University (HKBU) 香港浸会大学数学系教授

13 repositories5.1k followers

Course on Foundational Mathematics in Machine Learning 机器学习基础数学课程

Course on Intemediate Mathematics in Machine Learning 机器学习中级数学课程

Sinovation DeeCamp 创新工场DeeCAMP讲义

Deep Learning Research Topics 深度学习研究

Optimization Method 优化方法

Deep Learning Basics 深度学习基础

Restricted Boltzmann Machine

3D Geometry Computer vision 3D几何计算机视觉

Reinforcement Learning 强化学习

Natural Language Processing 自然语言处理

Data Science PowerPoint and Source Code 数据科学 PowerPoint 和源代码

Probabilistic Model 概率模型课件

Monte-Carlo Inference 蒙特卡洛推理

Advanced Probabilistic Model 高级概率模型课件

Hi there! I’m Alexander Fischer.

Data Scientist @trivago

a

juanitorduz Juan Orduz

Mathematician & Data Scientist

34 repositories577 followers

follows

s3alfisc Alexander Fischer

Data Scientist @trivago

43 repositories81 followers

Hi there! I’m Ross Wightman.

Computer Vision @huggingface. Always learning, constantly curious. Building ML/AI systems, watching loss curves.

rwightman Ross Wightman

Computer Vision @huggingface. Always learning, constantly curious. Building ML/AI systems, watching loss curves.

74 repositories6.7k followers

Hi there! I’m Miles Cranmer.

milescranmer Miles Cranmer

253 repositories1.6k followers

fix: comparison operator parsing#845

Here are the details of a specific commit from the PySR repository:

Pull Request Test Coverage Report given in #845

Changed Files:

• File Name or File Path

Create benchmark suite#1084

Here are the details of a specific commit from the JuliaNLSolvers/Optim.jl repository:

Pull Request Test Coverage Report given in #1084

This creates a simple benchmark for catching performance regressions on small, tightly controlled problems. To kick things off I added the multivariate first-order optimizers includingAdam,AdaMax,BFGS,LBFGS,NGMRES,ConjugateGradient,GradientDescent, and MomentumGradientDescent.

I also add a GitHub action to run AirspeedVelocity.jl on this benchmark for any new PR. It will automatically print out the performance and load time comparison of master in a GitHub comment on the PR.

hey, it works :) https://github.com/JuliaNLSolvers/Optim.jl/actions/runs/14055921576/job/39355263452?pr=1138

Hi there! I’m DavisVaughan.

hamelsmu HamelHusain

373 repositories2.1k followers

https://github.com/hamelsmu?tab=following

cderv Christophe Dervieux

321 repositories578 followers

https://bsky.app/profile/cderv.bsky.social

https://bsky.app/profile/davisvaughan.bsky.socialReference: Air, an extremely fast R formatter by Davis Vaughan

DavisVaughan DavisVaughan

452 repositories826 followers

Hi there! I’m Jon Shlens.

rwightman Ross Wightman

Computer Vision @huggingface. Always learning, constantly curious. Building ML/AI systems, watching loss curves.

74 repositories6.7k followers

rwightman JonShlens

1 repository86 followers

Reference: PR - Odd batch_size specific behaviour with nasnet_large on ImageNet validation #2778

Hi there! I’m Yixuan Qiu.

Currently an associate professor inSchool of Statistics and Management atShanghai University of Finance and Economics (SUFE).

djnavarro Danielle Navarro

Data scientist. Former academic. Occasional generative artist

233 repositories1.1k followers

yihui Yihui Xie

Hi there! I’m Yihui Xie. I’m a Freelancer (open source programmer, contractor, blogger, and writer)

89 repositories9.6k followers

Reference: Mastodon post - hachyderm.io/@djnavarro/113477662963181887

yihui Yihui Xie

Hi there! I’m Yihui Xie. I’m a Freelancer (open source programmer, contractor, blogger, and writer)

89 repositories9.6k followers

yixuan Yixuan Qiu

96 repositories841 followers

Reference: Yihui Xie's post - Solving Statistical Computing Problems with SQL - Yihui Xie | 谢益辉

Hi there! I’m Steven G. Johnson.

Professor of Applied Mathematics and Physics, Massachusetts Institute of Technology

stevengj Steven G. Johnson

Professor of Applied Mathematics and Physics

152 repositories1.3k followers

document/export chebvandermonde#24

Here are the details of the commit for this JuliaMath/FastChebInterp.jl repository:

https://discourse.julialang.org/t/multivariate-polynomial-regression-of-discrete-data-in-l-infinity-norm/125369/7?u=stevengj

https://gitlab.com/nsajko/FindMinimaxPolynomial.jl

https://xn--2-umb.com/22/approximation/

Random.randcycle(1) should throw?#50479

I found another paper on Sattolo's algorithm that defines cyclic permutations in a different way, which allows the identity permutation only for n=1:

AutoModel class for image-text-to-text models#32042

Hi there! I’m Thomas Stringer.

Hi there! I’m Martin Evans.

LLamaSharp

LLamaSharp is a C# wrapper around llama.cpp. This is not my project alone, but I became one of the lead maintainers last year and I've continued working on it this year.

In 2024 my major contribution to LLamaSharp was the development of the BatchedExecutor which is an entirely new low-level abstraction around language models. The BatchedExecutor is designed to expose all of the power of llama.cpp in a safe way, for example multiple parallel sequences evaluated all together in one batch is as simple as:

Sequences can be easily saved and loaded, forked into 2 sequences with the same prefix (which internally share the same space in memory), the KV cache can be accessed and manipulated (e.g. to implement context shifting), sequences can even be prompted with embeddings directly which allows things like LLava.

My long term goal for 2025 is to rewrite many of the higher level parts of LLamaSharp to operate on top of the BatchedExecutor, this will reduce the overall complexity of the project by implementing it all in one place and should offer more power to advanced users since they can always build on top of BatchedExecutor instead of using the low level llama.cpp primitives.

Hi there! I’m Martin Evans.

Martin Evans (https://github.com/martindevans) starred a repository on 5/4/25
https://github.com/MerlinVR/UdonSharp (C#) 706 STARS

Contributor Rankings

• #1 MerlinVR - 1035 commits | GitHub Profile
• #2 Momo the Monster - 54 commits | GitHub Profile

momo-the-monster Momo the Monster

80 repositories50 followers

Followings of Momo the Monster(momo-the-monster) on GitHub

Followings of Jeremy Cowles (jcowles) on GitHub

pixeljetstream Christoph Kubisch

NVIDIA

16 repositories89 followers

Visit the full article: Life of a triangle - NVIDIA's logical pipeline | Posts · 6/02/2016

Further reading

Next to the white papers mentioned at the beginning, the article series"A trip through the graphics-pipeline"by Fabian Giesen is worth a read and there is also aquite in-depth talk

Visit the Blog: The ryg blog (When I grow up I'll be an inventor)

Martin Evans (https://github.com/martindevans) starred a repository on 5/4/25
https://github.com/nietras/Llm.cs (C#) 49 STARS

Hi there! I’m Cédric Luthi.

On April 20, 2025, a Reddit user shared their excitement about completing their first significant AI project in C#, which utilized ONNX (Open Neural Network Exchange). They expressed how impressed they were by the capabilities of the ONNX framework, highlighting its ability to streamline model training and deployment across various platforms. The post detailed their journey through the project, including the challenges they faced and the solutions they discovered. The author encouraged others in the community to explore ONNX for their own AI endeavors, noting its versatility and the positive impact it had on their workflow. The enthusiasm radiating from their experience resonated with fellow enthusiasts, sparking discussions and sharing of similar projects.Link to the post - Posted on 20/4/25.

https://www.reddit.com/r/csharp/comments/1k37gj7/my_first_big_ai_project_in_c_onnx_blown_away_by/

My biggest tip is to do as much as possible on the GPU—I use ILGPU to do this, but you could also use something like compute shaders in Silk.NET, OpenTK, or ComputeSharp. — nullandkale, posted on 21/4/25

I searched in Microsoft Bing Browser with the query "ilgpu c#" and found these helpful results:Computing the Convex Hull on GPU andVectorized Computations and SIMD.

SIMD and SIMD-intrinsics in Julia

Visit the Blog Post titled SIMD and SIMD-intrinsics in Julia

Advanced Examples: Building your own PredictableModel

Basically all face recognition algorithms are the combination of a feature extractionand a classifier. The Eigenfaces method for example is a Principal Component Analysis with a Nearest Neighbor classifier. Local Binary Patterns Histograms . The feature (which must be an AbstractFeature) and the classifier (which must be an AbstractClassifier) form a PredictableModel, which does the feature extraction and learns the classifier.

Elasticsearch. The heart of the Elastic Stack

Elasticsearch is an open source distributed, RESTful search and analytics engine, scalable data store, and vector database capable of addressing a growing number of use cases. As the heart of the Elastic Stack, it centrally stores your data for lightning-fast search, fine‑tuned relevancy, and powerful analytics that scale with ease.

Anthony Sneed

https://blog.tonysneed.com/2020/06/25/event-stream-processing-micro-framework-apache-kafka/

Hi there! I’m ItamarSyn-Hershko.

CTO & Founder of BigData Boutique. Search, BigData and Cloud expert - making the cloud a better place day by day.

A number of articles have been written over the past few days documenting the various methods of securing Elasticsearch, most notably of which is this piece by Itamar Dyn-Hershko. For all our readers using Elasticsearch — especially those who are using it in production — who are not necessarily aware of the various pitfalls that need to be taken into consideration, we’ve summed up some of the methods that we recommend employing.

Hi there! I’m Marc Clifton.

http://marcclifton.wordpress.com/

Articles by Marc Clifton

Azure Function: Compute Pi Stress Test

Pretrained model hub for Keras 3.

Anshuman Mishra

Medium

• Interview with 2x Kaggle Grandmaster, Data Science Manager at Emirates NBD: Ravi Ramakrishnan
• Flux.jl is so flexible — Deep Learning in Julia
• Kaggle x Julia : Advanced House Price Prediction : EDA

add weights and conversion script for mobilenet#1875

Here are the details of a specific PR from the keras-team/keras-hub repository:

Parallel computing with task scheduling

Dask is a Python library for parallel and distributed computing.

Yoshifumi Kawai

Mohammad Elsheimy

Sam Grey Danus

Sam Grey Danus (https://github.com/greydanus) starred 2 repositories on 02/4/25
https://github.com/zwimpee/cursivetransformer (Jupyter Notebook) 3 Stars
https://github.com/zwimpee2/cursivetransformer (Jupyter Notebook) 1 Star

Both repositories, https://github.com/zwimpee/cursivetransformer and https://github.com/zwimpee2/cursivetransformer, focus on training a transformer model to generate cursive, with progress updates noted in their respective README files (February 12, 2025, and August 13, 2025).

Hi there! I’m MartinDotNet.

timdeschryver (https://github.com/timdeschryver) starred 2 repositories on 25/3/25
practical-otel/opentelemetry-aspire-collector (C#) 28 STARS
microsoft/playwright-mcp

Visit the article "Building a Secure OpenTelemetry Collector" published on 20 December, 2023 here: Building a Secure OpenTelemetry Collector

Hi there! I’m ABP.ABP

ABP offers an opinionated architecture to build enterprise software solutions with best practices on top of the .NET and the ASP.NET Core platforms.

Alexandre Mutel (https://github.com/xoofx) starred a repository on 25/3/25
abpframework/abp (C#) 13.3k STARS

ABP offers an opinionated architecture to build enterprise software solutions with best practices on top of the .NET and the ASP.NET Core platforms. It provides the fundamental infrastructure, production-ready startup templates, pre-built application modules, UI themes, tooling, guides and documentation to implement that architecture properly and automate the details and repetitive works as much as possible.

Hi there! I’m OpenTelemetry - CNCF.

Hi there! I’m Safia Abdalla.

Implement the Mvc PushFileStreamResult API#58161

Here are the details of a specific commit from the dotnet/aspnetcore repository:

Hi there! I’m Roger Koenker.

Conformal Quantile Regression pdf

Single instruction, multiple data (SIMD).

Open source software for scientific machine learning

Yunjey Choi

https://github.com/yunjey/pytorch-tutorial

Vincent D. Warmerdam

This page has all the details of the work, which include:

• A Python library that can interact with the game, which is the main entrypoint for the agents that compete in tasks.
• A leaderboard with the results of the agents that have competed so far (Claude seems the winner, but the fact that one of the authors is from Anthropic might help there).

https://github.com/JackHopkins/factorio-learning-environment

Linear Regression in Machine learning

Benoît Legat

Recommended for you:
jump-dev/MathOptInterface.jl (https://github.com/jump-dev/MathOptInterface.jl) is a data structure for mathematical optimization problems in Julia.
MathOptInterface.jl (Julia) 434 Stars
Contributors:View Contributors

Paul Berg

feat: more coverage for common NN operations#95

Here are the details of a specific PR from the EnzymeAD/Reactant.jl repository:

Benoît Legat

https://blegat.github.io/teaching/

https://blegat.github.io/ccir/practical1/

Recommended for you:
jump-dev/MathOptInterface.jl (https://github.com/jump-dev/MathOptInterface.jl) is a data structure for mathematical optimization problems in Julia.
MathOptInterface.jl (Julia) 434 Stars
Contributors:View Contributors

The Python Pickle Module

Using pickling as much as possible for serialization#966

Here are the details of a specific PR from the probabl-ai/skore repository:

fsdl-text-recognizer-2021-labsPublic

forked from https://github.com/the-full-stack/fsdl-text-recognizer-2021-labs

Here are the details of the fork of this fsdl-text-recognizer-2021-labs repository:

fsdl-text-recognizer-2021-labsPublic

forked from https://github.com/the-full-stack/fsdl-text-recognizer-2021-labs

CUDA Programming Model

Rotation_related_problems. Quarternions. Rodrigues’ rotation formula

Alex Chi Z.

Andrzej Więckowski, Ph.D.

Timur Iskhakov

Ahmet Alp Balkan(https://github.com/ahmetb) followed Anish Athalye (https://github.com/anishathalye) on 5/4/25

Ahmet Alp Balkan(https://github.com/ahmetb) starred a repository on 5/4/25
anishathalye/porcupine (Go) 1k STARS

• @cleanlab
• San Francisco, CA
• me@anishathalye.com
• anishathalye.com

Ahmet Alp Balkan(https://github.com/ahmetb) followed Anish Athalye (https://github.com/anishathalye) on 5/4/25

Ahmet Alp Balkan(https://github.com/ahmetb) starred a repository on 5/4/25
anishathalye/porcupine (Go) 1k STARS

Followings of Kritika Prakash on GitHub

I've always run the basic postgres docker image with no backups or replicas configured. Since I have a new cluster now, I thought I should try something new. I recently read aboutCloudNative PG on HN so I decided to look into it. It got high praise from the replies, which is quite remarkable for HN.

It seems to have all the features I would want from a 'managed' postgres:

• Managed backups
• Easily create a new database
• Manage secrets

Visit the Blog Post titledHow to Write a High-Performance SQL Join: Implementation and Best Practices of Joins

In fact, convolution neural networks work quite well with images, because in the worst case, you can cut the image to a certain size. For example, creating a model to recognize handwritten digits (MNIST dataset) is one of the very typical and easy-to-experiment exercises for newcomers to machine learning.

• codapi — Interactive code examples for all types of technical writing.
• redka — Redis re-implemented with SQLite.
• sqlean — SQLite extensions.

Artin Ghasivand(https://github.com/Ei30metry) followed a GitHub user on 27/6/24
https://github.com/chrisdone

📗 Recent blog posts

• Using Pattern Matching in C# for Performance Optimization
• Use C# 14 extensions to simplify enum Parsing
• StringComparison.InvariantCulture is not always invariant
• Using Snapshot Testing to validate EF Core schema
• Migrate from MSTest to xUnit using a Roslyn analyzer
• Using Roslyn to analyze and rewrite code in a solution
• Enhance Your .NET HttpClient with HSTS Support
• Exploring CollectionsMarshal for Dictionary
• Signing commits in Git using SSH keys on Windows
• Reading USN Journal with .NET

Just re-illustrating the example from the Russell book Chapter 21. Note how the unit “numbers” have changed. Give it a shot if you have literally nothing else to do. There is a reason we make computers do this.

AIMA has been called "the most popular artificial intelligence textbook in the world",^[2] and is considered the standard text in the field of AI.^[3][4] As of 2023, it was being used at over 1500 universities worldwide,^[5] and it has over 59,000 citations on Google Scholar.^[6]

Contributor Rankings

• #1 SkalskiP - 40 commits | GitHub Profile

Followings of @h3r2tic on X

Followings of @Jiayin_Cao on X

Anthony Shaw(https://github.com/tonybaloney) Created a pull request on 2/6/25
langchain-ai/langchain-community/pull/88

Harden Azure ML url validation#88

Here are the details of a specific PR from the langchain-ai/langchain-community repository:

• Institute for Geoinformatics, Universität Münster
• Münster, Germany

Passionate about technology, I am particularly committed to training myself and understanding new development best practices. From web to software, including mobile applications and IoT, I put my skills to the service of innovation, but also of transmission by giving courses at CESI in Dijon, Lille, and Nancy, and by sharing my knowledge with my colleagues whenever possible.

Scooletz (https://disqus.com/by/scooletz/) commented on 18/1/15

What does this PR do?

Use the proper squashing/activation function to calc probabilities for image-classification pipeline.

Currently 'sigmoid' is used for models with the single-label problem type. This is not correct.