datamininggroup / pfa Goto Github PK

The spec for the function
m.ln1p defines it as ln(1+ x^2). This is surprising because the normal definition, is ln(1+ x). This aligns with the classic Taylor series (the Mercator series) and java.lang.Math.log1p.

Looking at the code for hadrian, I see that the implementation is actually java.lang.Math.log1p.

I can verify this by running the PFA script

input: double
output: {type: array, items: double}
action:
  - new: [{m.ln1p: [input]}, {m.ln: [{+: [1, input]}]}, {m.ln: [{+: [1, {"**": [input, 2]}]}]}]
    type: {type: array, items: double}

and seeing that the output for the first value matches the second, not the third.

So I think we should change the spec to say ln(1+ x).

N.B. Originally filed as modelop/hadrian#10

Shall we use Github Issue tracking and manage all aspects of the PFA standard in Github?

Hi all,
thanks for the telephone conference, I think it was a good start. I asked the question regarding filtering rows because in KNIME I was dealing with that when I rewrote our Missing Value node in KNIME. It now supports PMML, but there you don’t really have the notion of removing rows from your input. So while replacing missing values by other values is easy to specify in PMML, saying „Remove any row that contains a missing value in column X“ is not possible, as far as I know. There are other nodes that also filter rows in KNIME, so having this in PFA would in my opinion be really helpful.
Regards,
Alexander

There are many products and open source packages that produce PMML, not so many for PFA. To help PFA to get wider adoption, a converter from PMML to PFA will be immensely helpful.

From PFA.general Slack:

srki [6:11 AM]
Yes, it is clear for the polynomial regression. But if we need for instance to feet a smoothing spline function (smooth.spline {stats} from R) which is not straightforward to compute, we would practically need to translate the code of smooth.spline() into PFA expression using available PFA functions, right?

pivarski [1:21 PM]
Yes. I didn't think of "canning" spline functions as named PFA callables, but that's not a bad idea. If I remember right, spline handle positions are something like a factor of three bigger or smaller than a tangent line to the curve at the control point. It's derivable, but maybe not fun to derive. That would be a good candidate addition to the "m." (math) module.

IN GROUP: https://groups.google.com/a/dmg.org/forum/#!topic/pfa-standard/I160ZPLu1UE

How would we implement the following in PFA?

http://dmg.org/pmml/v3-2/ModelVerification.html

Thanks!
Stu

GitHub moved the conformance tests to Git LFS storage since it is a very large file. However, I am having trouble pulling the file down with git lfs extension. I am receiving the following:

~/Code/pfa (master)$ git lfs pull origin master
Git LFS: (0 of 1 files, 1 skipped) 0 B / 238.24 MB, 238.24 MB skipped
[404] Object does not exist on the server
[64d83b7dfa013c4193b2f9743f8a40e1ea20d9dede879ccead653df074c7906c] Object does not exist on the server

Basically it thinks the file doesn't exist on the GitHub LFS server. Any thoughts? Am I the only one having this issue?

Suggested topics: pfa-standard, data-science

Should support for tensor flows be added to the PFA specification

This is the example for creating a map with the "new" special form.

It looks like the type definition was copied from the array example, so it says

{"new": {"p0": 1, "p1": "x", "p2": {"**": ["x", 2]}},
 "type": {"type": "array", "items": "double"}}

when it should say

{"new": {"p0": 1, "p1": "x", "p2": {"**": ["x", 2]}},
 "type": {"type": "map", "values": "double"}}

We would like to add new standard elements to PFA that would contain information for model visualization, similar to ModelExplanation and ModelStats in PMML. They would probably go into "metadata". Working on more detailed proposal.

Hi,
I just noticed that on the page http://dmg.org/pfa/docs/tutorial2/ the link to the exoplanets example is http://dmg.org/docs/exoplanets, but should be http://dmg.org/pfa/docs/exoplanets/.

1. In the function library I see this in the description of "+" and some other functions:
   Details:

   Float and double overflows do not produce runtime errors but result in positive or negative infinity, which would be carried through any subsequent calculations (see IEEE 754). Use impute.ensureFinite to produce errors from infinite or NaN values.

Runtime Errors:

#18000: Integer results above or below -2147483648 and 2147483647 (inclusive) produce an "int overflow" runtime error.
#18001: Long-integer results above or below -9223372036854775808 and 9223372036854775807 (inclusive) produce a "long overflow" runtime error.

So first it says that there are no runtime errors for overflow, then it says that there are.
It would be good to decide on one of those.
Or maybe there are only if impute.ensureFinite is used? How can one use it?

Hello,

I do not know if it is a problem specific to Hadrian pfainspector tool, but when I define a type in the output section and attempt to reuse that type in another section (a cell), pfainspector complains that the document is not valid PFA. The specification does not really say that a type defined in one section of the document may be used anywhere, but this is what I would expect especially as namespaces are used to isolate types into families of types.