Copyright of Items Produced by Artificial Intelligence

Copyright Law Article
Article On
Copyright of Items Created By

Artificial Intelligence
Assignment Under The Guidance Of: Prof S. Matilal
FROM
“RAJIV GANDHI SCHOOL OF INTELLECTUAL PROPERTY LAW, IIT KHARAGPUR” ON
COPYRIGHT LAW
Prepared By:
Sourish Roy - LL.B. Batch 2017-20

Table of Contents
A) Introduction .....................................................................................................................................- 2 -
B) Issue .................................................................................................................................................- 9 -
C) AI Operation ..................................................................................................................................- 17 -
D) Possible Approach .........................................................................................................................- 23 -
E) Legal Personality of AI as Employee ............................................................................................- 28 -
F) Conclusion .....................................................................................................................................- 31 -
G) References .....................................................................................................................................- 33 -
H) Appendix .......................................................................................................................................- 34 -
1. HMM_Categorise_Record Class: ...........................................................................................- 34 -
2. HMM_Format_Input_Files Class: ..........................................................................................- 43 -
3. HMM_Generate_Model Class: ...............................................................................................- 44 -
4. HMM_Merge_Files Class: .....................................................................................................- 52 -
5. HMM_Parameter Class: .........................................................................................................- 54 -
6. HMMDetection_New_MapR Class: ......................................................................................- 54 -
7. HMMKMeans Class: ..............................................................................................................- 65 -
8. HMMMain Class : ..................................................................................................................- 68 -
-1-
Artificial Intelligence (AI) and Copyright:
A) Introduction - With the advent of high-end computing power, advanced algorithms

along with Big Data analytics, more and more items are being produced by artificial
intelligence (AI) - be it artworks, predictive analysis reports, literary articles and even
speech and music. In this article we shall strive to analyze this new source of creative
work, with the underlying copyright issues in mind and the challenges and
shortcomings of existing laws with regard to the same.
In proceeding to figure out whether copyright subsists in works created with the aid of
artificial intelligence, we shall briefly look at the three triads of protection through
copyright i.e. originality, idea & expression dichotomy and fixation - along with
ownership and authorship. In doing so, we’ll look at some legal provisions, primarily
the law in India and the U.S.A. along with other aspects of copyright. Thereafter we’ll
see where artificial intelligence and works created through it fits in this matrix.
“Section 13 of the Indian Copyright Act protects by statute - the copyright, in ‘original’
literary, dramatic, artistic, musical works and also cinematographic films and sound
recordings; among other works.” In an infringement suit for copyright the plaintiff
would necessarily have to establish the originality of his creation, if it is a work of the
above mentioned types; except films. It is to be noted however, that the word
“originality” is itself not defined in the Act. Courts in India have relied upon several
doctrines laid down in copyright cases of other jurisdictions like the UK and the US;
for their judgments. Moreover, for cinema\films and recordings of sound of any kind,
the word ‘original’ is not mentioned as a requirement.
From the standpoint of originality, for eligibility of copyright two conditions have to
be satisfied -
(i) it should not be copied from others and
(ii) it should satisfy the threshold of originality;
The Privy Council, though its judgment in the early case of “Macmillan & Company
Ltd. v. Cooper”1, accepted for India the British standard - that “copyright over a work
emerges and subsists in that work due to the skill and labour that goes behind creating
that work, and does not necessarily involve inventive thought”. The doctrine here is
also known as the ‘labour theory’ or the “sweat of the brow” theory – established in UK
in the celebrated case of “University of London Press v. University Tutorial Press”2.
On the other hand, the USA, consequent to the decision of its Supreme Court in “Feist
Publications v. Rural Telephone Service”3, had set aside the ‘sweat of the brow’ theory;
1
(1924) 26 BOMLR 292
2
[1916] 2 Ch. 601
3
499 U.S. 340 (1991)
-2-
opting instead for what is called the “modicum of creativity” test - laying down that
originality subsists in a work only in such cases where considerable intellectual faculty
and considered decision-making had to be invested for creating the work. The Apex
Court in post-independence India, in the seminal case of “Eastern Book Company v.
D.B. Modak”4, had departed from the ‘sweat of the brow’ theory to take a middle path
by following the judgment of Canada’s Apex Court in “CCH Canadian Ltd. v. Law
Society of Upper Canada”5. It is this case had first postulated the midway principle of
“non-trivial, non-mechanical application of labour, skill and judgment” and the
judgment of the case defines these three terms as well. Again, apart from originality,
there is the question of idea-expression dichotomy, whereby it is well accepted that it
is the expressions of ideas that are protected but not the ideas per se. So the mere supply
of an idea does not entitle a person to copyright protection it; but it is only the
expression of an idea can be copyrighted.
In the US, the Copyright statute 6 states - ”(a) Copyright protection subsists, in
accordance with this title, in original works of authorship fixed in any tangible medium
of expression, now known or later developed, from which they can be perceived,
reproduced, or otherwise communicated, either directly or with the aid of a machine or
device. Works of authorship include the following categories:
(1) literary works;
(2) musical works, including any accompanying words;
(3) dramatic works, including any accompanying music;
(4) pantomimes and choreographic works;
(5) pictorial, graphic, and sculptural works;
(6) motion pictures and other audiovisual works;
(7) sound recordings; and
(8) architectural works.
(b) In no case does copyright protection for an original work of authorship extend to
any idea, procedure, process, system, method of operation, concept, principle, or
discovery, regardless of the form in which it is described, explained, illustrated, or
embodied in such work.”
So both in India and the US, originality is a requirement for protection through
copyright. In “Mazur v. Stein”7, Supreme Court of US had stated "Unlike a patent, a
copyright gives no exclusive right to the art disclosed; protection is given only to the
4
AIR 2008 SC 809
5
2004 (1) SCR 339 (Canada)
6
17 U.S. Code § 102
7
347 U.S. 201, 217 (1954)
-3-
expression of the idea-not the idea itself". The US Congress has, since then, assimilated
this into the Copyright statute of United States which states: "In no case does copyright
protection for an original work of authorship extend to any idea, procedure, process,
system, method of operation, concept, principle, or discovery, regardless of the form in
which it is described, explained, illustrated, or embodied in such work."8. Additionally,
Congress has stated that a "[c]opyright does not preclude others from using ideas or
information revealed by the author's work.". But in case of AI, very often it so happens
that the human creator supplies only the idea and the actual protectable expression is
created by the AI software.
Regarding ownership, Indian Copyright Act9 states -
“First owner of copyright:- Subject to the provisions of this Act, the author of a work
shall be the first owner of the copyright therein: Provided that—
(a) in the case of a literary, dramatic or artistic work made by the author in the course
of his employment by the proprietor of a newspaper, magazine or similar periodical
under a contract of service or apprenticeship, for the purpose of publication in a
newspaper, magazine or similar periodical, the said proprietor shall, in the absence of
any agreement to the contrary, be the first owner of the copyright in the work in so far
as the copyright relates to the publication of the work in any newspaper, magazine or
similar periodical, or to the reproduction of the work for the purpose of its being so
published, but in all other respects the author shall be the first owner of the copyright
in the work;
(b) subject to the provisions of clause (a), in the case of a photograph taken, or a painting
or portrait drawn, or an engraving or a cinematograph film made, for valuable
consideration at the instance of any person, such person shall, in the absence of any
agreement to the contrary, be the first owner of the copyright therein;
(c) in the case of a work made in the course of the author's employment under a contract
of service or apprenticeship, to which clause (a) or clause (b) does not apply, the
employer shall, in the absence of any agreement to the contrary, be the first owner of
the copyright therein;
4 [(cc) in the case of any address or speech delivered in public, the person who has
delivered such address or speech or if such person has delivered such address or speech
on behalf of any other person, such other person shall be the first owner of the copyright
therein notwithstanding that the person who delivers such address or speech, or, as the
case may be, the person on whose behalf such address or speech is delivered, is
employed by any other person who arranges such address or speech or on whose behalf
or premises such address or speech is delivered;]”
8
17 U.S.C. § 102(b) – [1988]
9
“The Copyright Act 1957” - Section 17
-4-
The copyright law in the US has a provision for the concept of “work made for hire”
(“work for hire” or “WFH”) which is different from “commissioned work”. The former
case i.e. WFH is essentially copyright of the work (e.g. literary, artistic, musical product,
etc) that is created by salaried employees in course of their employment in an entity or
under a person. Though this includes a handful of exceptions of some works, the
copyright for which all interested parties agree by written contract to some specific
clauses and terms, in majority of circumstances the copyright in this case belongs to the
employeer. “Work for hire” is actually a term defined in the US statute10, and so it
cannot ordinarily come up simply because the parties to a contract decide to regard it a
“work for hire”. It deviates from the general parlance that the creator of a creative work
is the “author” of that work under the copyright statute and hence should thus be legally
recognized as the de facto copyright owner. This is done in order to encourage
investment in the resources and facilities required to produce such work. Going by
Copyright Act of US and also in some other jurisdictions, if a work is "made for hire",
the employer and not the creating employee is regarded as the author – by law. This
principle elaborated here is also called “corporate authorship” in certain contexts, where
the underlying principle is that financial and other backing to the employee’s efforts is
at the behest of the business house. The employing entity may be a company, a business
house an organization, a newspaper, a society or even an individual.
The circumstances where a creation is to be taken as a "work made for hire" is given in
the “United States Copyright Act of 1976 as11 either -
(1) a work prepared by an employee, within the scope of employment; or
(2) a work specially ordered/ commissioned for use, as a contribution to a collective

work, as a part of a movie or other audiovisual work, as a translation, as a
supplementary work, as a compilation, as an instructional text, as a test, as answer
material for a test, or as an atlas - if the parties expressly agree, in a written instrument
signed by them, that the work shall be considered as a work made for hire.”
Situation (1) governs the situation if and only if the work is done i.e. created by a person
in payroll i.e. an “employee”, and not by an “independent contractor”, as defined by
statute12. The “common law of agency” determines the status of the individual for the
purpose of the “work made for hire” doctrine - as a contract employee or contractor for
commissioned work. The judiciary would take into account several factors to determine
whether the relationship between the parties can be designated as employer-employee
and would thereby come under the purview of “work made for hire”. In the famous US
Supreme Court case “Community for Creative Non-Violence v. Reid”13, the court
affirmed that common law of agency is the applicable rule to distinguish the rights of
employees of a legal entity from independent contractors commissioned by that entity;
10
17 U.S.C. § 101
11
17 U.S.C. § 101
12
US Copyright Office, Circular 9: Work-Made-For-Hire Under the 1976 Copyright Act
13
490 U.S. 730 (1989)
-5-
when it comes to the applicability of the “work for hire” doctrine. The Court gave the
reasoning for this as follows:
“In determining whether a hired party is an employee - under the general common
law of agency, we consider the hiring party's right to control the manner and means
by which the product is accomplished. Among the other factors relevant to this
inquiry; are the skills required, the source of instrumentalities and tools required, the
location where the work was done, the duration of relationship between the parties,
whether the hiring party has the right to assign additional projects to the hired party,
the extent of the hired party's discretion over when and how long he would work for
that purpose, the method of payment for the work done, the hired party's power and
discretion in hiring and paying his assistants for the work, whether the hiring party
is in the business, the provision of employee benefits in the contract and also the tax
treatment of the hired party. These are embodies in the Restatement § 220(2), which
set forth a non-exhaustive list of factors relevant to determining whether a hired party
is an employee or not.”
By contrast, if the work is made by an independent contractor brought in for that task
i.e. freelancer who is hired temprarily, the work is to be considered as a “work for hire”,
only if all of the conditions given below are satisfied:
1. “The work must come within one of the nine limited categories of works listed in
the definition above”, namely -
a) “a contribution to a collective work”,
b) “a part of a motion picture or other audiovisual work”,
c) “a translation”,
d) “a supplementary work”,
e) “a compilation”,
f) “an instructional text”,
g) “a test”,
h) “answer material for a test”,
i) “an atlas”;
2. “The work must be specially ordered or commissioned”;
3. “There must be a written agreement between the parties specifying that the work
is a work made for hire - by use of the phrase work for hire or work made for hire.”
In other words, simply the existence of an agreement\ contract that a work is a “work
for hire” would just by itself not suffice to establish a work as a “work for hire”. So, in
-6-
spite of the existence of such mutual agreement, all rights accruing from the output
creation can remain with the actual creator and not pass to the employer if the above
test is not satisfied. Again, it also has to be a negotiated agreement, though may not be
signed, before the work starts and not a one-sided contract. Also, “work for hire” of
retroactive nature, would not be recognized as such – “Schiller & Schmidt Inc. v.
Nordisco Corp.”14.
The “US Copyright Act (title 17 of the U.S. Code)15 defines a work made for hire in
two parts:
A) a work prepared by an employee within the scope of his or her employment
or
B) a work specially ordered or commissioned for use -
1 (a) to (i) (supra)
….if the parties expressly agree in a written instrument signed by them that the work
shall be considered a work made for hire.”
The US Supreme Court’s judgment in “Community for Creative Non-Violence” case

(supra) laid down the test for “work made for hire”. The test first ascertains if the
outcome of the effort (i.e. the work) is created by -
“by (a) an employee or by (b) an independent contractor”
If it is by an employee of a person or that of a legal entity, then part ‘A’ of the definition
above applies and the work will be held as a “work made for hire”. It is to be noted
however, that for copyright determination, “employee” means an employee as
understood common law of agency; and not in the ordinary sense of the term by usage.
Part ‘B’ of the definition above applies if an “independent contractor” was appointed
and he created the work and as such it was “specially ordered or commissioned” by
some requisitioning entity as mentioned earlier. An “independent contractor” is not
considered as an “employee” under the concept of the general understanding of the
common law of agency. A work of a freelancer i.e. independent contractor would
legally considered as a “work made for hire” only if -
(a) “it comes under any one of the nine categories of works listed in (a) to (i) above”
and
(b) “there is an express written agreement between parties” and
(c) “such agreement specifies that the work is a work made for hire.”
14
969 F2d 410 (1992)
15
Section 101
-7-
The US Supreme Court in “Community for Creative Non-Violence” (supra), identified

the constitutive elemenrs of an “employer-employee” relationship governed by agency
law. The factors to determine who is an “employee” fall into “three broad categories,
as below -
1. Employer’s control over the work being done. For example, the employer dictates
and manages how the work is to be done, provides the space of work and the timings
for the same, and provides the equipment or other means – physical and\or financial;
for creating the work concerned.
2. Employer’s control over the employee; in this case the person actually working.
For example, the employer controls the employee’s mode and timings in the effort
put in, sets targets for progress to be made,can make the employee perform other
assignments in between, determines the method of payment to the person employed,
and \ or has the right to hire the employee’s assistants, to be involved in creating the
work. So the level of control exercised is an important criteria.
3. Status and conduct of employer, in relation to the employee. For example, an

employer in the business to produce specific types of work, provides the employee
with benefits - regular or one-time, financial or otherwise, and \ or withholds tax from
the employee’s financial payment as per IRS guidelines to be deposited with the
government.”
However, these are only indicative – clarity is lacking in determining which of these
factors must be present and which are optional; in order to prove the relationship
through employment as a “work-for-hire” case. Moreover, the court’s view was that
“mere supervision or control” over creation of the work, by itself, is not to be considered
as “controlling”. It is obvious that for most practical purposes, bulk of these constitutive
elements are characteristic features of a regular salary-based employment relationship.
It is implied that the output of an initiative under the purview of employment under
such conditions, is a “work made for hire”, unless a contract to the contra
y existrs between the parties which stricto-senso follows of the provisions of the process
mentioned earlier for “commissioned works”. Examples of such “works made for hire,
created in an employment relationship” are -
 A software program in a specific language that is developed by a computer

programmer or a group of developers, within the scope of his/ their duty as
employees in a information technology company
 A newspaper or magazine article written by a journalist in regular payroll of a

media house for publication in their newspaper or news website - which employs
him as a reporter (and not as a freelance writer)
 A musical composition by a musician in the music production company’s payroll
 A sound recording that is the work by the staff who does recording job on salary in
voice recording company
-8-
The closer the employment-relationship comes to being a regular, salaried employment;

the greater is the likelihood of it be considered a work made within the purview and
scope of such employment and thus fitting the definition of a “work made for hire”. No
absolute statutory standard exists in the first part of the definition in “Section 101 of
the US copyright law” cited above; for determining whether a work is “made for hire”.
So there are opposing legal views at times. Nevertheless, if a work is “made for hire”,
the employer or other entity for which the work was prepared would be regarded as the
owner for the purpose of copyright registration.
Thus, unless there is a contract to the contrary, the employer whose requirement and
resources were behind the ultimate outcome is the first legal owner of the copyright on
the work created.
The debate begins from here.
Works of Artificial Intelligence (AI) and Copyright Premises:
B) Issue – Regarding products that are output of artificial intelligence, there are two
schools of thought:
One group postulates that ownership of copyright should be extended to non-humans

i.e. the AI machines - hardware and software combined. The other advocates that
instead of expanding the ambit of “authorship” to include “non-humans”, it would be
much more appropriate and manageable to interpret the terms “employee” and
“employer” in the “made for hire” test; in a manner that would be more in line with the
needs of the modern era. Thus AI would be treated as employees. There is a third group
that says that there should be no copyright protection to AI-generated material and they
should be fully in the public domain.
As increasing number of creative works started getting generated by non-human (AI)

authors, there was a demand for acknowledging computer algorithms and learning
machines as owners of the copyrights therein. The U.S. Copyright Office, however, was
circumspect and rather reluctant to accept this faculty of AI in the creative process and
did not allow copyrights of non-human works. Thus on release, they came to be part of
the public domain. It treated AI in a manner similar to the output of normal computer
programs; where the output belonged to the programmer or the company for which the
computer and the program was installed. Experts also considered this sufficient till the
advent of AI, as the copyright ownership of works which were computer-output was
not in dispute and called “computer-generated” work. The computer program creating
it was nothing but a digital implement in aid the creative process that resulted in the
outcome - the mental faculty of the author being the actual source of creation, much
-9-
like a pen and paper for literary work. Authors of creative works were regarded as the
creator of the expression (not idea), if the computer generated works are sufficiently
original. Most jurisdictions still require a human author - for the work to be considered
original, as cited in the beginning of this paper. Copyright laws of some countries, like
Spain and Germany, even explicitly specify that only works of a human being would
be considered eligible for copyright protection.
But gradually, with the advent of higher and higher computing power, artificial
intelligence systems are invented – in which the computer program is now more than a
mere instrument for repititive instruction execution. It is far different from the object
computing i.e. of meeting the requirement of creating similar repetitive output in a
somewhat assembly-line mode. Rather, nowadays advanced decision systems, which
have replaced traditional workflow systems, actually make many of the dynamic logic
and branching involved in the computational steps that go to create the final output. So
there is now a process without human intervention, giving the expression to the idea -
in the form its output. It can be argued that this distinction is still not too wide as to
entail a separate law, but the way the legal system determines the copyright issues
relating to these hitherto unknown types of machine-driven creativity could have much
impact on business aspect of AI. Such artificial intelligence systems are increasingly
being applied to generate works in music, animation, text writing, forecasts and video
games, among others - the nature of the output being quite original. These works could
in theory, be deemed as belonging to public domain because they are not created by a
human being - hence, not copyrightable, even though original. As such, they would be
freely available for any use by anyone, wanting to use them for any purpose. That would
be a clear disincentive for the companies creating and trying to generate revenue by
selling these works. For example, investment in an AI system that creates music for
animation albums and cartoons, would not flow in if that such music is not under the
purview copyright law and can be used by anyone without royalty payment; in absence
of the system owners’ business interest protected by copyright law.
This would, in turn, not only discourage new creation through AI but would
undoubtedly stifle new investment in automated decision-based computer systems -
which have the potential to generate a lot of new and creative work cheaper and faster
- which would in turn have a salutary effect on mankind at large. Such systems are
costly and require high-end expertise; so if investors find that creations generated
through machine learning based decision systems do not qualify for copyright
protection, they would not invest in them. The reason is obvious business sense - there
would be no assured revenue stream to recoup the costs. The effect would be that the
much needed investment in creation and installation of such systems would not come
in. Deployment of AI to handle time-consuming innovative and creative endeavors as
also mission-critical forecasts is critical to the future progress of technology - given the
savings that can accrue in personnel costs and the impossibility of humans to meet
iterative output to perfection within such compressed timelines.
- 10 -
Copyright law can operate in several plausible ways where such works with minimal
or non-existent human effort are concerned. There can be complete denial of any
protection through copyright for works generated by a AI-based computer system; or it
can give copyright of such products to the inventor of the AI-program; or to the person
who actually ran the AI-syetm to initial specifications to produce the ultimate outcome;
or the investor at whose instance the system is created or deployed.
Another somewhat outlandish suggestion, is to attribute copyright to the AI system

itself. While, copyright in AI-produced works have not really been explicitly denied or
prohibited in general, the laws in many jurisdictions do not allow for “non-human
copyright” ownership. For example, the US Copyright authority has specifically laid
down that it will “register an original work of authorship, provided that the work was
created by a human being.” This approach of the Copyright office originates from case
laws (e.g. “Feist Publications” (supra)) which specify that copyright law will only give
protection to “the fruits of intellectual labor” that “are founded in the creative powers
of the mind”. Similarly, in an Australian case (“Acohs Pty Ltd v Ucorp Pty Ltd”), the
court there declared that the outcome generated with the application of a computer is
not a work that could be considered eligible for protection under copyright law. The
reason cited by the court is – “it was not produced by a human”. The Court in Europe
i.e. the Court of Justice of the European Union i.e. CJEU has also held on several
occasions, most notably in the case of “Infopaq International A/S v Danske Dagbaldes
Forening”, that copyright would only apply to original works, and added as an adjunct
condition that such originality must bring out the “author’s own intellectual creation”.
This can be generally understood to point to the stand that an original work must
necessarily reflect the author’s own thinking and his human personality, which in turn
necessarily implies that a “human author” is necessary pre-condition for copyright to
subsist on the work.
Another option which advocates giving authorship to the AI programmer or the

corporation for which the programmer/ developer works for gain; would benefit the
investor who has purchased the AI software system for consideration. This is the line
taken by a few jurisdictions like India, Hong Kong (SAR), New Zealand, Ireland, and
the United Kingdom. This view is best elucidated in UK copyright law, called the
Copyright, Designs and Patents Act (CDPA), in which Section 9(3) lays down:
“In the case of a literary, dramatic, musical or artistic work which is computer-
generated, the author shall be taken to be the person by whom the arrangements
necessary for the creation of the work are undertaken.”
In addition, Section 178 of the same Act has a statutory definition of a computer-
generated work as one that “is generated by computer in circumstances such that there
is no human author of the work”. The reason for introducing such provision is to create
an exception to the “human authorship requirements” by recognizing that copyright
protection should come in as a reward for the work that goes into creating an algorithm-
based computer program capable of generating output, even though the actual creative
- 11 -
faculty and expression of idea is coming from the machine and not directly from the
man. Such output, if created directly by a man would have been considered
copyrightable – but here it is extended to the man behind the machine. Thus it addresses
the issue that has been plaguing most other copyright jurisdictions.
This leaves scope for debate as to who should the copyright law consider to be the
person making the necessary “arrangements” for the work being generated - the
ultimate output. Would it be the programmer\developer or the user\buyer of that
program? In the analogue world, this is analogous to debating whether copyright should
be conferred on the manufacturer of the writing instrument or the actual writer. Thus
the debate may seem silly at the first glance. But in the digital world the situation is not
so prosaic.
First let us take a simple situation - the case of Microsoft Word or Excel or PowerPoint;
which form part of MS Office suite. Microsoft developed the programs but obviously,
does not own every creative work produced by using that software; where it is a mere
tool. In this case, say for MS Word, the copyright lies with the ultimate user, i.e. the
author who purchased the program for use as a writing tool; and used it as such to create
his own literary work. However, if we go one step further, the haziness regarding this
distinction starts coming in – from elementary programs to decision systems to machine
learning and finally to artificial intelligence systems – the difficuly of determination of
actual contribution progressively increases.
When it comes to artificial intelligence algorithms, they are capable of generating a

finite output almost by themselves, the human user’s input to the creative process may
be very nominal – perhaps simply be to pressing a few buttons or keying in a few
boundary parameters at the start so the machine can do initiate its own series of action,
which by the way is creative action leading to the ultimate outcome. It can even decide
the path and process for the same in course of such creative process; based on the
machine learning and can also improve upon this learning as it handles more and more
data. We shall see this in a later example in details. There already exist several text-
generating machine-learning algorithms – available at varying pricetags, and even
though this is an emerging area where research is ongoing, the available results i.e. the
final expression is already beyond ordinary human expectation or imagination. Stanford
PhD student Andrej Karpathy taught an ANN (artificial neural network) to read text of
specific authors, decode the writing style, identify patterns and then compose sentences
in a particular style. It successfully generated Wikipedia articles and theatrical dialogue
that resembled the dramatic language of Shakespeare. More recently, Google has come
up with similar algorithms that would talk in human voice and interact with both human
manager as well as IVR to book seats in a restaurant for a person - it even chooses from
alternatives and suggests changes. This finds reflecion is Oxford dictionary definition
of artificial intelligence as “a computer system which is able to perform tasks which
normally requires human intelligence”.
- 12 -
Some case laws seem to suggest that this issue could be addressed on a case-by-case
basis, pertaining to the facts in question. For example, in the English case of “Nova
Productions v Mazooma Games”16, the Court of Appeal when faced with issues
relating to the authorship of a computer-based gaming module, held that a player’s input
“is not artistic in nature and that he has contributed no skill or labour of an artistic kind”.
So considering user action on a case by case basis could be a possible solution to the
question of determination of who would be the owner of copyright. Facts of real-life
cases are becoming more convoluted as use of artificial intelligence by artists are
becoming more prevalent especially in commercial artistry; and as the machines
become more advanced and more intelligent in terms of decision-making while
producing creative outcome. The distinction between artwork that is made by a human
and that made by a computer are becoming increasingly difficult to determine in the
sense that how much creative input is supplied by either entity – will it then be a case
of joint authorship? It makes one ponder.
Recent strides in computing power and the advent of Big Data analytics have enabled
machines to be imbibed with the capacity to learn styles and patterns from large datasets
of existing content. The datasets need not be numerical parametric data in tabular form
but actual prior works of art, like photographs or music from which the AI would
machine-learn the styles. The requirement of costly high-end server grade machines for
this purpose is also no longer there as Hadoop technology can generate comparable
computational power through an assembly of ordinary commodity-grade computer
hardware. The hardware cost of an AI system is thus drastically reduced - making the
cost of the hardware much less than the software. This, along with decision algorithms
have made them better at mimicking humans and that too at a much smaller cycles of
iteration. Given enough computing power, there may be a situation in the near future
there would be difficulty in distinguishing between human-generated and machine-
generated content. So it would be imperative to have to develop a jurisprudence for
determining the type of protection, if any, should be given to such new genre of artistic
works created by intelligent algorithms; where little or no human intervention is
involved. Copyright laws need to evolve to protect the fruits of such sophisticated
artificial intelligence - claimants would be the developers of AI, the parties that install
them and the AI system itself. The alternative of not granting copyright simpliciter, per
se to such works seem to go against the need for protecting creative works – that of
granting a temporary monopoly to intellectual property to encourage creation.
Granting of copyright of the outcome, to the person who initiated the creative operation
of artificial intelligence could be the most sensible approach, as such the UK’s model
could be the most viable from a business standpoint. Such a jurisprudential approach
could get on-the-ground success – the reality test; in that corporations would be
encouraged to invest in the technology, safe in the knowledge that they will get a return
on their investment. But the questions may arise when the person who is the creator or
the investor behind the AI system is different from the person who is supplying the
16
[2007] EWCA Civ 219
- 13 -
large datasets for machine learning. These datasets or existing work details are critical
to be quality and accuracy of the ultimate product created by AI. The degree and quality
of machine learning greatly depends on the quality and quantity of the initial data
supplied. The final output produced would largely depend on this machine learning.
Thus the supplier of the tutoring data can potentially lay a claim on the output of the
AI-system as well. Examples can be the details of fifty portraits created by Rembrandt
to be taught to the AI to create a new portrait in Rembrandt style - here the owners of
the data for learning are likely to be different. Also, sets of credit card transactions
which have been proved to be fraudulent in the past can be fed to an AI system to predict
which transactions done in a day are most likely to be fraudulent. Here the supplied of
all learning data is likely to be a single credit card association. Such suppliers of data
may have a claim over the ultimate copyright of the AI output or a part of the royalty
from sales of the same.
A futuristic, though less likely, debate could also be whether computers should get the
status and rights that accrue to creative human beings – as far as AI output is concerned.
This is analogous to ascribing personality without fundamental rights to corporate
entities; the essence being legal personhood consisting in whether “such entity has the
right to own property and the capacity to sue and be sued”. There are programs like
Google’s DeepMind, or Wordsmith, which create expressions resulting from the
human-brain-like operation of application code and algorithms – to create output like
natural language generation, etc. These programs themselves do not need any
interference or guidance from men and can act autonomously once set in motion. So
the results might be best construed as the intellectual property of those who “worked
the machine” i.e. the owners or employed users acting for the owner. Such robotic
devices, undoubtedly, have no actual agency or self-awareness of their own. If there is
any human interference or guidance, like a person setting parameters for how a program
operates or some boundary values within which the program would make a selection,
then that person may be entitled to a copyright. This is of course, if such person’s
contribution can satisfy the threshold of originality needed copyright protection.
From a practical standpoint, when it comes to the rights on an AI output, possibly the
governing factor that would clinch the issue would be the “intent” - what was to be
created and that a creation process should be initiated and resources needed for the same
put in place. Logically speaking, one can’t have original expression without intent, and
also one can’t have intent without consciousness or self-awareness. AI does not have
awareness of its own existence and operations, it is auto-creative but only within certain
fixed bounds. Even if an output has the form and feel of work that are generaly
understood to be copyrightable — say for example a film dialogue generated by a
program called “A” and set in animation film by another AI program called “B” — it
may still fail to qualify in terms of originality. Especially, if separated from the one who
operated the AI system and set the initial parameters of its operation and the one who
supplied the learning data - deciding what data would be appropriate for machine
learning. In other words, under current copyright rules, to qualify for copyright
- 14 -
protection, a work as an original creation would have to satify the condition spelled out
in Section 102(a) of the Copyright Act (“U.S. Code Title 17”):
“Copyright protection subsists, in accordance with this title, in original works of

authorship fixed in any tangible medium of expression, now known or later developed,
from which they can be perceived, reproduced, or otherwise communicated, either
directly or with the aid of a machine or device.”
Interestingly though, the Section goes on, in paragraph (b), to specify some items that
need mental faculty but which are not subject to protection by copyright:
“In no case does copyright protection for an original work of authorship extend to
any idea, procedure, process, system, method of operation, concept, principle, or
discovery, regardless of the form in which it is described, explained, illustrated, or
embodied in such work.”
A germinal issue of contention about AI-generated works is whether such AI-generated

works can be reasonably called “original expression/s”, even though there is no person
who is actually expressing his ideas. It should be kept in mind that the AI is only
“functioning, not thinking” on its own. Function, not consciousness, is the faculty that
produces the outcome or result in this case. Arguably, the AI itself has no discernable
intent to express anything – that is still in the realm of science fiction. The purpose of
copyright protection is a quid pro quo between the creator and the society — in order
“to promote the progress of …..” certain rights are “secured” to authors [and other
creators]. The US Constitution also lays down that the copyright holder’s statutory
monopoly, like the limited copyright duration required by the Constitution, reflects a
balance of the competing claims of authors’ reward vis a vis the public interest:
“Creative work is no doubt to be encouraged and rewarded, but private motivation
should ultimately serve the cause of promoting broad public interest through
availability of literature, music, and the other arts”. If achieving a “balance of claims”
is the core purpose of copyright, the question of giving copyright protection to works
generated by AI should also be evaluated against that purpose. This extension would in
all likelihood, ultimately increase the number of works available for fair use - education,
reaserch, forecasting and other desirable social purposes; as well as public enjoyment
after the expiry of copyright period. But absence of copyright may lead to no such
creation at all, in the first place, as there would be no incentive to create.
The other camp, though smaller, had been advocating the grant of copyright to the AI
itself. They go to the extent of saying that while the human-supplied information to the
AI is idea; the actual expression of the same is attributable to the AI alone. So the
copyrightable part belongs to the AI, even though it is not a human entity. As an analogy
they cite few cases. In 2011 the New York Times reported a curious case as follows –
“Naruto, a curious 6-year-old monkey in Indonesia, peered into a camera lens, grinned
and pressed the shutter button on the unattended camera. By all standards, this was for
sheer animal fun; and not with the intent of providing for his future. But the selfie of
- 15 -
his bucktooth smile and wide eyes made Naruto a celebrity in the internet world. But
the widely shared image became the cause of a lengthy lawsuit over whether the
monkey owned the rights to it. A group of lawyers and animal activists stood for Naruto,
who lost the first round in federal court in California in 2016, but won a victory of sorts
in a settlement on the second round for himself and his friends. The camera owner,
David J. Slater, agreed to donate 25 percent of future revenue of the images taken by
the monkey to charitable organizations that protect Naruto, who now lives in the
Tangkoko Reserve on the Indonesian island of Sulawesi, as well as other crested
macaques. Lawyers for Mr. Slater, a British photographer, and People for the Ethical
Treatment of Animals, which sued Mr. Slater on Naruto’s behalf, even represented
before the United States Court of Appeals for the Ninth Circuit, which was hearing an
appeal in the case, to drop the lawsuit and vacate a lower decision that found the
monkey could not own the image’s copyright.” In a in a joint statement issued by both
parties they stated – “PETA and David Slater agreed that this case raises important,
cutting-edge issues about expanding legal rights for nonhuman animals, a goal that they
both support, and they will continue their respective work to achieve this goal”. PETA’s
counsel, David Schwarz was impressive - in the way he tackled tricky questions from
the bench on how PETA was best placed to represent Naruto as “next friend”. This is
especially in view of the fact that Slater’s attorney, Andrew Dhuey had some strong
points – his brief beginning with “A monkey, an animal-rights organization and a
primatologist walk into federal court to sue for infringement of the monkey’s claimed
copyright. What seems like the setup for a punchline is really happening. It should not
be happening…. [D]ismissal of this action is required for lack of standing and failure
to state a claim upon which relief can be granted. Monkey see, monkey sue is not good
law – at least not in the Ninth Circuit.”.
Whether primate can create original works and get copyright protection is not exactly
a pressing question of the age; rather it is the question whether copyright can be
assigned to “non-humans” and will such entities include machines (computer systems
with AI). The important issue is thus “who owns the creative work produced by AI
machines” in an increasingly automated world. This crucial to the future of AI and that
of sufficiency of copyright law. With the advent of AI software, AI (not primates) will
potentially churn out a plethora of innovative creation that may then be required to be
protected by copyright for a finite duration - in order to recoup costs and make such
ventures profitable. The premise of encouraging the production of creative works by
onferring copyright protection — by indirectly incentivising the authors\ creators
financially — is embedded in the Constitution of US as cited earlier and other countries
as well. The Intellectual Property Clause specifically aims - “to promote the progress
of science and useful arts, by securing for limited times to authors and inventors the
exclusive right to their respective writings and discoveries.”
In drafting the text of this clause, the framers could hardly have anticipated the gray
area of bots making potentially copyrighted works. One doesn’t have to incentivise a
computer bot; a machine simply does what it was programmed to do without any need
- 16 -
for financial motivation. But it costs money to procure that machine. The absence of
intent is the factor as to why the court declined to award a copyright in a work created
by a monkey. Monkeys are not financially incentivised to create works, and even if they
were, the monopoly accorded to copyright holders – to foster intent; was not intended
for animals; just as they are not intended for machines.
In a world where bots may play an increasing role in the creative space — manipulating,
arranging, colour-setting, filming, and graphically generating literary, audio and visual
content – one jurisprudential line that courts may decide to tread is that works created
without human input belong in the public domain with no protection whatsoever. Or, if
copyright is granted to the AI, the bots’ output would be protected for potentially long
periods under current copyright law; which depends on the lifetime of the author -
making the AI machines the owners of such copyright. The debate over which is better
and what path best promotes the fundamental interest in “the progress of science and
useful arts” is bound to arise in such a situation. Also, should copyright subsist for fewer
years under certain such circumstances is a valid question in this context - with the
world changing more rapidly than ever before.
The UK first attempted to address such questions as early as 1988, when its Copyright,
Designs, and Patents Act recognized a “computer-generated” work as “one without a
human author” and specifically granted such work copyright protection. The European
Parliament had also advocated granting autonomous robots the legal status of
“electronic persons” for purposes of copyright protection. On September 28, 2017 a
Delegation of the European Union to Japan met in Tokyo to grapple with, among other
issues, whether works generated by artificial intelligence are eligible for copyright
protection under Japanese and European statutes. So the debate is still raging.
Let us now take a look at how AI works.
Way of Working of Artificial Intelligence:
C) AI Operation - To under the basic principles of AI operation, we shall consider the

simple example of a part of the fraud detection system of a credit card company. The
number of transactions carried out per day would be huge and it would not be possible
to check the transactions manually to figure out which ones can be fraudulent. To
reduce the number of transactions which are to be closely looked at, a 80-20
probabilistic rule based mechanism based on Big Data can be employed. It can have
several business rules embedded in it like some of the simpler ones mentioned below -
1. High Value Check
- 17 -
2. Counter-Based, Constant Velocity Checks
3. Counter-Based, Change-Detection Velocity Checks
4. Value-based Velocity Checks
5. Velocity Change With Respect To Card Number
6. Velocity Change With Respect To Phone Number
7. Shipping Rule Check
8. Warm and Hot List Check
For our purpose, we shall consider only the Counter-Based, Constant Velocity Checks,
whereby if there are a large number of transactions on a credit card in a single day,
much above the average threshold, it would trigger an alert of possible fraud.
A Big Data based machine-learning tool like Apache Mahout would be selected and
appropriate algorithm would be chosen by the AI developer for machine learning. By
enabling the developer to build machine-learning libraries that are scalable to
"reasonably large" data sets; Mahout aims to make building intelligent applications
easier and faster.
The “main use cases for Mahout17 here are:
 Recommendation mining, which tries to identify things users will like on the basis
of their past behavior (for example shopping or online-content recommendations)
 Clustering, which groups similar items (for example, documents on similar topics)
 Classification, which learns from existing categories what members of each

category have in common, and on that basis tries to categorize new items
 Frequent item-set mining, which takes a set of item-groups (such as terms in a

query session, or shopping-cart content) and identifies items that usually appear
together”
After the successful installation of Mahout in a UNIX based system, one can run
different algorithms with it and can experience the benefit of machine learning. For our
purpose, we shall consider HMM or Hidden Markov Model. It is defined as “a
statistical Markov model in which the system being modelled is assumed to be a
Markov process with unobserved (i.e. hidden) states. The hidden Markov model can be
represented as the simplest dynamic Bayesian network, which is a Bayesian network
which relates variables to each other over adjacent time steps. This is often called a
Two-Timeslice BN (2TBN) because it says that at any point in time T, the value of a
variable can be calculated from the internal regressors and the immediate prior value
17
Apache Manuals
- 18 -
(time T-1). In simpler Markov models (like a Markov chain), the state is directly visible
to the observer, and therefore the state transition probabilities are the only parameters,
while in the hidden Markov model, the state is not directly visible, but the output (in
the form of data or ‘token’ in the following), dependent on the state, is visible. Each
state has a probability distribution over the possible output tokens. Therefore, the
sequence of tokens generated by an HMM gives some information about the sequence
of states; this is also known as pattern theory, a topic of grammar induction. A hidden
Markov model can be considered a generalization of a mixture model where the hidden
variables (or latent variables), which control the mixture component to be selected for
each observation, are related through a Markov process rather than independent of each
other.”
In our simple example, we start by considering 30 transactions on a single credit card

per day as the threshold, above which the transactions would have a high probability of
being fraudulent. But this number 30 is not sacrosanct but only an initially assumed
value and the actual value would be determined by applying machine learning over a
large set of transaction data spanning over a long period and it would be more and more
perfect with the passage of time as the incremental transaction data refines the dynamic
parameters employed by the algorithm.
The charts in the subsequent give a simple depiction of the process. The Java and
Hadoop-Mapreduce based code for big data analysis using HMM is given in the
Appendix.
- 19 -
Credit Card Fraud-Detection using HMM
FLOW CHART
- 20 -
DETECTION MODULE
Alpha (α): Forward probabilities, which are generatedfrom an initial

estimate of the hidden state at the firstdata observation, and calculated
forward from there.
- 21 -
TRAINING MODULE
Such a system can now be built on a collection of simple commodity hardware - a

network of connected client-grade machines having -
 A Unix-like system (could be Centos 5.5+, SLES11 and Ubuntu 9.04+)
 Oracle JDK 1.6.x (tested only with JDK 1.6. See Java Development Kit
Installation.)
 CDH3 Update 2 or later(HADOOP Version)
For details of sample code, please refer to the Annexture.
The output would be a set of a few thousand suspicious transaction culled out from
several million transactions per day. These can then be closely evaluated, even
manually, to find out fraudulent ones. Thus the AI system would serve the goal of doing
- 22 -
away with the need of looking for a needle in the haystack. The parameters would
automatically get refined as the system runs over a period of time and more and more
transactions flow through it.
This report of potentially fraudulent transactions and the credit card account details
derived from it would be the output of the AI system.
This same principle can be applied in voice simulation systems for songs, music
creation by meaningfully permuting and combining notes, artwork generation that
combine the skills of maestros and the like. The accuracy would greatly depend not
only on the algorithm itself but the quality and quantity of the data used for the machine
learning - from which the machine will create the logic to generate new output on its
own.
Towards a Soulution in Terms of Copyright:
D) Possible Approach – Thus, it is now well established that sophisticated AI systems

can create artistic and innovative works – through some human intervention and
sometimes even without it. They can; through machine learning algorithms be
programmed in such a way that they exhibit learned skills and output based on the same,
which their creators themselves do not possess. Creative works produced through these
machine-learned skills have become a topic of legal debate, as they fall into a somewhat
grey area from a legal standpoint. These are not limited to Heuristic and Stochastic
algorithms like the one cited above but also Artificial Neural Network (ANN). They
are a software based simulation of human neural networks and can come up with new
patterns which are akin to new ideas and expressions thereof. These networks are
comprised of a number of network switches which can work in a synchronized manner
to assess information flowing-in and create new works which differ from existing prior
art in that field. This process is quite often both automatic and independent of human
intervention. There can be a great variation is results depending on the algorithm and
dataset used for learning, and unique works of different levels of complexity and artistic
value are generated over a much broader spectrum of creativity. The assortment of
choices and possibilities can be mind boggling. Human beings would have taken a lot
of time and effort and also a lot of trial and error would have to come in before the final
product can be created.
Broadly speaking, AI generated works fall into two main categories. The first category
comprises of works generated by AI programs with some direct human guidance,
assistance or input -where human beings supply the parameters with and within which
the AI operates. In this category, AI is used as a tool to achieve somewhat pre-
determined or predicted bounds for the outcome - although the details of the outcome
would depend on the AI. An example may be the creation of a picture by an artist who
- 23 -
selected the digital mode of colors, drawing instrument, the brush size, the stroke style,
the size and layout of the frame and has given parameters defining his requirements to
the AI algorithm that would be used to create the artistic work.He cannot exactly predict
the final version of the generated painting that would be generated nor is it his intention
to do so, but nevertheless, he has directly contributed to creation of the same.Some
premeditated expectations exist on his part as to what the art may look like when it
comes out. He can also change some of the parameters before arriving at the final shape
by changing the supplied parameters and viewing the outcome and iterating several
times for perfection. Under current copyright law, an author of the computer program
that comprises the AI may have copyright claims over the resulting creation if he cites
the AI program as a tool or medium used in the creative process for giving expression
to an idea. An analogy can be drawn with photography, as given below.
The US Supreme Court gave copyright protection to photography for the first time in
the case of case of “Burrow-Giles Lithographic Co. v. Sarony”18in 1884. The camera
used to capture the image of the famous writer Oscar Wilde by the photographer
Napoleon Sarony, was considered as a tool; which aided the “author” in creating an “an
original work of art”. The cameras used today, more often than not, use digital
technology and use both hardware and software which makes the photography much of
an automatic process that even a lay man can handle and the outcome is more
technology driven rather than human driven. But the 1884 judgment of the US Supreme
Court still stands and is used as a legal precedent justifying grant copyright to
photographers even today. The image from a digital camera or a smart phone being
computer-generated, may to some extent, be compared to the creation of an art work
using an AI system - where human intervention is there in a much reduced scope similar
to the example cited above. Both the processes however, are almost automatic and it
can possibly be argued in court that an AI device, much like a camera, is simply a tool
employed by an author to express an idea of his in a tangible form for the purpose of
expression and fixation - going by copyright terminology.
On the other hand, there are also AI creations that are autonomously generated - with
little or no human intervention. The computer algorithms generating such works are no
doubt the result of human innovation. But while their source code may be copyrighted
as a literary work under the U.S. Copyright Act, the artistic output is not copyrightable
under current copyright statutes. This is because, not having been directly influenced
by human authors, they fail to qualify under the provisions of US Copyright laws19.
Thus, such autonomous works are considered eligible for copyright protection and two
things can happen. They can fall into the public domain, if the entity running the AI
discloses them or such entity may choose to withhold them from public knowledge as
there would be no revenue accruing from disclosure. Thus, as per current provision and
interpretation of US copyright law, unless AI generated works can directly be attributed
18
111 U.S. 53 (1884)
19
“U.S. COPYRIGHT OFFICE, COMPENDIUM OF U.S. COPYRIGHT OFFICE PRACTICES - § 306 (3rd ed.
2014)”
- 24 -
to a human author, they would not be worth creating – at least for monetization purposes.
The U.S. Copyright Office in the latest version of its Compendium20 clearly state, “[the
office] will not register works produced by a machine or mere mechanical process that
operates randomly or automatically without any creative input or intervention from a
human author.”
There is thus no established period of copyright protection, and consequently no

tangible incentive for usersor owners of AI hardware-software systems to install and
improve their capabilities. Thus even if theAI-users and the companies for which they
work have invested a substantial resources in procurement of AI systems, they would
not be able to enjoy copyright protection or the financial benefits associated with the
creative output from such systems. This would, in turn, limit innovation by dissuading
developers and companies from investing in AI research, as no one would want to buy
them. The result would not onlybe in the decline of AI technology as a whole but also
in reduced innovation across a number of sectors of industry.Owners of AI machines
would not have any incentive, apart from the mere satisfaction of new creation. This is
bound to lead to a lower number of AI generated works (that could have been
potentially copyrightable) and in the longer run, a considerable decrease in works
ultimately entering the public domain after expiration of their copyright periods
(hypothetically). Forced-release of AI-output to public domain would decrease in
incentives for creativity and can have the same detrimental effect on new AI-creation
as piracy had on the music-CD and software industry. Lower number of AI-generated,
potentially copyright protected works would also mean less material available under
the Copyright Act’s fair-use doctrine - for use in teaching, scholarly usage and research.
Such non-commercial, educational use of AI-output is not small in volume or demand.
Thus, in the longer run reduced number of AI generated works would potentially have
considerable negative effects in numerous sectors (medicine, weather forecast,
economy modelling, engineering simulation, graphic arts, etc) where AI based
operation and outcome are proving imperative. Lack of copyright would result in less
funding for AI research and installation which would have an unsalutary effect on the
progress on mankind.
An effective solution to this issue is needed and a number of copyright law experts have
put forth their views in recent times.A suggestion which has gained considerable
currency is a reinterpretation of the terms “employee” and “employer” in the “made for
hire doctrine” – whereby the owner of the AI-systems and his employees manning these
systems would have the status of employer and the AI-systems (hardware and software
combination) would be a non-human employee. It can prove to be the least disruptive
and most practical solution to the issue of copyright of works created by AI-systems.
This would prevent them from automatically falling into the public domain, on
disclosure. This, however, is contrary to the views of eminent scholars like Colin R.
Davies and Ryan Abbot, who have advocated that the term “authorship” should be
enlarged in scope to include both human and non-human entities as “authors”. However,
20
supra § 313.2
- 25 -
the employee-approach to AI would significantly lessen the controversy and

uncertainty that could otherwise be full of legal challenges and systemic complexities.
Non-humans are not natural persons and cannot be held legally responsible in a court
of law. An effective solution to the AI copyright issue would require a balance of both
the legal status of the copyright holder and the need for incentives for AI developers.
These two important conditions should be satisfied in order to ensure appropriate legal
standing in terms of rights and future funding and development of the AI sector.
The notion of assigning authorship of computer generated works to humans can be

traced back to U.K. Copyright laws. The copyright of computer generated works in the
U.K. is attributed to “the person by whom the arrangements necessary for the creation
of the work are undertaken”21. This is in essence similar to the “employer” in the U.S.
Copyright Act’s made for hire doctrine, who can be ascribed with the copyright of the
work. Professor Annemarie Bridy supports the United Kingdom’s position and suggests
an amendment to the “made for hire” doctrine of the U.S. Copyright Act - as a way to
transfer copyright to a human author from works created by AI. Such amendment would
necessitate deviation from the current agency law approach for defining the relationship
between an employee and employer as set by the Supreme Court’s decision in
“Community for Creative Non-Violence” (supra), and bring in a more flexible relative
interpretation of terms “employee” and “employer” within the made for hire doctrine.
In employee-generated work copyright is awarded to a party who is not directly
responsible for the creation of the work. The same can be extrapolated to that of AI - in
line with the provision for employee-generated works.
There are three possible interested parties who can claim the copyright of AI generated
works: AI developers; AI users and owners (large companies and financial investors in
the AI sector); and end users (use by general public). The most suitable author should
be such that the system that would maximize the overall benefit to society at large in
the long run. In other words, the cardinal question is would society benefit most if
copyright is assigned to the AI programmer or the body responsible for funding the
development of the AI, or the continually growing number of end users of AI programs
for creative work or the general public as a whole? To better gauge the societal impact
of each party’s ownership, the ultimate goal of assigning copyright of AI generated
works to human authors should be ascertained. Next, we can assess which party
contributes most to this goal. Finally, we may deduce that the party which contributes
most to the realization of this goal is best suited to possess the authorship of AI
generated works.
AI machines, in contrast to human creators, are not driven by financial incentives. Their
performance is not dependent on tangible rewards but rather on the investment of time
and skills by AI programmers, the decision of people who feed data and set paramerts
for operation and the indirect financial backing of the companies for which they work
which drive innovation directed at improvised AI technology. These entities are the
21
Copyright, Designs and Patents Act, 1988, c. 48, § 9(3) (U.K.)
- 26 -
most important contributors to the research and development of the AI sector. Without
their contribution, AI devices would simply not be available for mankind. But they in
turn are dependent for revenue on entities which by the AI-systems for them and pay
for maintenance and support contracts. So it is the investors in AI-systems who should
be given the financial incentive from copyright on AI-output. That would give the
business justification for them to pump money and procure AI from the original makers.
They would also be in a better position to market the AI-output in comparison with the
original developers. The resulting financial gain would automatically get channelised
in part to the developers in the form of more orders and more research funding. Since
end users have the smallest contribution to the initial development or subsequent
installation and maintenance of AI, their claims for authorship are the least persuasive.
In fact, assigning authorship to end users instead of AI developers could be detrimental
to the growth of the AI sector, as mentioned earlier.
While independent programmers may retain copyright for the work generated by their
AI, copyright of AI works created within large companies may be settled through
employment contracts and attributed to either the users who run them or the companies
for which they work. This would be as per the terms specified in this regard on the
contract for employment and ownership and disclosure norms specified therein. If
owners and AI-programmers choose to assign their copyright to end-users, they can do
so through End User Licensing Agreements (EULA). In the long run, licensing may
prove more financially viable for some companies, while commercializing AI
generated works may work best for others – depending on the financial means of the
parties and the business model to be adopted on a case by case basis.
The employee–employer relationship in the “made for hire” doctrine may be applied to
AI programs and their developers if the terms “employer” and “employee” are
interpreted as relative within the confines of the doctrine. Just as the term “author” may
be applied to various entities (an individual, a firm or organization), and the term
“writings” is an all-encompassing word that could mean books, sound recordings, films,
images, and even computer code, so too should employer and employee be left open to
interpretation in order to satisfy newly arising requirements and reflect contemporary
social and technological changes. The terms “author” and “writings” have long been
understood to have flexible interpretations under the scope of relevant copyright law –
“Goldstein v. California”22. An AI machine could be considered an employee since its
generative services are employed by its programmer or owner. This new interpretation
of two of the terms (“employer” and “employee”) in the “made for hire doctrine” could
prove essential for the future development of AI by providing the incentive of copyright
protection to innovative AI-based developers. In addition, it would adhere to the latest
publication of the Compendium of best practices by the U.S. Copyright Office, which
clearly states that “copyrights will only be granted to human authors”. Also, the
reluctance of companies to disclose AI participation in the creative process would be
22
412 U.S. 546 (1973)
- 27 -
mitigated - currently, there exists a fear of rejection by the Copyright office, resulting
in low filings for AI copyright.
Finally, unlike human authors who have a limited lifespan, AI programs could
perpetually exist. This is a challenge for the predetermined term of copyright protection
given to authors (life of author plus 70 years in the U.S. and 60 years in India). A
reinterpretation of the employee–employer relationship in the “made for hire doctrine”
to allow transfer of copyright from AI to its employer would effectively resolve this
issue.
But question arises about the right of the supplier of the data that had been used for
machine learning. If its source is the same as the owner of the AI, then there is no issue.
But if it is supplied by a third party and not freely available, the right of such third party
can be governed by a separate contract between the owner of the AI and the third party,
based on either one-time payment or royalty or a combination of the two.
E) Legal Personality of AI as Employee – Having seen the advantages of bringing in

an employer-employee kind of relationship between the owner of the installation and
the AI system; it would be relevant to look at the legal aspects that might govern such
a relationship. “Personality” – in the legal sense can be of two broad categories – natural
and juridical23. A natural person is a human being. A juridical person, on the other hand
is a non-human legal entity, like an organization (business house or commercial
corporation) that is not a natural person but is statutorily ascribed with rights and duties\
liabilities. It is, nonetheless, recognized as a legal entity in the eyes of law and as having
a distinct identity. The rights and responsibilities of a juridical person are distinct from
those of the natural persons, who may be constituting or forming part of it in various
capacities. This includes any incorporated organizations including corporations,
government agencies, trusts and NGOs. It may also be called artificial person, juridical
entity, juristic person, or legal person. In a normal employer-employee kind of
relationship, it is quite common for the employer to be a juristic person. But in the case
of AI, the employee would be a juristic person also and appropriate statutory provision
would have to be devised to handle such a legal personification. To understand, what
type of legal personality would be suitable in this case, let us briefly look at the various
types and aspects of artificial personality.
While a company is the most common example, it is not the only one form of juridical
person. Also, there are various theory that look at various aspects of such artificial
person from different angles. The word person comes from the Latin word personare,
a term that meant larva histrionalis, meaning “mask”24 – in the legal field also, this
sense has got carried in. The classical theory is formulated by Salmond – “A person is
any being whom the law regards as capable of rights and bound by legal duties”; and
23
ARCELIA QUINTANA, COMMERCIAL LAW SCIENCE 270 (2d ed. 2004)
24
DUARDO G. MAYNEZ, INTRODUCTION TO LAW 273 (Porrúa 31st ed. 1980)
- 28 -
Austin – “the term 'person' includes physical or natural person including every being
which can be deemed human”. Carnelutti defined it as the “meeting point of the two
elements” – personal or economic interest and legal rights and duties; where collective
interest exists, i.e. leading several men as one, unity is allowed to emerge, and
personality as a unit will be acquired. Julien Bonnecase on the other hand, defines the
juridical personality law as a set of rules and institutions that apply to the persons
themselves forming part of the body. M.F.C. de Savigny is another proponent of the
traditional theory, better known as the theory of fiction - the legal entity is an
artificially-created being, capable of having a patrimony, but distinguished by its lack
of will and hence, not subject to law. Only the human beings behind it will acquire
rights and duties. Hans Kelsen argues that according to the traditional theory, a “subject
of law” refers to the object of a legal obligation or subjective right. This is known as
the juridical power to claim an action for the enforcement of an obligation – the
personification of rights and duties of natural and artificial persons combined into one.
Garcia Maynez defines a “person” as “any being capable of having powers and duties.”
He maintains that juridical persons are classified as either natural persons or legal
entities. While the first group refers to human beings as a subject of rights and
obligations, the second group focuses on those associations endowed with personality
such as unions or commercial corporations. German philosopher Nicolai Hartmann
says that a “person” is the subject whose conduct is able to express moral values. Brinz
classifies the patrimony in two categories: personal and nonpersonal, also known as
patrimonies attached to a destination or purpose. In the first category they belong toa
subject, while in the second category they do not have an owner, but their destination
is addressed by a particular purpose and enjoys special legal guarantees. Francisco
Ferrara says, the word “person” has three meanings: a biological sense, which is equal
to a man; a philosophical sense, which is identified with a rational being capable of
proposing and carrying out purposes; and the juridical sense which understands the
person as a subject with rights and obligations.
The development of the modern theory can be traced to Gray – “A person is an entity
to which rights and duties may be attributed”. José L. De Benitosets forth as “conditions”
for the existence of a juridical or corporate person – “Plurality of individuals,
cooperation, organization; exclusive patrimonial capacity and corporate purpose”.
Some more of the modern theory of artificial personality are –
The patrimony appropriation theory - This theory considers that “there exists the same
legal protection to one good and one person in a legal relationship than such created
between patrimony and purpose. In this manner, the purpose receives rights and
obligations, that is to say, a patrimony appropriated or earmarked for certain purpose”.
Theory of the apparent subject - This theory was developed by Rudolph Von Ihering,
who argues that - “The law consists of two elements. One element is substantial, which
resides in the practical end that produces utility or enjoyment of the things that have
economic or moral value, and, the other element, formal, is only related to this aim as
- 29 -
a means of enjoyment protection”. He asserts: “the rights are interests juridically

protected; the law is the legal certainty of enjoyment.”
Atomistic theory of the state - This theory stems from the idea that the creation of the
State is grounded in the conception of that only men are a reality and are able to act,
therefore, personality is an attribution for individuals only, not for the State. The
juridical person in private law is conceived as a fact ruled by the legal order.
Theory of fiction – It sets forth the idea that the juridical person or legal entity represents
an exception to the principle that only the natural person has capacity to act as holder
of rights and obligations. This is a result of a legal fiction that recognizes the artificial
capacity for possession or ownership of property by a fictitious being.
Theory of the legal act - Ferrara, when referring to the juridical personality of the legal
entity, argues that – “….juridical personality is not a thing, but instead a way things are.
The juridical personality is the organic vestment used by certain groups of men or
establishments to introduce themselves in the life of law, it is the legal configuration
certain groups of men assume in order to participate in commerce”.
Theory of veil. - This stance arises from the argument that it is possible to “penetrate”
the legal entity raising its “formal veil”. The theory of veil has its origin in United States
law, having as a frame of reference the precedent of diverse judicial resolutions issued
by United States courts, as well as opinions from different legal scholars. This trend of
thought is known as the “theory of disregard” or doctrine of the “disregard of legal
entity”.
Elvia Adrino summarizes the various legal theory of personihood, that a legal fiction
called artificial person can be defined in the following terms:
“The legal entity is a subject of an abstract existence, legally constructed with a will of
its own, including rights, obligations and a juridical personality that individualizes it in
the relationships of law and make it a center that generates rights and obligations of an
economic, financial and commercial nature”25.
To add, Section 11 of the Indian Penal Code lays down that the word “person includes
any company or association, or body of Persons, whether Incorporated or not”.
Thus to be a legal person an entity is to be subject to rights and duties. In the employer-
employee relationship between the owner and the AI, the owner gets the rights by virtue
of his financial investment in the AI system – be it in developing or acquiring. The AI
system is generating output as part an act which can be legally construed as in the nature
of its “legal duty”. However, many of the definitions of legal personihood harp on the
capacity to enter into legal relationships. On the other hand, mere “capacity” by itself
25
The Natural Person, Legal Entity or Juridical Person and Juridical Personality; Penn State Journal of
Law & International Affairs - Volume 4 Issue 1 Seventeenth Biennial Meeting of the International
Academy of Commercial and Consumer Law
- 30 -
does not bring in legal personality. However, regarding the question of AI being eligible
for legal personihood or not. Let us take a look at why the concept of artificial person
is needed. Aside from corporate legal personality i.e. the company being an independent
legal entity and different from its shareholders, which is the most common type of
juridical personality, there are several other forms as well. A minor can enter into
certain types of contracts through his guardian. A Hindu deity is perpetuial minor who
has a special form of legal personality, capable of rights and obligations26. He can hold
proptery and contest legal suits. A ship on being launched gets a personality27 – enter
into contracts, employ agents, sue and be sued. The underlying reason behind all these
doctrines is the legal convenience and economic advantage. For the company, it is
regualory issues and rasing money; For the ship it is the complexity of jurisdiction while
it travels. For the Hindu idol it is the simplicity in accepting donation of immovable
property. For the minor, it can be to avail an education load and so on. The underlying
reason for ascribing a juridical personality has always been the convenience of
functioning and simplicity of procedure. Same is the case of ascribing multiple capacity
to the same human being – as a trustee and a guardian, for example. The divergence of
various theory notwithstanding, the evolution of jurisprudence in this regard has always
been driven by the need to address a complex issue in a simple way – the statues have
also evolved as different for each such need. The rules governing the contract and tax
provisions of a ship as a personality travelling in various jurisdictions is different from
that governing the formation of a company – for aggregation of funds to start a capital
intensive business. Thus suitable statute would have to evolve to govern the legal
personality of AI in the employer-employee relationship. It could be like that of an
employee who has take a one-time payment for doing multiple tasks across a long
timespan; the money being the amount invested by the employer in procuring the AI.
The perpetuity and unbroken continuity concept can be taken from corporate
personality but there would be no liablity or duty to the employer apart from the passing
on of copyright of creation. It cannot sue or be sued for tort or breach of contract.
F) Conclusion - Thus considering all aspects, acknowledging copyright of AI

programmers and buyers\ users of AI software and owners of companies installing then
and employing professionals to run them would be imperative to the growth and
development of AI industry in future. There is a necessity to take a re-look at the terms
“employee” and “employer” in the “made for hire doctrine” as it exists now. This
suggested reinterpretation does not entail any major upheaval or overhaul of the current
copyright laws around the world. But still it would ensure promotion of “the progress
of science and useful arts” by incentivising innovation.
There is now increased acceptance of the fact that human beings are not the only source
of creativity or innovation anymore. The current Copyright Act, however, does not fully
26
Pramatha Nath Mallick vs. Pradyumna Kumar Mallick; L.R. 52 I.A. 245 (1925)
27
Tucker vs. Alexandroff; 183 U. 5. 424, 438, 22 Ct. 195, 201 (1902) and Re The Western Maid, 257
U. 5. 419, 436, 42 Ct. 159, 162 (1922)
- 31 -
appreciate this and as such does take into account this contemporary reality. This is
resulting in forced-release of large number of AI-created works into the public domain;
depriving the human investors. This is detrimental to the interests of the AI-
programmers and also the owners of AI devices who have invested in them; either by
funding development or purchase. Consequently their ability and willingness to invest
in AI-resources and in the future development of AI can be negatively impacted. This
perceived gap in copyright law can result in a decrease of valuable new works from AI.
Those could have been made available to forecasters, researchers, and the general
public for their benefit. Also a significant delay in technological and artistic progress
of modern society can result and have far reaching consequences on human progress.
Although this is an issue of considerable significance, it is not yet being effectively
addressed through deliberation regarding suitable legislation and the world is still in
search for a practical all-encompassing solution. This solution should be such as to
benefit and motivate the AI developers and investors and have a seamless roll-in with
the current copyright regime. That in turn would ensure the much-needed development
of AI and lead to increased creative output in many works of life. The possible
reinterpretation of the terms “employee” and “employer” in the “made for hire”
doctrine is recommended to overcome the current shortcomings of the copyright laws.
With the expanded interpretation of these terms in the “made for hire” doctrine,
authorship of AI generated works would be awarded to the developers and owners of
AI systems that produced such output. This legal right would help them generate
revenue instead of forced public release or withholding that can happen under current
laws. Financial incentivisation would give a significant boost to research and
development. This is imperative for continuation of investment in the AI sector; and to
aid those who are responsible for AI development.
If a software engineer writes an AI program which can generate music of various types,
the copyright should belongs to the person who created a song by controlling the bot,
not the engineer who came up the software, nor the AI device itself. It has to be the rule
that while monkey may have pushed the camera button out of sheer fun, it is the
photographer - the owner of the camera who owns the copyright. Thus, even in a
multimedia, logistics or forecasting process where AI devices may be operating largely
by themselves aided by increasing artificial intelligence; the law should evolve to
recognize that, although a human being may be relying fully on a cluster of software
systems to produce original work, that person is the author and there should be no bar
on awarding him the copyright of the output.
There can be situation where such statutory protection can come up for challenge. But,
in an increasingly automated world, the Constitutional principles of promoting “the
progress of science and useful arts” by protecting human creativity and innovation
should be upheld by necessary evolution of the copyright laws. Suitable jurisprudence
and statutory provisions would come up to address the employer-employee relationship
between the owner of AI system and the AI.
- 32 -
G) References:
1. The Copyright Act, 1957 - Bare Act
2. Wikipedia
3. Artificial Intelligence and the Copyright Dilemma by Kalin Hristov
4. Legal Personality by Bryant Smith
5. The Natural Person, Legal Entity or Juridical Person and Juridical Personality by
Elvia Arcelia Quintana Adriano
6. WIPO Magazine: Artificial intelligence and copyright by Andres Guadamuz
- 33 -
H) Appendix:
1. HMM_Categorise_Record Class:
/*
* This class will categorise the transactions ie whether
* they will go to either detection or training module
*/
public class HMM_Categorise_Record extends Configured implements Tool
{
public static class Map extends Mapper<Text, Text, Text, Text> {
/*
* Input Key: Card Number Input Value: Single Transaction Record
Output
* Key : Card_Number Output Value : Single Transaction Record
*/
public void map(Text key, Text value, Context context) {
try {
System.out.println(“Key:” + key.toString() + “, Value”
+ value.toString());
context.write(key, value);
} catch (Exception e) {
e.printStackTrace();
System.out
.println(“Error in context.write() of map task in
HMM_Group_Card_Numbers class”);
}
}
}
/*
* Input Key: Card_Number Input Value: Single Transaction Record List
Output
* Key : Card_Number Output Value : Single Transaction Record List
*/
public static class Reduce extends Reducer<Text, Text, Text, Text> {
public void reduce(Text key, Iterable<Text> values, Context context) {
System.out.println(“I am at reducer”);
int trainingSequenceLength =
HMM_Parameter.trainingSequenceLength;
int countOfTransactionTraining = 0;
int countOfTransactionCurrent = 0;
boolean generateModel = false;
- 34 -
String trainingRecords[] = new String[trainingSequenceLength];

long[] transactionIDTrainingRecords = new
long[trainingSequenceLength];
List<String> ls = new ArrayList<String>();

/*
* START: code for counting no. of records in training table
*/
int counter=0;
for (Text val : values) {
//System.out.println(val.toString());
String line = val.toString();
ls.add(counter,line);
//System.out.println(“Get:”+counter+”:”+ls.get(counter));
counter++;
StringTokenizer parseLine = new StringTokenizer(line,
HMM_Parameter.separaterType);
int countOfToken = parseLine.countTokens();
if (countOfToken == 3) {
transactionIDTrainingRecords[countOfTransactionTraining] = Long
.parseLong(parseLine.nextToken());
trainingRecords[countOfTransactionTraining] = line;
countOfTransactionTraining++;
} else
countOfTransactionCurrent++;
}
/*System.out.println(“countOfTransactionTraining:”
+ countOfTransactionTraining);
System.out.println(“countOfTransactionCurrent:”
+ countOfTransactionCurrent);*/
/*
* END: code for counting no. of records in training table
*/
/*
* START: code for putting transactions records into array
*/
String[] transactionInASingleDay = new
String[countOfTransactionCurrent];
long[] transactionIDArray = new long[countOfTransactionCurrent];
countOfTransactionCurrent = -1;
counter=0;
while (counter<ls.size()) {
- 35 -
String line = ls.get(counter);

//System.out.println(“Line:”+line);
StringTokenizer parseLine = new StringTokenizer(line,
int countOfToken = parseLine.countTokens();
//System.out.println(“hi”);
if (countOfToken != 3) {
countOfTransactionCurrent++;
transactionInASingleDay[countOfTransactionCurrent] =
line;
transactionIDArray[countOfTransactionCurrent] = Long
.parseLong(parseLine.nextToken());
}
counter++;
}
/*System.out.println(“Before sorting:Length-”
+ countOfTransactionCurrent);
for (int i = 0; i <= countOfTransactionCurrent; i++) {
System.out.println(“ID:” + transactionIDArray[i] + “\tRecord:”
+ transactionInASingleDay[i]);
}*/
/*
* END: code for putting transactions records into array
*/
/*
* START: SORT Transactions by Transaction ID
*/
quickSort(transactionIDArray, transactionInASingleDay, 0,
countOfTransactionCurrent);
quickSort(transactionIDTrainingRecords, trainingRecords, 0,
countOfTransactionTraining - 1);
/*
* END: SORT Transactions by Transaction ID
*/
/*System.out.println(“After sorting:Length-”
+ countOfTransactionCurrent);
for (int i = 0; i <= countOfTransactionCurrent; i++) {
System.out.println(“ID:” + transactionIDArray[i] + “\tRecord:”
+ transactionInASingleDay[i]);
}*/
/*
* START: Categorise each transactions
*/
- 36 -
if (countOfTransactionTraining >= trainingSequenceLength) {

System.out.println(“Inside if-1”);
for (int strIndex = 0; strIndex <= countOfTransactionCurrent;
strIndex++) {
try {
context.write(new Text(“Detection”), new Text(
transactionInASingleDay[strIndex]));
} catch (IOException e) {
System.out.println(“Error in reducer IOException-4”);
System.exit(0);
} catch (InterruptedException e) {
System.out
.println(“Error in reducer
InterruptedException-4”);
System.exit(0);
}
}
} else {
System.out.println(“Inside else-1”);
if ((countOfTransactionTraining +
countOfTransactionCurrent) >= trainingSequenceLength) {
int strIndex = 0;
generateModel = true;
for (int index = countOfTransactionTraining; index <
trainingSequenceLength; index++, strIndex++) {
trainingRecords[index] = ““;
StringTokenizer parseLine = new StringTokenizer(
transactionInASingleDay[strIndex],HMM_Parameter.separaterType);
trainingRecords[index] += parseLine.nextToken();
trainingRecords[index] = trainingRecords[index]
+ HMM_Parameter.separaterType
+ parseLine.nextToken();
parseLine.nextToken();
// Added on 1st july 2013
trainingRecords[index] = trainingRecords[index]
- 37 -
try {
context.write(new Text(“Training”), new Text(
trainingRecords[index]));
System.out
.println(“Error in reducer IOException-
3”);
System.exit(0);
System.out
System.exit(0);
}
}
for (; strIndex <= countOfTransactionCurrent; strIndex++)

{
try {
context.write(new Text(“Detection”), new Text(
transactionInASingleDay[strIndex]));
System.out
2”);
System.exit(0);
System.out
System.exit(0);
}
}
} else {
for (int strIndex = 0; strIndex <=
countOfTransactionCurrent; strIndex++) {
String str = ““;

StringTokenizer parseLine = new StringTokenizer(
transactionInASingleDay[strIndex],HMM_Parameter.separaterType);
str += parseLine.nextToken();
str = str + HMM_Parameter.separaterType
- 38 -
str = str + HMM_Parameter.separaterType
try {
context.write(new Text(“Training”), new
Text(str));
System.out
3”);
System.exit(0);
System.out
System.exit(0);
}
}
}
}
/*
* END: Categorise each transactions
*/
/*
* START: If the count reaches 30 then generate the model for the
* card number
*/
if (generateModel == true) {
HMM_Generate_Model hmm_Generate_Model = new
HMM_Generate_Model();
/*
* Here the output of
hmm_Generate_Model.run(trainingRecords)
* will contain records for inserting into HMM_NonFraud_File
and
* HMM_Parameter_File So, the first 30 records are for
- 39 -
* HMM_NonFraud_file and rest for HMM_Parameter_file

*/
String[] result = hmm_Generate_Model.run(trainingRecords);
int index = 0;
while (index < trainingSequenceLength) {
try {
context.write(new Text(“NonFraud”), new Text(
result[index]));
System.exit(0);
System.out
System.exit(0);
}
index++;
}
while (index < result.length) {

try {
context.write(new Text(“HMMParameter”), new Text(
result[index]));
System.exit(0);
System.out
System.exit(0);
}
index++;
}
}
/*
* END: If the count reaches 30 then generate the model for the card
* number
*/
}
/*
* START: Code for sorting Transactions based on Transaction ID
*/
- 40 -
public static int partition(long[] transactionIDArray, String[]

transactionInASingleDay,int p, int r){
int i=p,j=r;
long pivot=transactionIDArray[r];
while(i<j){
while(i<r && transactionIDArray[i] <= pivot){

i++;
}
while(j>p && transactionIDArray[j]>pivot){

j--;
}
if(i<j){
swap(transactionIDArray, transactionInASingleDay,i, j);
}
}
return j;
}
public static void quickSort(long[] transactionIDArray, String[]

transactionInASingleDay,int p, int r){
if(p<r){
int q=partition(transactionIDArray, transactionInASingleDay,p,
r);
if(p==q){
quickSort(transactionIDArray, transactionInASingleDay,p+1,
r);
}else if(q==r){
quickSort(transactionIDArray, transactionInASingleDay,p, r-
1);
}else {
quickSort(transactionIDArray, transactionInASingleDay,p,
q);
quickSort(transactionIDArray, transactionInASingleDay,q+1,
r);
}
}
}
public static void swap(long[] transactionIDArray, String[]

transactionInASingleDay,int p1, int p2){
long temp=transactionIDArray[p1];
transactionIDArray[p1]=transactionIDArray[p2];
- 41 -
transactionIDArray[p2]=temp;
String str=transactionInASingleDay[p1];
transactionInASingleDay[p1]=transactionInASingleDay[p2];
transactionInASingleDay[p2]=str;
}
/*
* END: Code for sorting Transactions based on Transaction ID
*/
}
public int run(String[] args) {
Job job = null;

String output = “hmm/categorise_result”;
try {
job = new Job(getConf());
System.out.println(“Error in Job(getConf())”);
}
job.setJarByClass(HMM_Categorise_Record.class);
job.setJobName(“HMM_Categorise_Record”);
job.setNumReduceTasks(HMM_Parameter.hadoopClusterSize);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
job.setMapperClass(Map.class);
job.setReducerClass(Reduce.class);
job.setInputFormatClass(KeyValueTextInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class);
try {
FileInputFormat.addInputPath(job, new Path(“hmm/input/”));
FileSystem fs = FileSystem.get(new Configuration());
Path training = new Path(HMM_Parameter.trainingFolder);
if (fs.exists(training))
FileInputFormat.addInputPath(job, training);
System.out.println(“Error in FileInputFormat.addInputPath()”);
}
FileOutputFormat.setOutputPath(job, new Path(output));
try {
job.waitForCompletion(true);
System.out.println(“Error in job.waitForCompletion()”);
}
- 42 -
return 0;
}
public static void main(String[] args) throws Exception {

System.out.println(“HMM_Categorise_Record”);
HMM_Categorise_Record obj = new HMM_Categorise_Record();
obj.run(args);
}
}
2. HMM_Format_Input_Files Class:
public class HMM_Format_Input_Files extends Configured implements

Tool {
public static class Map extends Mapper<LongWritable, Text, Text, Text> {
public void map(LongWritable key, Text value, Context context) {

String line = value.toString();
StringTokenizer tokenizer = new StringTokenizer(line,

String str = null;
try {
str = tokenizer.nextToken();
str = tokenizer.nextToken();
System.out
.println(“Data Mismatch Error in
HMM_Format_Input_Files class”);
System.exit(0);
}
try {
context.write(new Text(str), value);
System.out
HMM_Format_Input_Files class”);
System.exit(0);
}
}
}
public int run(String[] args) throws Exception {
- 43 -
Job job = new Job(getConf());
job.setNumReduceTasks(2);
job.setJarByClass(HMM_Format_Input_Files.class);
job.setJobName(“wordcount21feb2013”);
job.setInputFormatClass(TextInputFormat.class);
FileInputFormat.setInputPaths(job, new Path(args[0]));

FileOutputFormat.setOutputPath(job, new Path(“hmm/input”));
boolean success = job.waitForCompletion(true);

return success ? 0 : 1;
}

System.out.println(“Hello WordCount”);
int ret = ToolRunner.run(new HMM_Format_Input_Files(), args);

System.exit(ret);
}
}
3. HMM_Generate_Model Class:
public class HMM_Generate_Model {
/**
* @param args
*/
public static void main(String[] args) {
public String[] run(String[] transactionRecordForTraining) {
System.out.println(“Generate Model Module”);
int trainingSequenceLength =
- 44 -
HMM_Parameter.trainingSequenceLength;
int noOfCluster = HMM_Parameter.noOfCluster;
int noOfHiddenStates = HMM_Parameter.noOfHiddenStates;
int noOfObservedStates = HMM_Parameter.noOfObservedStates;
int outputIndex = trainingSequenceLength + (noOfCluster - 1)

+ (noOfHiddenStates * noOfHiddenStates)
+ (noOfHiddenStates * noOfObservedStates) +
(noOfHiddenStates);
String[] output = new String[outputIndex];
/* here all the observed array values will be stored */

int[] observedValues = new int[trainingSequenceLength];
/* here all the transaction amount will be stored */

double[][] transactionAmount = new
double[trainingSequenceLength][1];
System.out.println(“Generate Module 8th Mar 2013”);

long[] transactionID = new long[trainingSequenceLength];
String cardNumber = ““;
/*
* START: code for selecting 30(trainingSequenceLength) records from
* training table and storing that values in corresponding array
* elements
*/
for (int i = 0; i < trainingSequenceLength; i++) {
StringTokenizer stringTokenizer = new StringTokenizer(
transactionRecordForTraining[i],HMM_Parameter.separaterType);
transactionID[i] = Long.parseLong(stringTokenizer.nextToken());
cardNumber = stringTokenizer.nextToken();
transactionAmount[i][0] = Double.parseDouble(stringTokenizer
.nextToken());
/*
* END: code for selecting 30(trainingSequenceLength) records from
* training table and storing that values in corresponding array
* elements
*/
/*
* START: code for calculating observation symbols using KMeans
* algorithm
*/
- 45 -
HMMKMeans kMeansObj = new HMMKMeans();
double[][] KMeansOutput = null;

try {
KMeansOutput = kMeansObj.RunKMeans(transactionAmount,
noOfCluster, trainingSequenceLength);
System.out.println(“Error at KMeans IOException”);
System.exit(0);
System.out.println(“Error at KMeans InterruptedException”);
System.exit(0);
} catch (ClassNotFoundException e) {
System.out.println(“Error at KMeans ClassNotFoundException”);
System.exit(0);
}
for (int i = 0; i < trainingSequenceLength; i++) {

observedValues[i] = (int) KMeansOutput[i][1];
}
double[] tempTrAmountArray=new double[trainingSequenceLength];

int []obsValues=new int[trainingSequenceLength];
for(int i=0;i<trainingSequenceLength;i++)
{
tempTrAmountArray[i]=transactionAmount[i][0];
obsValues[i]=observedValues[i];
}
quickSort(tempTrAmountArray, obsValues, 0,
trainingSequenceLength-1);
int prevObsSymbol = obsValues[0];

int index = 0;
for (int i = 0; i < 30; i++) {
if (obsValues[i] == prevObsSymbol) {
prevObsSymbol = obsValues[i];
obsValues[i] = index;
} else {
index++;
prevObsSymbol = obsValues[i];
obsValues[i] = index;
}
}
- 46 -
for(int i=0;i<trainingSequenceLength;i++)
{
for(int j=0;j<trainingSequenceLength;j++)
{
if(transactionAmount[i][0]==tempTrAmountArray[j])
observedValues[i]=obsValues[j];
}
}
/*
* END: code for calculating observation symbols using KMeans
algorithm
*/
/*
* START: code for storing non fraud data to Output string so that we
* can set this record as value and key as “nonfraud” in main program
*/
for (outputIndex = 0; outputIndex < trainingSequenceLength;
outputIndex++) {
output[outputIndex] = ““ + transactionID[outputIndex] +
HMM_Parameter.separaterType
+ cardNumber + HMM_Parameter.separaterType +
transactionAmount[outputIndex][0]
+ HMM_Parameter.separaterType +
observedValues[outputIndex];
}
/*
* END: code for storing non fraud data to Output string so that we can
* set this record as value and key as “nonfraud” in main program
*/
/*
* START: Code for calculating the centroid and storing it in output
* string
*/
int parameterMatrixSerialNumber=0;
double temp = 0.0;
for (parameterMatrixSerialNumber= 0; parameterMatrixSerialNumber <
noOfCluster; parameterMatrixSerialNumber++) {
double transactionAmountSum = 0.0;
int transactionAmountCount = 0;
for (int j = 0; j < trainingSequenceLength; j++) {
if (observedValues[j] == parameterMatrixSerialNumber) {
transactionAmountSum += KMeansOutput[j][0];
transactionAmountCount++;
}
}
double avgTransactionAmount = transactionAmountSum
/ transactionAmountCount;
- 47 -
if (parameterMatrixSerialNumber == 0) {
temp = avgTransactionAmount;
} else {
double amount = (avgTransactionAmount + temp) / 2.0;
System.out.println(“Amount:” + amount);
output[outputIndex] = “C” +
HMM_Parameter.separaterType+cardNumber
+HMM_Parameter.separaterType + parameterMatrixSerialNumber +
+ amount;
outputIndex++;
temp = avgTransactionAmount;
}
}
/*
* END: Code for calculating the centroid and storing it in output
* string
*/
int[] percentageOfObservation = new int[noOfObservedStates];

/*
* code for calculating percentage of each observation example: low:
* 30, medium:50, high:20
*/
for (int i = 0; i < noOfObservedStates; i++) {
percentageOfObservation[i] = 0;
for (int j = 0; j < trainingSequenceLength; j++) {
if (i == observedValues[j]) {
percentageOfObservation[i]++;
}
}
}
Matrix transitionP = new DenseMatrix(noOfHiddenStates,

noOfHiddenStates);
Matrix emissionP = new DenseMatrix(noOfHiddenStates,
noOfObservedStates);
Vector initialP = new DenseVector(noOfHiddenStates);
Path hmm_param_input=new Path(“hmm/HMM_PARAMETER”);

FileSystem fs=null;
try {
fs=FileSystem.get(new Configuration());
} catch (IOException e1) {
e1.printStackTrace();
System.out.println(“Error at HMM_Generate_Model-1”);
System.exit(0);
}
- 48 -
double initialPSum = 0.0;

for (int i = 0; i < noOfHiddenStates - 1; i++) {
initialP.setQuick(i, 1.0 / noOfHiddenStates);
initialPSum += initialP.getQuick(i);
}
initialP.setQuick((noOfHiddenStates - 1), (1 - initialPSum));
try {
if(fs.exists(hmm_param_input))
{
FSDataInputStream in=fs.open(hmm_param_input);
BufferedReader brIn=new BufferedReader(new
InputStreamReader(in));
for (int i = 0; i < noOfHiddenStates; i++) {

for (int j = 0; j < noOfHiddenStates; j++) {
transitionP.setQuick(i,
j,Double.parseDouble(brIn.readLine()));
}
}

for (int j = 0; j < noOfObservedStates; j++) {
emissionP.setQuick(i, j,
Double.parseDouble(brIn.readLine()));
}
}
}
else
{
initialP.setQuick(0, 0.5);
initialP.setQuick(1, 0.5);
transitionP.setQuick(0, 0, 0.7);
emissionP.setQuick(0, 0, 0.3);
/*
* Calculating values for emission matrix First Column
*/
/*for (int i = 0; i < noOfObservedStates; i++) {
- 49 -
emissionP.setQuick(0, i,
(double) percentageOfObservation[i]
/ (double) trainingSequenceLength);
}*/
/*
* since we are assuming nrOfHiddenStates=2 we have just
taken
* the reverse of first column as the value for second column
*/
/*for (int i = 0, j = noOfObservedStates - 1; i <
noOfObservedStates; i++, j--) {
emissionP.setQuick(1, i, emissionP.getQuick(0, j));
}*/
/*
* emissionP.setQuick(0, 0,0.3 ); emissionP.setQuick(0, 1,0.5 );
*/
}
System.out.println(“Error at HMM_Generate_Model-2”);
System.exit(0);
}
/*
* Creating a HMM model out of transition matrix,emission matrix and
* initial probability matrix
*/
HmmModel model = new HmmModel(transitionP, emissionP, initialP);
// Matrix emissionMatrix = model.getEmissionMatrix();

// Matrix transitionMatrix = model.getTransitionMatrix();
for(int i=0;i<observedValues.length;i++)
System.out.println(“obs:”+observedValues[i]);
HmmModel trainedModel = HmmTrainer.trainBaumWelch(model,
observedValues, 0.001, 50, true);
/*
* code for storing transition matrix, emission matrix and initial
* probability matrix in a table called HMM_Parameter
*/
for (int i = 1; i <= noOfHiddenStates; i++) {

output[outputIndex] = “pi” +
HMM_Parameter.separaterType+cardNumber +
HMM_Parameter.separaterType+parameterMatrixSerialNumber +
+ trainedModel.getInitialProbabilities().get(i - 1);
- 50 -
System.out.println(“PI-Matrix Value:”+output[outputIndex]);
outputIndex++;
parameterMatrixSerialNumber++;
}

output[outputIndex] = “A” +
+HMM_Parameter.separaterType + parameterMatrixSerialNumber
+ trainedModel.getTransitionMatrix().get(i, j);
System.out.println(“A-Matrix Value:”+output[outputIndex]);
outputIndex++;
}
}

output[outputIndex] = “B” +
+HMM_Parameter.separaterType + parameterMatrixSerialNumber
trainedModel.getEmissionMatrix().get(i, j);
System.out.println(“B-Matrix Value:”+output[outputIndex]);
outputIndex++;
}
}
return output;
}
/*
*/
public static int partition(double[] transactionAmountArray,int

[]obsSymbolArray,int p, int r){
int i=p,j=r;
double pivot=transactionAmountArray[r];
while(i<j){
while(i<r && transactionAmountArray[i] <= pivot){

i++;
}
- 51 -
while(j>p && transactionAmountArray[j]>pivot){

j--;
}
if(i<j){
swap(transactionAmountArray, obsSymbolArray,i, j);
}
}
return j;
}
public static void quickSort(double[] transactionAmountArray, int

[]obsSymbolArray,int p, int r){
if(p<r){
int q=partition(transactionAmountArray, obsSymbolArray,p, r);
if(p==q){
quickSort(transactionAmountArray, obsSymbolArray,p+1, r);
}else if(q==r){
quickSort(transactionAmountArray, obsSymbolArray,p, r-1);
}else {
quickSort(transactionAmountArray, obsSymbolArray,p, q);
quickSort(transactionAmountArray, obsSymbolArray,q+1, r);
}
}
}
public static void swap(double[] transactionAmountArray,int

[]obsSymbolArray,int p1, int p2){
double temp=transactionAmountArray[p1];
transactionAmountArray[p1]=transactionAmountArray[p2];
transactionAmountArray[p2]=temp;
int var=obsSymbolArray[p1];
obsSymbolArray[p1]=obsSymbolArray[p2];
obsSymbolArray[p2]=var;
}
/*
*/
}
4. HMM_Merge_Files Class:
- 52 -
public class HMM_Merge_Files extends Configured implements Tool{
try {
System.out.println(“Key:”+key.toString()+”
value:”+value.toString());
System.out
HMM_Merge_Files class”);
}
}
}
public int run(String[] args) throws Exception {
String output=“hmm/temp_output/”;
Job job = new Job(getConf());
job.setJarByClass(HMM_Merge_Files.class);
job.setJobName(“HMM_Merge_Files”);

Path path = new Path(args[0]);
if (fs.exists(path))
FileInputFormat.addInputPath(job, new Path(args[0]));
else
System.out.println(“HMM_Merge arg[0] doesn't exists”);
return 0;
}
- 53 -
System.out.println(“HMM_Merge_Files”);
HMM_Merge_Files hmm_Merge_Files=new HMM_Merge_Files();
hmm_Merge_Files.run(args);
}
}
5. HMM_Parameter Class:
public class HMM_Parameter {
public static int noOfHiddenStates=2;
public static int noOfObservedStates=3;
public static int trainingSequenceLength=30;
public static int detectionSequenceLength=10;
public static int noOfCluster=3;
public static double EPSILON=0.001;
public static int hadoopClusterSize=1;
public static String nonFraudFolder=“hmm/nonfraud/”;
public static String parameterFolder=“hmm/parameter/”;
public static String trainingFolder=“hmm/training/”;
public static String fraudFolder=“hmm/fraud/”;
public static String separaterType=“|”;
6. HMMDetection_New_MapR Class:
public class HMMDetection_New_MapR extends Configured implements

Tool {
- 54 -
/*
* Input Key: Line Offset(LongWritable) Input Value: Single
Transaction
* Record Output Key : Card_Number Output Value : Single
Transaction
* Record
*/

try {
System.out
HMMDetection_New_MapR class”);
System.exit(0);
}
}
}
/*
* Input Key: Card_Number Input Value: Single Transaction Record List
Output
* Key : Card_Number Output Value : Single Transaction Record List
*/
public static class Reduce extends Reducer<Text, Text, Text, Text> {
public void reduce(Text key, Iterable<Text> values, Context context) {
int noOfCluster = HMM_Parameter.noOfCluster;

int noOfHiddenStates = HMM_Parameter.noOfHiddenStates;
int noOfObservedStates = HMM_Parameter.noOfObservedStates;
int detectionSequenceLength =
HMM_Parameter.detectionSequenceLength;
int parameterMatrixRowCount = (noOfCluster - 1)

+ (noOfHiddenStates * noOfHiddenStates)
+ (noOfHiddenStates * noOfObservedStates)
+ (noOfHiddenStates);
int countParameterMatrixRowCount = 0;
int countNonFraudRecords = 0;
int countOfRecords4Detection = 0;
/* here all the observed array values will be stored */

int[] observedValues = new int[detectionSequenceLength];
int[] observedValuesTemp = new int[detectionSequenceLength];
- 55 -
Matrix transitionP = new DenseMatrix(noOfHiddenStates,

noOfHiddenStates);
Matrix emissionP = new DenseMatrix(noOfHiddenStates,
noOfObservedStates);
Vector initialP = new DenseVector(noOfHiddenStates);
double[] centroidValues = new double[noOfCluster - 1];
double[] transactionAmountArray = new

double[parameterMatrixRowCount];
List<String> ls = new ArrayList<String>();

int listCounter = 0;
for (Text val : values) {
String record = val.toString();
ls.add(listCounter, record);
// System.out.println(“Get:”+ls.get(listCounter));
listCounter++;
StringTokenizer stringTokenizer = new StringTokenizer(record,
int count = stringTokenizer.countTokens();
String identifier = stringTokenizer.nextToken();
// System.out.println(“identifier:”+identifier);
// System.out.println(“Count:”+count);
if (count == 4) {
if (identifier.equalsIgnoreCase(“C”)
|| identifier.equalsIgnoreCase(“PI”)
|| identifier.equalsIgnoreCase(“A”)
|| identifier.equalsIgnoreCase(“B”)) {
countParameterMatrixRowCount++;
stringTokenizer.nextToken();
transactionAmountArray[Integer.parseInt(stringTokenizer
.nextToken()) - 1] = Double
.parseDouble(stringTokenizer.nextToken());
// System.out.println(“If case”);
} else {
countNonFraudRecords++;
}
} else {
countOfRecords4Detection++;
}
}
/*
* System.out.println(“countParameterMatrixRowCount:”+
* countParameterMatrixRowCount);
*
System.out.println(“countNonFraudRecords:”+countNonFraudRecords);
- 56 -
* System
* .out.println(“countOfRecords4Detection:”+countOfRecords4Detection
* ); System.out.println(“Total:”+listCounter);
*/
if (countParameterMatrixRowCount == parameterMatrixRowCount)
{
int index = 0;
for (int i = 0; i < centroidValues.length; i++) {
centroidValues[i] = transactionAmountArray[index];
index++;
}
initialP.setQuick(i, transactionAmountArray[index]);
index++;
}
transitionP.setQuick(i, j,
transactionAmountArray[index]);
index++;
}
}
emissionP.setQuick(i, j,
transactionAmountArray[index]);
index++;
}
}
} else {
System.out.println(“Error in parameter matrix row count:”
+ countParameterMatrixRowCount);
System.exit(0);
}
long[] transactionID = new long[countNonFraudRecords];

int[] observationSymbol = new int[countNonFraudRecords];
countNonFraudRecords = 0;
String[] records = new String[countOfRecords4Detection];

countOfRecords4Detection = 0;
listCounter = 0;
while (listCounter < ls.size()) {
String record = ls.get(listCounter);
StringTokenizer stringTokenizer = new StringTokenizer(record,
int count = stringTokenizer.countTokens();
String trID = stringTokenizer.nextToken();
- 57 -
String identifier = trID;

if (count == 4) {
if (identifier.equalsIgnoreCase(“C”)
|| identifier.equalsIgnoreCase(“PI”)
|| identifier.equalsIgnoreCase(“A”)
|| identifier.equalsIgnoreCase(“B”)) {
} else {
transactionID[countNonFraudRecords] = Long
.parseLong(trID);
observationSymbol[countNonFraudRecords] = Integer
.parseInt(stringTokenizer.nextToken());
countNonFraudRecords++;
}
} else {
records[countOfRecords4Detection] = record;
countOfRecords4Detection++;
}
listCounter++;
}
/*
* START: Sort transactionID array to get latest 10 transactions
*/
quickSort(transactionID, observationSymbol, 0,
countNonFraudRecords - 1);
/*
* END: Sort transactionID array to get latest 10 transactions
*/
/*
* START: Code for selecting latest 10 transactions
*/
for (int i = 0; i < detectionSequenceLength; i++) {

countNonFraudRecords--;
observedValues[i] =
observationSymbol[countNonFraudRecords];
}
/*
* END: Code for selecting latest 10 transactions
*/
/*
* START: After getting latest 10 transactions and parameter
matrix,
- 58 -
* now we need to detect fraud or not

*/
for (int recordIndex = 0; recordIndex < records.length;
recordIndex++) {
int obsSymbol = 0;
Long trID = 0L;
String dateOfTransaction = null;
String transactionType = null;
String posMachineID = null;
String IPAddressID = null;
String shippingAddress = null;
String shipping_type=null;
String issuerID = null;
String merchantID = null;
// String merchantCatID = null;
String productID = null;
String locationID = null;
String billingName = null;
int Qty = 0;
double transactionAmount = 0;
String transactionCurrencyCode = null;
String emailID = null;
String phoneNumber = null;
try {
StringTokenizer tokenizerDetection = new
StringTokenizer(
records[recordIndex],
trID = Long.parseLong(tokenizerDetection.nextToken());
tokenizerDetection.nextToken();
dateOfTransaction = tokenizerDetection.nextToken();
transactionType = tokenizerDetection.nextToken();
posMachineID = tokenizerDetection.nextToken();
IPAddressID = tokenizerDetection.nextToken();
shippingAddress = tokenizerDetection.nextToken();
shipping_type =tokenizerDetection.nextToken();
issuerID = tokenizerDetection.nextToken();
merchantID = tokenizerDetection.nextToken();
// merchantCatID = tokenizerDetection.nextToken();
productID = tokenizerDetection.nextToken();
locationID = tokenizerDetection.nextToken();
Qty = Integer.parseInt(tokenizerDetection.nextToken());
transactionAmount =
Double.parseDouble(tokenizerDetection
.nextToken());
transactionCurrencyCode =
tokenizerDetection.nextToken();
billingName = tokenizerDetection.nextToken();
- 59 -
emailID = tokenizerDetection.nextToken();
phoneNumber = tokenizerDetection.nextToken();
System.out.println(“Error in extracting values:”
+ records[recordIndex]);
}
for (int i = 0; i < noOfCluster - 1; i++) {

if (transactionAmount <= centroidValues[i]) {
obsSymbol = i;
break;
}
}
if (transactionAmount > centroidValues[noOfCluster - 2])

obsSymbol = noOfCluster - 1;
HmmModel model = new HmmModel(transitionP, emissionP,

initialP);
Matrix alpha = HmmAlgorithms.forwardAlgorithm(model,

observedValues, false);
double alpha1 = HmmEvaluator.modelLikelihood(alpha, false);
for (int i = 0; i < detectionSequenceLength - 1; i++) {

observedValuesTemp[i] = observedValues[i + 1];
}
observedValuesTemp[detectionSequenceLength - 1] =
obsSymbol;
alpha = HmmAlgorithms.forwardAlgorithm(model,
observedValuesTemp, false);
double alpha2 = HmmEvaluator.modelLikelihood(alpha, false);
double deltaAlpha = alpha1 - alpha2;
if ((deltaAlpha / alpha1) >= HMM_Parameter.EPSILON) {

/*
* START: code for inserting this transaction data by
* marking it as FRAUD
*/
// System.out.println(“FRAUD”);
String sqlQuery = ““ + trID +
+ key.toString() + HMM_Parameter.separaterType
- 60 -
+ dateOfTransaction +
+ transactionType +
+ posMachineID +
+ IPAddressID + HMM_Parameter.separaterType
+ shippingAddress +
+shipping_type +HMM_Parameter.separaterType
+ issuerID + HMM_Parameter.separaterType
+ merchantID + HMM_Parameter.separaterType
// + merchantCatID +
+ productID + HMM_Parameter.separaterType
+ locationID + HMM_Parameter.separaterType +
Qty
transactionAmount
transactionCurrencyCode
+ billingName
+ emailID
phoneNumber
+ HMM_Parameter.separaterType + “H”;
// System.out.println(“Fraud:” + sqlQuery);
try {
context.write(new Text(“FRAUD”), new
Text(sqlQuery));
System.out
.println(“Error in writing to fraud file in
HMMDetection class”);
System.exit(0);
}
/*
* END: code for inserting this transaction data by marking
* it as FRAUD
*/
} else {
/*
* START: code for inserting this transaction data by
* marking it as NON-FRAUD
*/
// System.out.println(“NON-FRAUD”);
String sqlQuery = ““ + trID +
- 61 -
+ key.toString() + HMM_Parameter.separaterType
+ transactionAmount +
+ obsSymbol;
// System.out.println(“Non-Fraud:” + sqlQuery);
try {
context.write(new Text(“NONFRAUD”), new
Text(sqlQuery));
System.out
.println(“Error in writing to non fraud file in
HMMDetection class”);
System.exit(0);
}
/*
* START: code for inserting non fraud record into
* observedvalue array so that it can be further used
*/
for (int i = 0; i < detectionSequenceLength - 1; i++) {
observedValues[i] = observedValues[i + 1];
}
observedValues[detectionSequenceLength - 1] =
obsSymbol;
/*
* END: code for inserting non fraud record into
* observedvalue array so that it can be further used
*/
/*
* END: code for inserting this transaction data by marking
* it as NON-FRAUD
*/
}
}
/*
* END: After getting latest 10 transactions and parameter matrix,
* now we need to detect fraud or not
*/
/*
*/
public static int partition(long[] transactionIDArray,

int[] transactionInASingleDay, int p, int r) {
- 62 -
int i = p, j = r;
long pivot = transactionIDArray[r];
while (i < j) {
while (i < r && transactionIDArray[i] <= pivot) {

i++;
}
while (j > p && transactionIDArray[j] > pivot) {

j--;
}
if (i < j) {
swap(transactionIDArray, transactionInASingleDay, i, j);
}
}
return j;
}
public static void quickSort(long[] transactionIDArray,

int[] transactionInASingleDay, int p, int r) {
if (p < r) {
int q = partition(transactionIDArray, transactionInASingleDay,
p, r);
if (p == q) {
quickSort(transactionIDArray, transactionInASingleDay,
p + 1, r);
} else if (q == r) {
quickSort(transactionIDArray, transactionInASingleDay, p,
r - 1);
} else {
quickSort(transactionIDArray, transactionInASingleDay, p,
q);
quickSort(transactionIDArray, transactionInASingleDay,
q + 1, r);
}
}
}
public static void swap(long[] transactionIDArray,

int[] transactionInASingleDay, int p1, int p2) {
long temp = transactionIDArray[p1];
transactionIDArray[p1] = transactionIDArray[p2];
transactionIDArray[p2] = temp;
int tmp = transactionInASingleDay[p1];
- 63 -
transactionInASingleDay[p1] = transactionInASingleDay[p2];
transactionInASingleDay[p2] = tmp;
}
/*
*/
}
public int run(String[] args) {
String output = “hmm/output/”;

Job job = null;
try {
job = new Job(getConf());
System.out.println(“Error in Job(getConf())”);
}
job.setJarByClass(HMMDetection_New_MapR.class);
job.setJobName(“HMMDetection_New_MapR”);
job.setReducerClass(Reduce.class);
try {
Path path = new Path(HMM_Parameter.nonFraudFolder);

FileInputFormat.addInputPath(job, path);
else {
System.out.println(HMM_Parameter.nonFraudFolder
+ “ doesn't exists”);
System.exit(0);
}
path = new Path(HMM_Parameter.parameterFolder);

FileInputFormat.addInputPath(job, path);
else {
System.out.println(HMM_Parameter.parameterFolder
+ “ doesn't exists”);
System.exit(0);
- 64 -
System.out.println(“Error in FileInputFormat.addInputPath()”);
}
try {
System.out.println(“Error in job.waitForCompletion()”);
}
return 1;
}
}
7. HMMKMeans Class:
public class HMMKMeans {

public static final double[][] points = { { 316.8 }, { 578.8 }, { 1112.5 },
{ 1279.6 }, { 1441.6 }, { 1138.7 }, { 1421.4 }, { 498.1 },
{ 754.6 }, { 140.8 }, { 140.8 }, { 672.5 }, { 980.9 }, { 1460.9 },
{ 454.9 }, { 215.3 }, { 693.9 }, { 275.1 }, { 1111.8 }, { 1134.6 },
{ 238.8 }, { 114.3 }, { 716.9 }, { 299.8 }, { 1054 }, { 616.4 },
{ 1043.6 }, { 198.2 }, { 1385.2 }, { 262.4 } };
public void writePointsToFile(List<Vector> points, String fileName,

FileSystem fs, Configuration conf) throws IOException {
Path path = new Path(fileName);
SequenceFile.Writer writer = new SequenceFile.Writer(fs, conf, path,

LongWritable.class, VectorWritable.class);
long recNum = 0;
VectorWritable vec = new VectorWritable();
for (Vector point : points) {

vec.set(point);
writer.append(new LongWritable(recNum++), vec);
}
writer.close();
}
public List<Vector> getPoints(double[][] raw) {
List<Vector> points = new ArrayList<Vector>();

for (int i = 0; i < raw.length; i++) {
- 65 -
double[] fr = raw[i];
Vector vec = new RandomAccessSparseVector(fr.length);
vec.assign(fr);
points.add(vec);
}
return points;
}

HMMKMeans obj = new HMMKMeans();
try {
obj.RunKMeans(points, 3, 30);
System.out.println(“IOException”);
System.out.println(“InterruptedException”);
} catch (ClassNotFoundException e) {
System.out.println(“ClassNotFoundException”);
}
}
public static void deleteDir(File dir) throws IOException {

if (!dir.isDirectory()) {
throw new IOException(“Not a directory “ + dir);
}
File[] files = dir.listFiles();

for (int i = 0; i < files.length; i++) {
File file = files[i];
if (file.isDirectory()) {
deleteDir(file);
} else {
boolean deleted = file.delete();
if (!deleted) {
throw new IOException(“Unable to delete file” + file);
}
}
}
dir.delete();
}
public double[][] RunKMeans(double[][] transactionAmount, int

noOfCluster,
int trainingSequenceLength) throws IOException,
InterruptedException, ClassNotFoundException {
- 66 -
/*here k is the no. of clusters into which the given points needs to be
* clustered
*/
int k = noOfCluster;
List<Vector> vectors = getPoints(transactionAmount);
File testDataDirectory = new File(“testdata”);

if (!testDataDirectory.exists()) {
testDataDirectory.mkdir();
}
File testData = new File(“testdata/points”);
if (!testData.exists()) {
testData.mkdir();
}
Configuration conf = new Configuration();

FileSystem fs = FileSystem.get(conf);
writePointsToFile(vectors, “testdata/points/file1”, fs, conf);
Path path = new Path(“testdata/clusters/part-00000”);
SequenceFile.Writer writer = new SequenceFile.Writer(fs, conf, path,
Text.class, Cluster.class);
DistanceMeasure measure = new EuclideanDistanceMeasure();
for (int i = 0; i < k; i++) {
Vector vec = vectors.get(i);
Cluster cluster = new Cluster(vec, i, measure);
writer.append(new Text(cluster.getIdentifier()), cluster);
}
writer.close();
KMeansDriver.run(new Path(“testdata/points”), new Path(

“testdata/clusters”), new Path(“output”),
new EuclideanDistanceMeasure(), 0.001, 10, true, false);
SequenceFile.Reader reader = new SequenceFile.Reader(fs, new Path(
“output/” + Cluster.CLUSTERED_POINTS_DIR + “/part-m-
00000”),
conf);
IntWritable key = new IntWritable();
WeightedVectorWritable value = new WeightedVectorWritable();
double[][] KMeansOutput = new double[trainingSequenceLength][2];
int index = 0;
while (reader.next(key, value)) {
if (index < trainingSequenceLength) {
KMeansOutput[index][0] = transactionAmount[index][0];
KMeansOutput[index][1] =
Double.parseDouble(key.toString());
System.out.println(KMeansOutput[index][0] + “,”
+ KMeansOutput[index][1]);
- 67 -
index++;
}
}
reader.close();
deleteDir(testDataDirectory);
return KMeansOutput;
}
}
8. HMMMain Class :
public class HMMMain_New_MapR implements Tool {
/**
* @param args
*/
@SuppressWarnings({ “deprecation” })
String hmmInput = “hmm/input/”;

String hmmCategoriseOutput = “hmm/categorise_result/”;
String detectionOutput = “hmm/output/”;
boolean nonFraudFileFlag = false;

boolean fraudFileFlag = false;
boolean trainingFileFlag = false;
boolean parameterFileFlag = false;
boolean detectionFileFlag = false;
/*
* START: Code to create hmm directory with its subdirectories like
* nonfraud,parameter,training,fraud
*/
FileSystem fs = null;
try {
fs = FileSystem.get(new Configuration());
Path path = new Path(HMM_Parameter.trainingFolder);
if (!fs.isDirectory(path)) {
fs.delete(path);
fs.mkdirs(path);
}
path = new Path(HMM_Parameter.fraudFolder);
fs.delete(path);
fs.mkdirs(path);
}
- 68 -
path = new Path(HMM_Parameter.nonFraudFolder);

fs.delete(path);
fs.mkdirs(path);
}
path = new Path(HMM_Parameter.parameterFolder);
fs.delete(path);
fs.mkdirs(path);
}
System.out.println(“Error in Creating Directories”);
System.exit(0);
}
try {
fs.close();
System.out.println(“fs close error”);
}
/*
* END: Code to create hmm directory with its subdirectories like
* nonfraud,parameter,training,fraud
*/
/*
* START: Code to Format the input files
* This HMM_Format_Input_Files class will group all the card numbers
from different input files
*/
// HMM_Format_Input_Files hmm_Format_Input_Files=new
// HMM_Format_Input_Files();
try {
ToolRunner.run(new HMM_Format_Input_Files(), args);
} catch (Exception e1) {
System.out.println(“Error at formatting the input files”);
System.exit(0);
}
System.out.println(“done...”);
/*
* END: Code to Format the input files
* This HMM_Format_Input_Files class will group all the card numbers
from different input files
*/
/*
* First call HMM_Categorise_Record to know where will the current
* transaction will go either to detection module or to training file or
- 69 -
* to generate model
*/
// HMM_Categorise_Record hmm_Categorise_Record = new

// HMM_Categorise_Record();
// hmmCategoriseOutput=hmm_Categorise_Record.run(hmmInput);
String[] arg = new String[1];
arg[0] = hmmInput;
try {
ToolRunner.run(new HMM_Categorise_Record(), arg);
System.out.println(“Error at Categorising the files”);
System.exit(0);
}
System.out.println(“done...”);
/*
* START: code for writing categorisation data to respective files
*/
Path createNonFraudFile = null;

FSDataOutputStream fsCreateNonFraudFile = null;
BufferedWriter bwCreateNonFraudFile = null;
Path createTrainingFile = null;

FSDataOutputStream fsCreateTrainingFile = null;
BufferedWriter bwCreateTrainingFile = null;
Path createDetectionFile = null;

FSDataOutputStream fsCreateDetectionFile = null;
BufferedWriter bwCreateDetectionFile = null;
Path createParamterFile = null;

FSDataOutputStream fsCreateParameterFile = null;
BufferedWriter bwCreateParameterFile = null;
String nonFraudFileName = “hmm/temp_files/nonfraud”;

String trainingFileName = “hmm/temp_files/training”;
String detectionFileName = “hmm/temp_files/detection”;
String parameterFileName = “hmm/temp_files/parameter”;
String fraudFileName = “hmm/temp_files/fraud”;
try {
createNonFraudFile = new Path(nonFraudFileName);
fsCreateNonFraudFile = fs.create(createNonFraudFile, true);
bwCreateNonFraudFile = new BufferedWriter(new
OutputStreamWriter(
fsCreateNonFraudFile));
- 70 -
createTrainingFile = new Path(trainingFileName);

fsCreateTrainingFile = fs.create(createTrainingFile, true);
bwCreateTrainingFile = new BufferedWriter(new
OutputStreamWriter(
fsCreateTrainingFile));
createDetectionFile = new Path(detectionFileName);

fsCreateDetectionFile = fs.create(createDetectionFile, true);
bwCreateDetectionFile = new BufferedWriter(new
OutputStreamWriter(
fsCreateDetectionFile));
createParamterFile = new Path(parameterFileName);

fsCreateParameterFile = fs.create(createParamterFile, true);
bwCreateParameterFile = new BufferedWriter(new
OutputStreamWriter(
fsCreateParameterFile));
System.out.println(“Error in Temp File Creation”);
System.exit(0);
}
try {
FileStatus[] status = fs.listStatus(new Path(hmmCategoriseOutput));

for (int i = 0; i < status.length; i++) {
Path temp = status[i].getPath();
// System.out.println(“File Name:” + temp.toString());
if (fs.isFile(temp)) {
BufferedReader br = new BufferedReader(
new InputStreamReader(fs.open(temp)));
String line;
line = br.readLine();
while (line != null) {
// System.out.println(line);
int index = line.indexOf(“\t”);
String identifier = line.substring(0, index);
String record = line.substring(index + 1);
// System.out.println(“Identifier:” + identifier+
// “||Record:” + record);
StringTokenizer stringTokenizer = new

StringTokenizer(
record, HMM_Parameter.separaterType);
String cardNumberAsKey =
cardNumberAsKey = stringTokenizer.nextToken();
- 71 -
if (identifier.equalsIgnoreCase(“NONFRAUD”)) {
nonFraudFileFlag = true;
bwCreateNonFraudFile.write(cardNumberAsKey);
bwCreateNonFraudFile.write(“\t”);
bwCreateNonFraudFile.write(record);
bwCreateNonFraudFile.newLine();
} else if (identifier.equalsIgnoreCase(“TRAINING”)) {
trainingFileFlag = true;
bwCreateTrainingFile.write(cardNumberAsKey);
bwCreateTrainingFile.write(“\t”);
bwCreateTrainingFile.write(record);
bwCreateTrainingFile.newLine();
} else if (identifier.equalsIgnoreCase(“DETECTION”))
{
detectionFileFlag = true;
bwCreateDetectionFile.write(cardNumberAsKey);
bwCreateDetectionFile.write(“\t”);
bwCreateDetectionFile.write(record);
bwCreateDetectionFile.newLine();
} else if
(identifier.equalsIgnoreCase(“HMMPARAMETER”)) {
parameterFileFlag = true;
bwCreateParameterFile.write(cardNumberAsKey);
bwCreateParameterFile.write(“\t”);
bwCreateParameterFile.write(record);
bwCreateParameterFile.newLine();
} else {
System.out.println(“Identifier else part:”
+ identifier);
}
}
}
}
bwCreateDetectionFile.close();
fsCreateDetectionFile.close();
bwCreateNonFraudFile.close();
fsCreateNonFraudFile.close();
bwCreateTrainingFile.close();
fsCreateTrainingFile.close();
bwCreateParameterFile.close();
fsCreateParameterFile.close();
System.out.println(“Error at HMMMain_New_MapR-1”);
System.exit(0);
- 72 -
/*
* END: code for writing categorisation data to respective files
*/
/*
* START: Code for Inserting Temp NONFRAUD file data, parameter
data and
* Training data to Original folders
*/
// HMM_Merge_Files hmm_Merge_Files = new HMM_Merge_Files();

try {
String hmmMergeOutputFolder = “hmm/temp_output/”;
String[] strArgs = new String[2];
if (nonFraudFileFlag == true) {
strArgs[0] = HMM_Parameter.nonFraudFolder;
strArgs[1] = nonFraudFileName;
ToolRunner.run(new HMM_Merge_Files(), strArgs);
fs.delete(new Path(HMM_Parameter.nonFraudFolder), true);

fs.rename(new Path(hmmMergeOutputFolder), new Path(
HMM_Parameter.nonFraudFolder));
}
if (trainingFileFlag == true) {
strArgs[0] = HMM_Parameter.trainingFolder;
strArgs[1] = trainingFileName;
fs.delete(new Path(HMM_Parameter.trainingFolder), true);

HMM_Parameter.trainingFolder));
}
if (parameterFileFlag == true) {
strArgs[0] = HMM_Parameter.parameterFolder;
strArgs[1] = parameterFileName;
fs.delete(new Path(HMM_Parameter.parameterFolder), true);

HMM_Parameter.parameterFolder));
}
System.out.println(“Error in merging temporary files”);
- 73 -
System.exit(0);
}
System.out.println(“stage 3”);
/*
* END: Code for Inserting Temp NONFRAUD file data and Training
data to
* Original folders
*/
/*
* START: code for calling the Detection Module
*/
if (detectionFileFlag == true) {
nonFraudFileFlag = false;
arg[0] = detectionFileName;
// HMMDetection_New_MapR hmmDetection_New_MapR = new
// HMMDetection_New_MapR();
//
detectionOutput=hmmDetection_New_MapR.run(detectionFileName);
try {
ToolRunner.run(new HMMDetection_New_MapR(), arg);
System.out.println(“HmmDetection error”);
}
/*
* END: code for calling the Detection Module
*/
/*
* START: After detection the next step is to insert the records in
* temp files
*/
Path NonFraudFile = null;

FSDataOutputStream fsNonFraudFile = null;
BufferedWriter bwNonFraudFile = null;
Path FraudFile = null;

FSDataOutputStream fsFraudFile = null;
BufferedWriter bwFraudFile = null;
try {
NonFraudFile = new Path(nonFraudFileName);
fsNonFraudFile = fs.create(NonFraudFile, true);
bwNonFraudFile = new BufferedWriter(new
OutputStreamWriter(
- 74 -
fsNonFraudFile));
FraudFile = new Path(fraudFileName);

fsFraudFile = fs.create(FraudFile, true);
bwFraudFile = new BufferedWriter(new OutputStreamWriter(
fsFraudFile));
System.out.println(“Error in Temp File Creation”);
System.exit(0);
}
try {
FileStatus[] status = fs.listStatus(new Path(detectionOutput));

for (int i = 0; i < status.length; i++) {
Path temp = status[i].getPath();
System.out.println(“File Name:” + temp.toString());
if (fs.isFile(temp)) {
BufferedReader br = new BufferedReader(
new InputStreamReader(fs.open(temp)));
String line;
while (line != null) {
// System.out.println(line);
int index = line.indexOf(“\t”);
String identifier = line.substring(0, index);
String record = line.substring(index + 1);
// System.out.println(“Identifier:” + identifier +
// “||Record:” + record);
StringTokenizer stringTokenizer = new

StringTokenizer(
record, HMM_Parameter.separaterType);
String cardNumberAsKey = stringTokenizer
.nextToken();
cardNumberAsKey =
if (identifier.equalsIgnoreCase(“NONFRAUD”)) {
nonFraudFileFlag = true;
bwNonFraudFile.write(cardNumberAsKey);
bwNonFraudFile.write(“\t”);
bwNonFraudFile.write(record);
bwNonFraudFile.newLine();
} else if (identifier.equalsIgnoreCase(“FRAUD”))
{
fraudFileFlag = true;
bwFraudFile.write(cardNumberAsKey);
- 75 -
bwFraudFile.write(“\t”);
bwFraudFile.write(record);
bwFraudFile.newLine();
} else {
System.out.println(“Identifier:” + identifier);
}
}
}
}
bwFraudFile.close();
bwFraudFile.close();
bwNonFraudFile.close();
fsNonFraudFile.close();
System.out.println(“Error at HMMMain_New_MapR-1”);
System.exit(0);
}
System.out.println(“stage 4”);
/*
* END: After detection the next step is to insert the records in
* temp files
*/
/*
* START: Code for inserting the above temp files in their
* respective places
*/
try {
String hmmMergeOutputFolder = “hmm/temp_output/”;
String[] strArgs = new String[2];
if (nonFraudFileFlag == true) {
strArgs[0] = HMM_Parameter.nonFraudFolder;
strArgs[1] = nonFraudFileName;
fs.delete(new Path(HMM_Parameter.nonFraudFolder),
true);
HMM_Parameter.nonFraudFolder));
}
if (fraudFileFlag == true) {
strArgs[0] = HMM_Parameter.fraudFolder;
strArgs[1] = fraudFileName;
- 76 -
fs.delete(new Path(HMM_Parameter.fraudFolder), true);

HMM_Parameter.fraudFolder));
}
System.out.println(“Error in merging temp files”);
System.exit(0);
}
}
/*
* END: Code for inserting the above temp files in their respective
* places
*/
try {
fs.delete(new Path(hmmInput), true);
System.out.println(hmmInput + “ folder deleted”);
fs.delete(new Path(hmmCategoriseOutput), true);
System.out.println(hmmCategoriseOutput + “ folder deleted”);
fs.delete(new Path(detectionOutput), true);
System.out.println(detectionOutput + “ folder deleted”);
fs.delete(new Path(“hmm/temp_files/”), true);
System.out.println(“hmm/temp_files/ folder deleted”);

System.out.println(“Error in deleting temporary folder”);
System.exit(0);
}
System.out.println(“Processing Done...”);
System.out.println(“Processed records are there in respective places”);
}
@Override
public Configuration getConf() {
return null;
}
@Override
public void setConf(Configuration arg0) {
}
@Override
public int run(String[] arg0) throws Exception {
- 77 -
return 0;
}
}
******** END ********
- 78 -

Copyright of Items Produced by Artificial Intelligence

Uploaded by

Document Information

Copyright

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Copyright of Items Produced by Artificial Intelligence

Uploaded by

Copyright:

Copyright Law Article

Copyright of Items Created By

Assignment Under The Guidance Of: Prof S. Matilal

“RAJIV GANDHI SCHOOL OF INTELLECTUAL PROPERTY LAW, IIT KHARAGPUR” ON

Sourish Roy - LL.B. Batch 2017-20

D) Possible Approach .........................................................................................................................- 23 -

E) Legal Personality of AI as Employee ............................................................................................- 28 -

1. HMM_Categorise_Record Class: ...........................................................................................- 34 -

2. HMM_Format_Input_Files Class: ..........................................................................................- 43 -

3. HMM_Generate_Model Class: ...............................................................................................- 44 -

4. HMM_Merge_Files Class: .....................................................................................................- 52 -

5. HMM_Parameter Class: .........................................................................................................- 54 -

6. HMMDetection_New_MapR Class: ......................................................................................- 54 -

7. HMMKMeans Class: ..............................................................................................................- 65 -

8. HMMMain Class : ..................................................................................................................- 68 -

Artificial Intelligence (AI) and Copyright:

A) Introduction - With the advent of high-end computing power, advanced algorithms

(i) it should not be copied from others and

(ii) it should satisfy the threshold of originality;

(1) literary works;

(2) musical works, including any accompanying words;

(3) dramatic works, including any accompanying music;

(4) pantomimes and choreographic works;

(5) pictorial, graphic, and sculptural works;

(6) motion pictures and other audiovisual works;

(7) sound recordings; and

(8) architectural works.

Regarding ownership, Indian Copyright Act9 states -

(1) a work prepared by an employee, within the scope of employment; or

(2) a work specially ordered/ commissioned for use, as a contribution to a collective

a) “a contribution to a collective work”,

b) “a part of a motion picture or other audiovisual work”,

f) “an instructional text”,

h) “answer material for a test”,

2. “The work must be specially ordered or commissioned”;

A) a work prepared by an employee within the scope of his or her employment

B) a work specially ordered or commissioned for use -

1 (a) to (i) (supra)

The US Supreme Court’s judgment in “Community for Creative Non-Violence” case

“by (a) an employee or by (b) an independent contractor”

(b) “there is an express written agreement between parties” and

The US Supreme Court in “Community for Creative Non-Violence” (supra), identified

3. Status and conduct of employer, in relation to the employee. For example, an

 A software program in a specific language that is developed by a computer

 A newspaper or magazine article written by a journalist in regular payroll of a

 A musical composition by a musician in the music production company’s payroll

The closer the employment-relationship comes to being a regular, salaried employment;

The debate begins from here.

Works of Artificial Intelligence (AI) and Copyright Premises:

One group postulates that ownership of copyright should be extended to non-humans

As increasing number of creative works started getting generated by non-human (AI)

Another somewhat outlandish suggestion, is to attribute copyright to the AI system

Another option which advocates giving authorship to the AI programmer or the

When it comes to artificial intelligence algorithms, they are capable of generating a

“Copyright protection subsists, in accordance with this title, in original works of

A germinal issue of contention about AI-generated works is whether such AI-generated

Let us now take a look at how AI works.

Way of Working of Artificial Intelligence:

C) AI Operation - To under the basic principles of AI operation, we shall consider the

1. High Value Check

2. Counter-Based, Constant Velocity Checks

3. Counter-Based, Change-Detection Velocity Checks

4. Value-based Velocity Checks

5. Velocity Change With Respect To Card Number

6. Velocity Change With Respect To Phone Number

7. Shipping Rule Check

8. Warm and Hot List Check