Github user jkbradley commented on the issue:
https://github.com/apache/spark/pull/15843
I don't see a need to do deep copies of model summaries, but I agree I
don't like how JavaWrapper is ambiguous about whether it does shallow or deep
copies.
I'd say the confusion comes from us having a mix of immutable Java types
(like model summaries) and mutable Java types (like Params subclasses). What
do you think of these 2 options?
* Distinguish mutability within Python wrappers: JavaWrapper is usable for
immutable types. JavaParams (or other subtypes, if needed) is usable for
mutable types. I.e., ```__del__``` and ```copy``` go in JavaParams.
* Distinguish mutability within Java only: Use the same wrapper types for
both in Python, and Java copy methods can do deep or shallow copies. I.e., in
JavaWrapper, implement copy() which copies the Java instance, and implement
```__del__``` to release that instance's handle.
I don't think either option does much for enforcing these semantics.
Barring GC issues, I'd pick option 1 since it's simpler. But if option 2 is
better for GC issues, then I'd vote for it.
Thoughts?
---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---
---------------------------------------------------------------------
To unsubscribe, e-mail: reviews-unsubscr...@spark.apache.org
For additional commands, e-mail: reviews-h...@spark.apache.org
