You can make a model that is trained only with BSD and MIT code, and IIRC/IIUC the result can be used with any license, including proprietary code.

You can make a second model that is trained only with BSD, MIT and GPL2 code (and perhaps GPL2+), and IIRC/IIUC the result can be only with GPL2 code.

You can make a third model that is trained only with BSD, MIT and GPL2+ and GPL3 code, and IIRC/IIUC the result can be only with GPL3 code.

AGPL, Apache, WTFPL, ... Just add them to the correct model or create a new model for them.

BSD and MIT license still require attribution of the used source code (there exists a MIT No Attribution License, though: https://en.wikipedia.org/w/index.php?title=MIT_License&oldid...).

Which in this scenario could be accomplished by starting that “this software contains algorithmically generated code that was trained using MIT derived code from X, Y, and Z.

This attribution list would be very long, but it could be done.

I think the interesting thing here would be to compare the generated code with the original training data after the fact. If the generated code does not already exist (with some degree of similarity), then it would be okay to use. Otherwise, if it did already exist, you’d then need to attribute the authors of the chunk of code — which you’d now know.

I’m not discounting the hurdles involved, but there might be ways to overcome them.

On the other hand, open source licenses haven’t been tested thoroughly in court, so maybe the result would be to throw out such attribution requirements entirely. The main relevant case to date is https://en.wikipedia.org/wiki/Jacobsen_v._Katzer

In reality through, we'll all just end up using the MIT No Attribution License copilot.

Great, so GPL code would be left alone. I don't see how that's a bad thing.

Surely the solution would be to give credit to every author from the training corpus. I am looking forward to the 10 000 lines of copyrights in every header. :P

If Microsoft had trained it on its own code, there would be no such problems. Surely a company as large as Microsoft has produced enough code over the years to create a large enough training dataset.

I keep seeing this sentiment from the GPL/"laundering" side of the debate.

Believe me, Microsoft wouldn't have released this thing (after what, 6 months of beta testing?) if they thought they had any "problems" at all.

I'm not saying I don't sort of agree with you, but is there no room for what's actually _likely_ to happen in this debate? Because as best as I can tell, they aren't going to see any real legal issues from this.

(There's also an option to remove generations that result in a collision with actual GitHub code, just fyi)

I feel like when the singularity happens HN is going to be flooded with programmers mad that they got automated away despite it very much being one of the primary goals of computer science and software engineering. This stuff is a kind of just a fact of life now.

Salesforce trained models (on GitHub) competitive with copilot without needing to own GitHub. I would spend less time worrying about how to lawyer up and more time figuring out how you're going to adapt to these new tools. That's the gig.

The simply way to test the legal theory behind copilot would be to write a AI that write music notes, using music scraped from youtube or any other large music library. The idea that one can train on "public available material" and produce algorithms that output large chunk of copyrighted material is a bit untested in court, but go against the wrong target and we will quickly see a response. We have actually seen some traces of this with news bots that scrapes news site and produce "novel" interpretation of existing news, especially sports news.

No, we're not. Further, Amazon just announced a similar product and Salesforce has literally _released weights_ for their code models. You can't put the genie back in the bottle.

Actually enforcing any action when the representations are learned rather than hard-coded just seems impossible to me. They have a check box that removes any predictions matching existing code - that basically makes it impossible to discern the source since this will be based on some subjective "semantic closeness" BS.

They would. Did you just forget TAI? Microsoft didn't consider 4chan would train her to be the ultimate racist.

Do you work in marketing? Do you program?

I'm a machine learning engineer, amateur researcher and open source contributor. Before that I was a software engineer for 8 years.

As a person that teaches and conducts research with these models, there is no reason why a tool like Copilot has to be a purely parametric, generative transformer like GPT-3. Where attribution, as you describe it, is nearly impossible.

For example, if the model was to use a retriever component to obtain specific pieces of concrete code from a database (where the licensing for each piece is known) conditioned on the original source code context; then generate its output based on this, the context in your source code, and pre-trained parameters, then it could theoretically at least satisfy Butterick’s request and probably be more akin to how a human programmer operates.

This still does not rule out possible legal issues entirely as the pre-trained parameters are opaque, but it certainly makes it less problematic.

Alternatively, there is active research on attributing a given output to a transformer’s training data. But it is still very early days and frankly it is very “foggy” as to what degree this can be done.

Lastly, I have seen a bunch of comments elsewhere alluding to it being somehow sufficient to reduce the level of verbatim copying. Sadly, it will not, as even if you for example replace the variable names it is still a copyright violation. Just like if you manipulate the RGB space slightly for an image. Determining fair use, etc without a license is something that today can only be done in court, regardless of how we of a heavier technical disposition may feel about it. After all, that is exactly why we have explicit licenses in the first place!

That's what Copilot does with extra steps. I don't see why it should be different just because Microsoft mixed the code snippets in a blender to obscure what they're doing. It's code laundering.

using copilot is like subcontracting to a company who you know has no institutional qualms about their employees liberally copy/pasting from a known corpus of github repos. you know these employees don't always literally copy/paste, but all they do every day is read the corpus, so their code is always going to be basically derivative. you can optionally ask that the company avoids matches to existing code, which you know means that before sending you the code, the boss will fuzzy search their code against the corpus, asking their employees to write it again if a match is found.

so given that this is the way the company works, and that you know this is the way they work, your task is to decide what your ethical and legal liabilities are.

actually i'm sure you do, you just don't think of it this way. The education you received to learn to code would consists of such snippets and examples. Then you sell your skill as a programmer, which consists of you recalling past experience and knowledge, and transform that into the final piece of code.

Copilot is merely doing something like that, but way less sophisticated than a human brain.

I think this will require looking at some actual examples to try to judge, and figure out how to articulate the basis for the judgement.

Hm. That begs the question what good is it if it deals in such small bits? I guess that means if the snippets are large enough to be of any value at all, then they are automatically big enough to be damning.

Analogy: the law has no problem with you memorizing the license plates of cars you see as they pass your street; however, building an automated system for recording and storing license plates in a database is a different story.

Attribution would still be a problem though. How to attribute generated code that's a random mishmash from thousands of inputs? The only solution can be to attribute all of them by doing some sort of reverse match. This "IP scanning" must clearly also be provided by Copilot and not be offloaded to the user.

TBH I would have expected that the "evil geniuses" who came up with Copilot would have thought about such obvious pitfalls beforehand. It's not much of an achievement to innovate by ignoring the law.

Assuming the generated code does not exist and is not part of the training set (these are two giant caveats), how would this be different from me reading GPL code to learn how to do something, and then rewriting it in my own words?

If I have not copied, but learned from GPL code, is my new code GPL? No, it’s not a derived work in terms of copyright. Am I standing on the shoulders of giants? Yes. But so long as that concept is expressed in a novel way (not just changing variable names), then it isn’t a derivative work.

I haven’t worked with copilot at all to know how verbatim the results are, but it is theoretically possible to train a model with GPL code and not get GPL code generated out the other side. (Again, here be dragons).

No different - that is also not allowed. The idea of clean room reverse engineering exists exactly for this reason.

My understanding is the GPL based on copyright - and that copyright only protects a specific expression, not a general idea or concept. To suggest that if something is copyrighted, humans cannot learn from it and generate thier own material seems to be absurd.

But will it be capable of generating a copyright infringement? Let's imagine I want to implement an algorithm to find the shortest path between nodes in a graph. Well I remember from my MSc that you probably need to implement it with Dijkstra's algorithm, and I've implemented this a few times over the years in kata and leetcode. Now let's say I'm programming Rust, which I don't really know the syntax for so I go read some GPL code while browsing the net for syntax.

Do I need to state that my implementation of Dijkstra's algorithm is 10% GPL, because I spent a few minutes reading syntax of a GPL file? What if someone else's copyrighted code looks 90% similar to mine, because hell there's only so many ways to implement it, can I get sued because there is 90% overlap and I might have looked at this code?

These systems aren't even capable yet of generating more than a a few functions, much less a coherent library. Even then, as they generalize more and gain more expressive power they will be less likely to copy in the training data to the output now, a possibility that I consider quite remote even given a relatively primitive Co-Pilot.

When you write your implementation of Dijkstra's algorithm then you hopefully using human intelligence to write it, not an illusion of intelligence. If its original then its 0% of whatever GPL file you happen to have read at a previous date. If you copy something verbatim without using human intelligence, then its 100% GPL.

True artificial intelligence == magic. if not magic then math.

At least according to Google’s monetization policy when it comes to music.

In particular an algorithmic concept cannot be copyrighted but a description of an algorithm in code can be. I think that many programmers believe that the algorithm is the copyrightable bit because that is the “hard part” compared to say the variable names and comments which are the easy part. But copyright cares much more about the latter than loops and conditionals, which have much less creative value. Mathematical expressions cannot be copyrighted.

But of course this wouldn't catch copies where variable names have been changed, etc. One thing that I think would be really interesting (but hideously computationally expensive) is to compute an embedding of each chunk of the training data and then query for the k nearest neighbors when Copilot generates some code, so you can see what the closest snippets in the training data are and evaluate for yourself if they're too similar.

Checking generated code for similarity against training set is possible, and is now done by both Copilot and CodeWhisperer. But it'll include code that just happens to be similar, even if that code had no influence on what the model generated.

I was finding the copilot trial was pretty good at reading something like an adjacent CSV file and building out a struct with proper data types from the data in it but beyond writing CSV->DB migration stuff I didn't really use it for a lot