Understand Python for Enterprise Artificial Intelligence
Learn AI by Working with a World-Class, No-Cost Advanced AI Computing Lab
Reinvent traditional software through DeepSphere.AI Enterprise AI platform through software engineering from hardcoded instruction-driven
automation to the machine self-learning application for the digital era.
Code
Test
Deploy
Be Empowered by Our School of AI through Learning with Intelligent Automation
Learn Enterprise AI and Advanced Python without Coding
Test
Become an AI Architect and AI Engineer through the Pathway of Our DeepSphere.AI learning Platform
Choose Your AI Specialization
Acquire Cross-Functional Skills from Business to Data to Technology by Mastering AI
Learning Path
Learn How Our School of AI Teaches Workers to Transfer Business Processes to the Modern Digital World
Choose Your Hands-On Learning Unit
Develop an AI Application Using our Pre-Built Scala Libraries. Coding is No Longer Necessary
Master Artificial Intelligence with Hundreds of
Predeveloped Python Programs
Purpose : A Simple Hello World Program in Python
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:00 hrs
Version : 1.0
## Program Description : A "Hello, World!" Program in Python ## Python Development Environment & Runtime - Python, Anaconda print ("Hello World!") /************** Disclaimer: We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product. /**************
Purpose : A Program to show Variables in Python
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:00 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Variables for Integer, Floating Point Integer & String Assignment in Python
## Python Development Environment & Runtime - Python, Anaconda
# An Integer Assignment
vAR_Counter = 100
# Floating Point Integer Assignment
vAR_Miles = 1000.0
# String Assignment
vAR_Name = "John"
print (vAR_Counter)
print (vAR_Miles)
print (vAR_Name)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_TYPE_INTEGER_V1
Purpose : A Program in Python to show Integer Assignment
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:58 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Integer Assignment by Variables in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_Counter = 100
print (vAR_Counter)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_TYPE_FLOATING_POINT_V1
Purpose : A Program in Python to show Floating Point Integer Assignment
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:57 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Floating Point Integer Assignment by Using Variables in Python
## Python Development Environment & Runtime - Python, Anaconda
# A floating Point Integer Assignment vAR_Miles = 1000.0
print (vAR_Miles)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_TYPE_STRING_V1
Purpose : A Program in Python to show String Assignment
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 13:12 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Usage of Strings in Python
## Python Development Environment & Runtime - Python, Anaconda
# String Assignment
vAR_Name = "John"
print (vAR_Name)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_COMPLEX_NUMBERS_V1
Purpose : A Program in Python to show Complex Numbers
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 14:04 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Complex Numbers in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_Z = 2+3j
vAR_Z.real
vAR_Z.imag
vAR_Z.conjugate()
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_DEFINE_FUNCTIONS_V1
Purpose : A Program in Python to Define Functions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 14:32 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Defining Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_My_Function():
print("Hello from a function")
vAR_My_Function()
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_DYNAMIC_TYPING
Purpose : A Program in Python for Dynamic Typing
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 15:03 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Dynamic Typing in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_EMPNAME = 9
vAR_EMPNAME = "Steve Ferg"
print(vAR_EMPNAME)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_STATIC_TYPING
Purpose : A Program in Python for Static Typing
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 15:37 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Static Typing in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_A = 9
vAR_B = "9"
print(vAR_A)
print(vAR_B)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_BOOLEAN_EVALUATION
Purpose : A Program in Python for Boolean Evaluation
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 15:37 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Boolean Evaluation in Python
## Python Development Environment & Runtime - Python, Anaconda
5 == 5
5 == 6
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_IF_STATEMENT
Purpose : A Program in Python for If Statement
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 16:18 hrs
Version : 1.0
/****************************************
## Program Description : A Program for IF Statement in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR1 = 100
if vAR1:
print ("Got a true expression value")
print(vAR1)
vAR2 = 0
if vAR2:
print ("Got a true expression value")
print(vAR2)
print ("Good bye!")
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_IF_ELSE_STATEMENT
Purpose : A Program in Python for Ifelse Statement
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 16:49 hrs
Version : 1.0
/****************************************
## Program Description : A Program for IF Else Statement in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR1 = 100
if vAR1:
print ("1 - Got a true expression value")
print (vAR1)
else:
print ("1 - Got a false expression value")
print (vAR1)
vAR2 = 0
if vAR2:
print ("2 - Got a true expression value")
print (vAR2)
else:
print ("2 - Got a false expression value")
print (vAR2)
print ("Good bye!")
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/************
/****************************************
File Name : CSLAB_ELSE_IF_STATEMENT
Purpose : A Program in Python for Else If Statement
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 16:49 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Else if Statement in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR = 100
if vAR == 200:
print ("1 - Got a true expression value")
print (vAR)
elif vAR == 150:
print ("2 - Got a true expression value")
print(vAR)
elif vAR == 100:
print ("3 - Got a true expression value")
print(vAR)
else:
print ("4 - Got a false expression value")
print (vAR)
print ("Good bye!")
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/************
/****************************************
File Name : CSLAB_BLOCK_STRUCTURE
Purpose : A Program in Python for Block Structure
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 9:28 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Block Structure in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_i = 25
if vAR_i < 0:
print ("vAR_i is negative")
else:
print ("vAR_i is Non Negative")
if vAR_i < 10:
print ("vAR_i has one digit")
else:
print ("vAR_i has multiple digits")
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/************
/****************************************
File Name : CSLAB_WHITESPACES
Purpose : A Program in Python for Whitespaces
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 9:57 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Whitespaces in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_X = 49
for vAR_X in range(0, 5):
print (vAR_X)
print (2*vAR_X)
print (vAR_X)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/************
/****************************************
File Name : CSLAB_REGULAR_EXPRESSIONS
Purpose : A Program in Python for Regular Expressions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 10:29 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Regular Expressions in Python
## Python Development Environment & Runtime - Python, Anaconda
import re
pattern = re.compile(r"[(on|off)]") # Slight optimization
print(re.search(pattern, "Mono: Playback 65 [75%] [-16.50dB] [on]"))
# Returns a Match object!
print(re.search(pattern, "Nada...:-("))
# Doesn't return anything.
# End Example
# Exercise: make a regular expression that will match an email
def test_email(your_pattern):
pattern = re.compile(your_pattern)
emails = ["john@example.com", "python-list@python.org", "wha.t.`1an?ug{}ly@email.com"]
for email in emails:
if not re.match(pattern, email):
print("You failed to match %s" % (email))
elif not your_pattern:
print("Forgot to enter a pattern!")
else:
print("Pass")
pattern = r"" # Your pattern here!
test_email(pattern)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/************
/****************************************
File Name : CSLAB_LISTS
Purpose : A Program in Python for Lists
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:08 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Lists in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_LIST1 = ['Physics', 'Chemistry', 1997, 2000]; vAR_LIST2 = [1, 2, 3, 4, 5 ]; vAR_LIST3 = ["a", "b", "c", "d"];
print (vAR_LIST1)
print (vAR_LIST2)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_TUPLE
Purpose : A Program in Python for Tuple
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:47 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Creation of Tuple in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_Tuple = ("Apple", "Banana", "Cherry")
for x in vAR_Tuple: print(x)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_SETS_V1
Purpose : A Program in Python for Sets
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:13 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Creation of Sets in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_A = {1, 2, 3}
vAR_A = set('qwerty')
print(vAR_A)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_FROZEN_SETS_V1
Purpose : A Program in Python for Frozen Sets
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:54 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Creation of Frozen Sets in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CITIES = set(["Frankfurt", "Basel","Freiburg"])
vAR_CITIES.add("Strasbourg")
vAR_CITIES
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_COLLECTION_TRANSITION_V1
Purpose : A Program in Python for Collection Trasition
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 13:22 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Creation of Collection Transition in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_characters = {'hero': 'Othello', 'villain': 'Iago', 'friend': 'Cassio'}
vAR_roles = CSLAB_characters.keys()
vAR_roles
vAR_names = CSLAB_characters.values()
print(vAR_roles)
print(vAR_names)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_LOOP_ELSE_V1
Purpose : A Program in Python for LOOP-ELSE
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 13:51 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Else Statement in Loops in Python
## Python Development Environment & Runtime - Python, Anaconda
for vAR_n in range(2, 10):
for vAR_x in range(2, vAR_n):
if vAR_n % vAR_x == 0:
print(vAR_n, 'equals', x, '*', vAR_n/vAR_x)
break
else:
# loop fell through without finding a factor
print(vAR_n, 'is a prime number')
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_ARGUMNETS_V1
Purpose : A Program in Python for Arguments
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 9:38 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Usage of Arguments in Python
## Python Development Environment & Runtime - Python, Anaconda
import sys
print ('Number of arguments:', len(sys.argv), 'arguments.')
print ('Argument List:', str(sys.argv))
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_MUTABLE_ARGUMNETS_V1
Purpose : A Program in Python for Mutable Arguments
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 10:07 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Usage of Mutable Arguments in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_MY_LIST = ["apple", "pear"]
print("My_list:", vAR_MY_LIST)
print("ID of x before modification:", id(vAR_MY_LIST))
# append "banana" to my_list
vAR_MY_LIST.append("banana")
print("my_list:", vAR_MY_LIST)
print("ID of x after modification:", id(vAR_MY_LIST))
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_ACCEPTING_VARIABLE_ARGUMENTS_V1
Purpose : A Program in Python for Accepting Variable Arguments
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 10:41 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Accepting Variable Arguments in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_myFun(vAR_arg1, vAR_arg2, vAR_arg3):
print("arg1:", vAR_arg1)
print("arg2:", vAR_arg2)
print("arg3:", vAR_arg3)
# Now we can use *args or **kwargs to
# pass arguments to this function :
vAR_args = ("Geeks", "for", "Geeks")
myFun(*vAR_args)
vAR_kwargs = {"vAR_arg1" : "Geeks", "vAR_arg2" : "for", "vAR_arg3" : "Geeks"} vAR_myFun(**vAR_kwargs)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_UNPACKING_ARGUMENT_LIST_V1
Purpose : A Program in Python for Unpacking Argument List
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:41 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Accepting Unpacking Arguments in Python
## Python Development Environment & Runtime - Python, Anaconda
# A sample function that takes 4 arguments
# and prints the,
def fun(a, b, c, d):
print(a, b, c, d)
# Driver Code
my_list = [1, 2, 3, 4]
# Unpacking list into four arguments
fun(*my_list)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_SCOPE_V1
Purpose : A Program in Python for Scope
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:13 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Usage of Scope in Python
## Python Development Environment & Runtime - Python, Anaconda
def deep_scope():
if True:
if True:
if True:
CSLAB_X = 5
return CSLAB_X
deep_scope()
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_ERROR_HANDLING_V1
Purpose : A Program in Python for Error Handling
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 13:00 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Error Handling in Python
## Python Development Environment & Runtime - Python, Anaconda
Total_Marks = int(input("Enter Total Marks Scored: "))
Num_of_Sections = int(input("Enter Num of Sections: "))
Average = 0
try:
Average = int(Total_Marks/Num_of_Sections)
except ZeroDivisionError:
print("Error:There has to be atleast 1 or more than 1 sections.")
print("Average marks scored per section is: ",Average)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_NAMESPACES_V1
Purpose : A Program in Python for Namespaces
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 13:44 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Usage of Namespaces in Python
## Python Development Environment & Runtime - Python, Anaconda
def outer_function():
vAR_a = 20
def inner_function():
vAR_a = 30
print('a =',vAR_a)
inner_function()
print('a =',vAR_a)
vAR_a = 10
outer_function()
print('a =',vAR_a)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_FILE_INPUT_OUTPUT_V1
Purpose : A Program in Python for File Input/Output Functions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 16:27 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Usage of Input/Output Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
colors = ['redn', 'yellown', 'bluen']
f = open('colors.txt', 'w')
f.writelines(colors)
f.close()
f = open('colors.txt')
f.readline()
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_HIGHER_ORDER_FUNCTIONS_V1
Purpose : A Program in Python for Higher order Functions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 09:34 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Higher Order Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
def second_element(t): return t[1]
zepp = [('Guitar', 'Jimmy'), ('Vocals', 'Robert'), ('Bass', 'John Paul'), ('Drums', 'John')]
sorted(zepp)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_ANONYMOUS_FUNCTIONS_V1
Purpose : A Program in Python for Anonymous Functions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 10:03 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Anonymous Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
def call_func(f, *args): return f(*args)
call_func(lambda x, y: x + y, 4, 5)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_NESTED_FUNCTIONS_V1
Purpose : A Program in Python for Nested Functions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 10:37 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Nested Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
def outer():
def inner(a): return a
return inner
f = outer()
f
f(10)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_CLOSURE_V1
Purpose : A Program in Python for Closures
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:12 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Closures in Python
## Python Development Environment & Runtime - Python, Anaconda
def outer2(a):
def inner2(b):
return a + b
return inner2
add1 = outer2(1)
add1
add1(4)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/*******
File Name : CSLAB_LEXICAL_SCOPING_V1
Purpose : A Program in Python for Lexical Scoping
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:47 hrs
Version : 1.0
/**************
## Program Description : A Program for Lexical Scoping in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_CSLAB_increment(vAR_CSLAB_n):
vAR_CSLAB_n += 1
print(vAR_CSLAB_n)
return vAR_CSLAB_n
vAR_CSLAB_n = 1
vAR_CSLAB_increment(vAR_CSLAB_n)
print(vAR_CSLAB_n)
/*******
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******
/****************************************
File Name : CSLAB_OPERATOR_V1
Purpose : A Program in Python for Operators
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:18 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Operators in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_x = 15
vAR_y = 4
## Arithmetic operators are used to perform mathematical operations like addition, subtraction, multiplication etc
# Output: x + y = 19
print('vAR_x + vAR_y =',vAR_x+vAR_y)
# Output: x - y = 11
print('vAR_x - vAR_y =',vAR_x-vAR_y)
# Output: x * y = 60
print('vAR_x * vAR_y =',vAR_x*vAR_y)
# Output: x / y = 3.75
print('vAR_x / vAR_y =',vAR_x/vAR_y)
# Output: x // y = 3
print('vAR_x // vAR_y =',vAR_x//vAR_y)
# Output: x ** y = 50625
print('vAR_x ** vAR_y =',vAR_x**vAR_y)
##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
## Comparison operators are used to compare values. It either returns True or False according to the condition.
vAR_x = 10
vAR_y = 12
# Output: x > y is False
print('vAR_x > vAR_y is',vAR_x>vAR_y)
# Output: x < y is True
print('vAR_x < vAR_y is',vAR_x < vAR_y)
# Output: x == y is False
print('vAR_x == vAR_y is',vAR_x==vAR_y)
# Output: x != y is True
print('vAR_x != vAR_y is',vAR_x!=vAR_y)
# Output: x >= y is False
print('vAR_x >= vAR_y is',vAR_x>=vAR_y)
# Output: x <= y is True
print('vAR_x <= vAR_y is',vAR_x<=vAR_y)
##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
## Logical operators are the and, or, not operators
vAR_x = True
vAR_y = False
# Output: x and y is False
print('vAR_x and vAR_y is',vAR_x and vAR_y)
# Output: x or y is True
print('vAR_x or vAR_y is',vAR_x or vAR_y)
# Output: not x is False
print('not vAR_x is',not vAR_x)
##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
## "is" and "is not" are the identity operators in Python.
## They are used to check if two values (or variables) are located on the same part of the memory.
## Two variables that are equal does not imply that they are identical.
vAR_x1 = 5
vAR_y1 = 5
vAR_x2 = 'Hello'
vAR_y2 = 'Hello'
vAR_x3 = [1,2,3]
vAR_y3 = [1,2,3]
# Output: False
print(vAR_x1 is not vAR_y1)
# Output: True
print(vAR_x2 is vAR_y2)
# Output: False
print(vAR_x3 is vAR_y3)
##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
## "in" and "not" in are the membership operators in Python.
## They are used to test whether a value or variable is found in a sequence (string, list, tuple, set and dictionary).
vAR_x = 'Hello world'
vAR_y = {1:'a',2:'b'}
# Output: True
print('H' in vAR_x)
# Output: True
print('hello' not in vAR_x)
# Output: True
print(1 in vAR_y)
# Output: False
print('a' in vAR_y)
##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_DECORATORS_V1
Purpose : A Program in Python for Decorators
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:44 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Decorators in Python
## Python Development Environment & Runtime - Python, Anaconda
def simple(*args):
for arg in args:
print (arg),
simple('a', 'b', 'c')
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_LIST_COMPREHENSIONS_V1
Purpose : A Program in Python for List Comprehensions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 13:00 hrs
Version : 1.0
/****************************************
## Program Description : A Program for List Comprehensions in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_Celsius = [39.2, 36.5, 37.3, 37.8]
vAR_Fahrenheit = [ ((float(9)/5)*x + 32) for x in vAR_Celsius ]
print (vAR_Fahrenheit)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_GENERATOR_EXPRESSIONS_V1
Purpose : A Program in Python for Generator Expressions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 13:47 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Generator Expressions in Python
## Python Development Environment & Runtime - Python, Anaconda
def my_gen():
for x in range(5):
yield x
vAR_gen_exp = (x ** 2 for x in range(10) if x % 2 == 0)
for x in gen_exp:
print(x)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/*******
File Name : CSLAB_GENERATOR_FUNCTIONS_V1
Purpose : A Program in Python for Generator Functions
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 14:23 hrs
Version : 1.0
/**************
## Program Description : A Program for Generator Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_CSLAB_fib(vAR_CSLAB_limit):
# Initialize first two Fibonacci Numbers
vAR_CSLAB_a, vAR_CSLAB_b = 0, 1
# One by one yield next Fibonacci Number
while vAR_CSLAB_a < vAR_CSLAB_limit:
yield vAR_CSLAB_a
vAR_CSLAB_a, vAR_CSLAB_b = vAR_CSLAB_b, vAR_CSLAB_a + vAR_CSLAB_b
# Create a generator object
vAR_CSLAB_x = vAR_CSLAB_fib(5)
# Iterating over the generator object using next
print(vAR_CSLAB_x. __next__() ); # In Python 3, __next__()
print(vAR_CSLAB_x. __next__() );
print(vAR_CSLAB_x. __next__() );
print(vAR_CSLAB_x. __next__() );
print(vAR_CSLAB_x. __next__() );
# Iterating over the generator object using for
# in loop.
print("\nUsing for in loop")
for i in vAR_CSLAB_fib(5):
print(i)
/*******
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******
/****************************************
File Name : CSLAB_ITERTOOLS_CHAIN_V1
Purpose : A Program in Python for Iter Tools - Chain()
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 15:58 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Iter Tools in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_l1 = ['a', 'b', 'c']
vAR_l2 = ['d', 'e', 'f']
vAR_l1.extend(vAR_l2)
vAR_l1
import itertools
vAR_l1 = ['a', 'b', 'c']
vAR_l2 = ['d', 'e', 'f']
vAR_chained = itertools.chain(vAR_l1, vAR_l2)
vAR_chained
[vAR_l for vAR_l in chained]
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_ITERTOOLS_IZIP_V1
Purpose : A Program in Python for Iter Tools - Izip()
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 16:29 hrs
Version : 1.0
/****************************************
## Program Description : A Program for Iter Tools - IZIP in Python
## Python Development Environment & Runtime - Python, Anaconda
name = ['Jimmy', 'Robert', 'John Paul', 'John']
instruments = ['Guitar', 'Vocals', 'Bass', 'Drums']
zepp = zip(name, instruments)
zepp
#zepp = itertools.islice(name, instruments)
#zepp
[musician for musician in zepp]
/**************************************************************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/****************************************
File Name : CSLAB_DEBUGGING_TOOL_PPRINT_V1
Purpose : A Program in Python for pprint
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 17:54 hrs
Version : 1.0
/****************************************
## Program Description : A Program for pprint in Python
## Python Development Environment & Runtime - Python, Anaconda
import pprint
deep = [{'letter': let, 'index': i, 'extended': let*i}
for i, let in enumerate(list('abcdefg'))]
deep
pprint.pprint(deep)
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/**************************
File Name : CSLAB_CLASSES_V1
Purpose : A Program in Python for Classes
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 9:43 hrs
Version : 1.0
/**************************
## Program Description : A Program for Classes in Python
## Python Development Environment & Runtime - Python, Anaconda
class A(object):
def whoami(self):
return self.__class__.__name__
vAR_A = A()
vAR_A
vAR_A.whoami()
/****************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/**************************************************************************************************
File Name : CSLAB_EMULATION_V1
Purpose : A Program in Python for Emulation
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 10:28 hrs
Version : 1.0
/**************************************************************************************************
## Program Description : A Program for Emulations in Python
## Python Development Environment & Runtime - Python, Anaconda
class Adder(object):
def __init__(self, extra):
self.extra = extra
def __call__(self, base):
return self.extra + base
add2 = Adder(2)
add2(3)
/**************************************************************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/*******************
File Name : CSLAB_CLASS_METHOD_V1
Purpose : A Program in Python for Class Method
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:04 hrs
Version : 1.0
/*******************
## Program Description : A Program for Class Method in Python
## Python Development Environment & Runtime - Python, Anaconda
class vAR_CSLAB_Person:
vAR_CSLAB_age = 25
def vAR_CSLAB_printAge(cls):
print('The age is:', cls.vAR_CSLAB_age)
# create printAge class method
vAR_CSLAB_Person.vAR_CSLAB_printAge = classmethod(vAR_CSLAB_Person.vAR_CSLAB_printAge)
vAR_CSLAB_Person.vAR_CSLAB_printAge()
/*******
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/**************
/*******************
File Name : CSLAB_STATIC_METHOD_V1
Purpose : A Program in Python for Static Method
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 11:38 hrs
Version : 1.0
/*******************
## Program Description : A Program for Static Method in Python
## Python Development Environment & Runtime - Python, Anaconda
class vAR_CSLAB_Mathematics:
def vAR_CSLAB_addNumbers(x, y):
return x + y
# create addNumbers static method
vAR_CSLAB_Mathematics.addNumbers = staticmethod(vAR_CSLAB_Mathematics.vAR_CSLAB_addNumbers)
print('The sum is:', vAR_CSLAB_Mathematics.vAR_CSLAB_addNumbers(5, 10))
/*******
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/**************
/*******************
File Name : CSLAB_INHERITANCE_V1
Purpose : A Program in Python for Inheritance
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:15 hrs
Version : 1.0
/**************************
## Program Description : A Program for Inheritance in Python
## Python Development Environment & Runtime - Python, Anaconda
class vAR_CSLAB_Person(object):
# Constructor
def __init__(self, name):
self.name = name
# To get name
def getName(self):
return self.name
# To check if this person is employee
def isEmployee(self):
return False
# Inherited or Sub class (Note Person in bracket)
class vAR_CSLAB_Employee(vAR_CSLAB_Person):
# Here we return true
def isEmployee(self):
return True
# Driver code
vAR_CSLAB_emp = vAR_CSLAB_Person("aaa1") # An Object of Person
print(vAR_CSLAB_emp.getName(), vAR_CSLAB_emp.isEmployee())
vAR_CSLAB_emp = vAR_CSLAB_Employee("bbb2") # An Object of Employee
print(vAR_CSLAB_emp.getName(), vAR_CSLAB_emp.isEmployee())
/*******
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******
/**************************************************************************************************
File Name : CSLAB_ENCAPSULATION_V1
Purpose : A Program in Python for Encapsulation
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:52 hrs
Version : 1.0
/**************************
## Program Description : A Program for Encapsulation in Python
## Python Development Environment & Runtime - Python, Anaconda
import traceback
import sys
class Course(object):
def __init__(self, capacity):
self.capacity = capacity
self.enrolled = 0
def enroll(self):
self.enrolled += 1
def __getattr__(self, name):
if name == 'open':
return self.capacity - self.enrolled
else:
raise AttributeError('%s not found', name)
def __setattr__(self, name, value):
if name == 'open':
self.enrolled = self.capacity - value
else:
object.__setattr__(self, name, value)
def __str__(self):
return 'Enrolled: t{0}nCapacity:t{1}nOpen:t{2}'.format(
self.enrolled, self.capacity, self.open)
course=Course(12)
course.enroll()
course.enroll()
/**************************************************************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/******************************************************************************************************************
File Name : CSLAB_N_DIMENSIONAL_ARRAY_V1 Surya
Purpose : A Program in Python for N Dimensionsional Arrays
Author : DeepSphere.AI, Inc.
Date and Time : 12/13/2018 12:34 hrs
Version : 1.0
/******************************************
## Program Description : A Program for N Dimensional Arrays in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
CSLAB_X = np.array([[1, 2, 3], [4, 5, 6]], np.int32)
type(CSLAB_X)
print(CSLAB_X.shape[0])
print(CSLAB_X.dtype)
/**************************************************************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/****************************************
/******************************************************************************************************************
File Name : CSLAB_READING_WRITING_DATA_V1
Purpose : A Program in Python for Reading & Writing Data
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:32 hrs
Version : 1.0
/******************************************
## Program Description : Program for Reading & Writing Data in Python
## Python Development Environment & Runtime - Python, Anaconda
CSLAB_f = open("E:Python ExamplesPredicted.txt", 'r')
CSLAB_f.read()
CSLAB_f.write("E:Python ExamplesPredicted1.txt")
print(_)
/*******************************************************************************************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/**************************************
/******************************************************************************************************************
File Name : CSLAB_READING_DATA_FROM_CSV_V1
Purpose : A Program in Python for Reading Data from a CSV File
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 9:51 hrs
Version : 1.0
/******************************************
## Program Description : Program for Reading Data from a CSV File in Python
## Python Development Environment & Runtime - Python, Anaconda
import csv
CSLAB_f = open("E:Pythontrain_1.csv", 'r')
CSLAB_f.read()
print(_)
/*******************************************************************************************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/**************************************
/************************************
File Name : CSLAB_NORMALIZING_DATA_V1
Purpose : A Program in Python for Normalizing Data
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 10:42 hrs
Version : 1.0
/******************************************
## Program Description : Program for Normalizing Data in Python
## Python Development Environment & Runtime - Python, Anaconda
# Normalize the data attributes for the Iris dataset.
from sklearn.datasets import load_iris
from sklearn import preprocessing
# load the iris dataset
iris = load_iris()
print(iris.data.shape)
# separate the data from the target attributes
CSLAB_X = iris.data
CSLAB_Y = iris.target
# normalize the data attributes
normalized_CSLAB_X = preprocessing.normalize(CSLAB_X)
/************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/************************
/*************************
File Name : CSLAB_FORMATTING_DATA_V1
Purpose : A Program in Python for Formatting Data
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 11:13 hrs
Version : 1.0
/******************************************
## Program Description : Program for Formatting Data in Python
## Python Development Environment & Runtime - Python, Anaconda
CSLAB_Q = 459
CSLAB_P = 0.098
print(CSLAB_Q, CSLAB_P, CSLAB_P * CSLAB_Q)
print(CSLAB_Q, CSLAB_P, CSLAB_P * CSLAB_Q, sep=",")
print(CSLAB_Q, CSLAB_P, CSLAB_P * CSLAB_Q, sep=" :-) ")
/************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/************************
/*************************
File Name : CSLAB_CONTROLLING_LINE_PROPERTIES_MATPLOTLIB_V1
Purpose : A Program in Python for Line Properties using Matplotlib Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 11:28 hrs
Version : 1.0
/******************************************
## Program Description : Program for Line Properties using Matplotlib Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as plt
plt.plot([1,2,3,4], color='r', linewidth = 2.0)
plt.ylabel('some numbers')
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_PLOTTING_SIMPLE_FUNCTION_V1
Purpose : A Program in Python for Plotting Simple Function
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 9:28 hrs
Version : 1.0
/******************************************
## Program Description : Program for Plotting Simple Function in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
x=arange(0,2,0.01)
y=2*sin(2*pi*(x-1/4))
ylabel('y-axis')
xlabel('x-axis')
title(r'$y=2sin 2pi(x-1/4)$')
plot(x,y)
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/*******
File Name : CSLAB_IMPORTING_MODULE_V1
Purpose : A Program in Python for Importing a Module
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:22 hrs
Version : 1.0
/****************************************
## Program Description : Program for Importing a Module in Python
## Python Development Environment & Runtime - Python, Anaconda
import collections
import pprint
d = collections.deque()
d.append('a')
d.appendleft('b')
pprint.pprint(globals())
/*******
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******
/*******
File Name : CSLAB_CREATING_MODULE_V1
Purpose : A Program in Python for Creating Module
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:22 hrs
Version : 1.0
/****************************************
## Program Description : Program for Creating a Module in Python
## Python Development Environment & Runtime - Python, Anaconda
def shorten(toolong): return toolong[:2]
from tools import shorten
print (shorten('abcdef'))
/*******
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_USING_DEFAULTS_V1
Purpose : A Program in Python for Using Defaults in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 13:08 hrs
Version : 1.0
/***********************************
## Program Description : Program for Using Defaults in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)
plot(X,C)
plot(X,S)
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : XGRAPHING_MATPLOTLIB_USING_DEFAULTS_CHANGING_COLORS_V1
Purpose : A Program in Python for For Using Defaults & changing Line Color & Width in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 13:42 hrs
Version : 1.0
/***********************************
## Program Description : Program for Using Defaults & changing Line Color & Width in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)
plot(X,C)
plot(X,S)
figure(figsize=(10,6), dpi=80)
plot(X, C, color="blue", linewidth=2.5, linestyle="-")
plot(X, S, color="red", linewidth=2.5, linestyle="-")
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_USING_DEFAULTS_SETTING_LIMITS_V1
Purpose : A Program in Python for Using & Setting Defaults in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 10:00 hrs
Version : 1.0
/****************************************
## Program Description : Program Using & Defaults in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
import numpy as vAR_np
vAR_CSLAB_X = vAR_np.linspace(-vAR_np.pi, vAR_np.pi, 256,endpoint=True)
vAR_CSLAB_C,vAR_CSLAB_S = vAR_np.cos(vAR_CSLAB_X), vAR_np.sin(vAR_CSLAB_X)
plot(vAR_CSLAB_X,vAR_CSLAB_C)
plot(vAR_CSLAB_X,vAR_CSLAB_S)
xlim(-4.0,4.0)
ylim(-1.0,1.0)
xlim(vAR_CSLAB_X.min()*1.1, vAR_CSLAB_X.max()*1.1)
ylim(vAR_CSLAB_C.min()*1.1, vAR_CSLAB_C.max()*1.1)
xmin ,xmax = vAR_CSLAB_X.min(), vAR_CSLAB_X.max()
dx = (xmax - xmin) * 0.2
xlim(xmin - dx, xmax + dx)
show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_USING_DEFAULTS_SETTING_TICKS_V1
Purpose : A Program in Python for Using Defaults & Setting Ticks in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 10:25 hrs
Version : 1.0
/***********************************
## Program Description : Program for Using Defaults & Setting Ticks in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)
plot(X,C)
plot(X,S)
xlim(-4.0,4.0)
ylim(-1.0,1.0)
xlim(X.min()*1.1, X.max()*1.1)
ylim(C.min()*1.1, C.max()*1.1)
xmin ,xmax = X.min(), X.max()
dx = (xmax - xmin) * 0.2
xlim(xmin - dx, xmax + dx)
xticks( [-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
yticks([-1, 0, +1])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_USING_DEFAULTS_SETTING_TICK_LABELS_V1
Purpose : A Program in Python for Using Defaults & Setting Tick Labels in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 11:02 hrs
Version : 1.0
/***********************************
## Program Description : Program for Using Defaults & Setting Tick Labels in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)
plot(X,C)
plot(X,S)
xlim(-4.0,4.0)
ylim(-1.0,1.0)
xlim(X.min()*1.1, X.max()*1.1)
ylim(C.min()*1.1, C.max()*1.1)
xmin ,xmax = X.min(), X.max()
dx = (xmax - xmin) * 0.2
xlim(xmin - dx, xmax + dx)
xticks( [-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
yticks([-1, 0, +1])
xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
[r'$-pi$', r'$-pi/2$', r'$0$', r'$+pi/2$', r'$+pi$'])
yticks([-1, 0, +1],
[r'$-1$', r'$0$', r'$+1$'])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_USING_DEFAULTS_MOVING_SPINES_V1
Purpose : A Program in Python for Using Defaults & Moving Spines in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 11:39 hrs
Version : 1.0
/***********************************
## Program Description : Program for Using Defaults & Moving Spines in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)
plot(X,C)
plot(X,S)
xlim(-4.0,4.0)
ylim(-1.0,1.0)
xlim(X.min()*1.1, X.max()*1.1)
ylim(C.min()*1.1, C.max()*1.1)
xmin ,xmax = X.min(), X.max()
dx = (xmax - xmin) * 0.2
xlim(xmin - dx, xmax + dx)
xticks( [-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
yticks([-1, 0, +1])
xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
[r'$-pi$', r'$-pi/2$', r'$0$', r'$+pi/2$', r'$+pi$'])
yticks([-1, 0, +1],
[r'$-1$', r'$0$', r'$+1$'])
ax = gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_USING_DEFAULTS_ADDING_LEGENDS_V1
Purpose : A Program in Python for Using Defaults & Adding Legends in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:05 hrs
Version : 1.0
/***********************************
## Program Description : Program for Using Defaults & Adding Legends in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)
plot(X,C)
plot(X,S)
xlim(-4.0,4.0)
ylim(-1.0,1.0)
xlim(X.min()*1.1, X.max()*1.1)
ylim(C.min()*1.1, C.max()*1.1)
xmin ,xmax = X.min(), X.max()
dx = (xmax - xmin) * 0.2
xlim(xmin - dx, xmax + dx)
xticks( [-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
yticks([-1, 0, +1])
xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
[r'$-pi$', r'$-pi/2$', r'$0$', r'$+pi/2$', r'$+pi$'])
yticks([-1, 0, +1],
[r'$-1$', r'$0$', r'$+1$'])
ax = gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
plot(X, C, color="blue", linewidth=2.5, linestyle="-", label="cosine")
plot(X, S, color="red", linewidth=2.5, linestyle="-", label="sine")
legend(loc='upper left')
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_USING_DEFAULTS_ANNOTATING_POINTS_LEGENDS_V1
Purpose : A Program in Python for Using Defaults & Annota in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:05 hrs
Version : 1.0
/***********************************
## Program Description : Program for Using Defaults & Annota in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)
plot(X,C)
plot(X,S)
xlim(-4.0,4.0)
ylim(-1.0,1.0)
xlim(X.min()*1.1, X.max()*1.1)
ylim(C.min()*1.1, C.max()*1.1)
xmin ,xmax = X.min(), X.max()
dx = (xmax - xmin) * 0.2
xlim(xmin - dx, xmax + dx)
xticks( [-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
yticks([-1, 0, +1])
xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
[r'$-pi$', r'$-pi/2$', r'$0$', r'$+pi/2$', r'$+pi$'])
yticks([-1, 0, +1],
[r'$-1$', r'$0$', r'$+1$'])
ax = gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
plot(X, C, color="blue", linewidth=2.5, linestyle="-", label="cosine")
plot(X, S, color="red", linewidth=2.5, linestyle="-", label="sine")
legend(loc='upper left')
t = 2*np.pi/3
plot([t,t],[0,np.cos(t)], color ='blue', linewidth=2.5, linestyle="--")
scatter([t,],[np.cos(t),], 50, color ='blue')
annotate(r'$sin(frac{2pi}{3})=frac{sqrt{3}}{2}$',
xy=(t, np.sin(t)), xycoords='data',
xytext=(+10, +30), textcoords='offset points', fontsize=16,
arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
plot([t,t],[0,np.sin(t)], color ='red', linewidth=2.5, linestyle="--")
scatter([t,],[np.sin(t),], 50, color ='red')
annotate(r'$cos(frac{2pi}{3})=-frac{1}{2}$',
xy=(t, np.cos(t)), xycoords='data',
xytext=(-90, -50), textcoords='offset points', fontsize=16,
arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_DATA_MANIPULATION_USING_V1
Purpose : A Program in Python for Data Manipulation using Pandas
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 13:42 hrs
Version : 1.0
/******************************************
## Program Description : Program for Data Manipulation using Pandas in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as pd
import numpy as np
import matplotlib as plt
CSLAB_DF = pd.read_csv("C:/Users/user/Desktop/CSLAB_CUSTOMER.csv")
CSLAB_DF.head(10)
CSLAB_DF.describe()
CSLAB_FIGURE = plt.pyplot.figure()
CSLAB_FIGURE = plt.pyplot.figure()
CSLAB_AX = CSLAB_FIGURE.add_subplot(111)
CSLAB_AX.hist(CSLAB_DF['Customer_ID'], bins = 10, range = (CSLAB_DF['Customer_ID'].min(),CSLAB_DF['Customer_ID'].max()))
plt.pyplot.title('Sales Analysis')
plt.pyplot.xlabel('Customer_ID')
plt.pyplot.ylabel('Amount')
plt.pyplot.show()
from pylab import *
CSLAB_AX = axes([0.1, 0.1, 0.8, 0.8])
CSLAB_labels = 'Nicholas', 'Nasser', 'Elizabeth', 'William', 'Johan'
CSLAB_fracs = [10, 20, 25, 25, 20]
CSLAB_explode=(0, 0.05, 0, 0)
pie(CSLAB_fracs, explode=CSLAB_explode, labels=labels, autopct='%1.1f%%', shadow=True, startangle=90)
title('Customer Churn % ', bbox={'facecolor':'0.8', 'pad':5})
show()
import matplotlib.pyplot as plt
plt.plot([1124,1958,857,2465,3042,3245,4544,4956,3896,4948,4565])
plt.ylabel('Amount($)')
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/*******
File Name : CSLAB_READING_DATA_FROM_HANA_TO_PYTHON
Purpose : A Program in Python for Reading Data from SAP HANA
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:00 hrs
Version : 1.0
/*******
## Program Description : Program for Reading Data from SAP HANA in Python
## Python Development Environment & Runtime - Python, Anaconda
#!/usr/bin/python
# -*- coding: utf-8 -*-
import pypyodbc as pyodbc
CSLAB_CONN = pyodbc.connect('DSN=DS;UID=DURGA;PWD=Delhi123')
CSLAB_CURSOR = CSLAB_CONN.cursor()
CSLAB_STMNT = 'SELECT * FROM DURGA.TICKETS'
CSLAB_CURSOR.execute(CSLAB_STMNT)
CSLAB_RESULT = CSLAB_CURSOR.fetchall()
print (CSLAB_RESULT)
/*******
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk.
All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******
/************************************
File Name : CSLAB_DIFFERENTIAL_EXPRESSION_ANALYSIS_V1
Purpose : A Program in Python for Differential Expression Analysis using statsmodels Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:31 hrs
Version : 1.0
/******************************************
## Program Description : Program for Differential Expression Analysis using statsmodels Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import gzip
import numpy as np
import urllib2
import gzip
from StringIO import StringIO
from statsmodels.stats.multitest import multipletests
from scipy.stats.distributions import norm
import matplotlib.pyplot as plt
url = urllib2.urlopen("ftp://ftp.ncbi.nlm.nih.gov/geo/datasets/GDS1nnn/GDS1615/soft/GDS1615_full.soft.gz")
zdata = url.read()
sio = StringIO(zdata)
fid = gzip.GzipFile(fileobj=sio)
SIF = {}
for line in fid:
if line.startswith("!dataset_table_begin"):
break
elif line.startswith("!subset_description"):
subset_description = line.split("=")[1].strip()
elif line.startswith("!subset_sample_id"):
subset_ids = line.split("=")[1].split(",")
subset_ids = [x.strip() for x in subset_ids]
for k in subset_ids:
SIF[k] = subset_description
# Next line is the column headers (sample id's)
SID = fid.next().split("t")
# The column indices that contain gene expression data
I = [i for i,x in enumerate(SID) if x.startswith("GSM")]
# Restrict the column headers to those that we keep
SID = [SID[i] for i in I]
# Get a list of sample labels
STP = [SIF[k] for k in SID]
# Read the gene expression data as a list of lists, also get the gene identifiers
GID,X = [],[]
for line in fid:
# This is what signals the end of the gene expression data
# section in the file
if line.startswith("!dataset_table_end"):
break
V = line.split("t")
# Extract the values that correspond to gene expression measures
# and convert the strings to numbers
x = [float(V[i]) for i in I]
X.append(np.asarray(x))
GID.append(V[0] + ";" + V[1])
# Convert the Python list of lists to a Numpy array.
X = np.asarray(X)
# The indices of samples for the ulcerative colitis group
UC = [i for i,x in enumerate(STP) if x == "ulcerative colitis"]
# The indices of samples for the Crohn's disease group
CD = [i for i,x in enumerate(STP) if x == "Crohn's disease"]
XL = np.log(X) / np.log(2)
MUC = XL[:,UC].mean(1) ## Mean of ulcerative colitis samples
MCD = XL[:,CD].mean(1) ## Mean of Crohn's disease samples
VUC = XL[:,UC].var(1) ## Variance of ulcerative colitis samples
VCD = XL[:,CD].var(1) ## Variance of Crohn's disease samples
nUC = len(UC) ## Number of ulcerative colitis samples
nCD = len(CD) ## Number of Crohn's disease samples
zscores = (MUC - MCD) / np.sqrt(VUC/nUC + VCD/nCD)
print zscores.mean()
print zscores.std()
print np.mean(np.abs(zscores) > 2)
print np.mean(zscores > 2)
print np.mean(zscores < -2)
pvalues = 2*norm.cdf(-np.abs(zscores))
pm = multipletests(pvalues, method="fdr_bh")
apv = pm[1]
ii = np.argsort(zscores)
plt.plot(zscores[ii], apv[ii], '-')
plt.xlabel("Z-score")
plt.ylabel("False Discovery Rate")
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_GENERALIZED_LINEAR_MODELS_V1
Purpose : A Program in Python for Generalized Linear Models using statsmodels Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 13:44 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Generalized Linear Models using statsmodels Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
import pandas as vAR_pd
import matplotlib.pyplot as vAR_plt
from statsmodels.discrete.discrete_model import Logit
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_Data_URL1 = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_70_DATA_URL1']
vAR_CSLAB_Data_URL1 = vAR_CSLAB_Data_URL1
vAR_CSLAB_data_tr = vAR_pd.read_csv(vAR_CSLAB_Data_URL1)
vAR_CSLAB_Data_URL2 = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_70_DATA_URL2']
vAR_CSLAB_Data_URL2 = vAR_CSLAB_Data_URL2
vAR_CSLAB_data_te = vAR_pd.read_csv(vAR_CSLAB_Data_URL2)
vAR_CSLAB_data = vAR_pd.concat((vAR_CSLAB_data_tr, vAR_CSLAB_data_te), axis=0)
vAR_CSLAB_endog = vAR_np.asarray([int(x.lower() == "yes") for x in vAR_CSLAB_data["type"]])
vAR_CSLAB_xnames = ["npreg", "glu", "bp", "skin", "bmi", "ped", "age"]
vAR_CSLAB_exog = vAR_np.asarray(vAR_CSLAB_data[vAR_CSLAB_xnames])
vAR_CSLAB_exog = vAR_np.concatenate((vAR_np.ones((vAR_CSLAB_exog.shape[0],1)), vAR_CSLAB_exog), axis=1)
vAR_CSLAB_x = [vAR_np.corrcoef(vAR_CSLAB_endog, vAR_CSLAB_x)[0,1] for vAR_CSLAB_x in vAR_CSLAB_exog[:,1:].T]
vAR_CSLAB_x = vAR_pd.Series(vAR_CSLAB_x, index=vAR_CSLAB_xnames)
print(vAR_CSLAB_x)
vAR_CSLAB_n = vAR_CSLAB_data.shape[0]
vAR_CSLAB_scores = vAR_np.zeros(vAR_CSLAB_n, dtype=vAR_np.float64)
for k in range(vAR_CSLAB_n):
vAR_CSLAB_ii = range(vAR_CSLAB_n)
#ii.pop(k)
vAR_CSLAB_mod = Logit(vAR_CSLAB_endog[vAR_CSLAB_ii], vAR_CSLAB_exog[vAR_CSLAB_ii,:])
vAR_CSLAB_rslt = vAR_CSLAB_mod.fit(disp=False)
vAR_CSLAB_scores[k] = vAR_CSLAB_rslt.predict(vAR_CSLAB_exog[k,:])
vAR_CSLAB_uscores = vAR_np.unique(vAR_CSLAB_scores)
vAR_CSLAB_n1 = vAR_np.sum(vAR_CSLAB_endog)
vAR_CSLAB_Sens = vAR_np.zeros_like(vAR_CSLAB_uscores)
vAR_CSLAB_Spec = vAR_np.zeros_like(vAR_CSLAB_uscores)
for j,u in enumerate(vAR_CSLAB_uscores):
vAR_CSLAB_Sens[j] = vAR_np.sum((vAR_CSLAB_scores >= u) * vAR_CSLAB_endog) / float(vAR_CSLAB_n1)
vAR_CSLAB_Spec[j] = vAR_np.sum((vAR_CSLAB_scores <= u) * (1-vAR_CSLAB_endog)) / float(vAR_CSLAB_n - vAR_CSLAB_n1)
vAR_plt.plot(1 - vAR_CSLAB_Spec, vAR_CSLAB_Sens, '-')
vAR_plt.plot([0,1], [0,1], '-', color='grey')
vAR_plt.xlabel("1 - Specificity", size=17)
vAR_plt.ylabel("Sensitivity", size=17)
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_DOT_PLOT_V1
Purpose : A Program in Python for Dot Plots using statsmodels Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:07 hrs
Version : 1.0
/******************************************
## Program Description : Program for Dot Plots using statsmodels Package in Python
## Python Development Environment & Runtime - Python, Anaconda
from statsmodels.graphics.dotplots import dot_plot
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
data_url = "https://umich.box.com/shared/static/uxpesc1pix3gedyecggp.csv"
data = pd.read_csv(data_url)
print data.head()
small = data.iloc[0:10,:]
fig = dot_plot(points=small["2000 GDP"])
plt.xlabel("GDP", size=16)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_FERTILITY_TRENDS_V1
Purpose : A Program in Python for Fertility Trends using statsmodels Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:54 hrs
Version : 1.0
/******************************************
## Program Description : Program for Dot Plots using statsmodels Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.sandbox.tools.tools_pca import pcasvd
url = "C:UsersuserDownloadssp.dyn.tfrt.in_Indicator_en_csv_v2.csv"
data = pd.read_csv(url, skiprows=2)
print data.head()
for tok in ["IFC", "developing", "income", "European", "HIPC", "classified",
"Least", "Other", "small states", "cone", "world", "baltics"]:
ii = [i for i in data.index if tok.lower() in data.loc[i, "Country Name"].lower()]
print "n".join(data.loc[ii, "Country Name"])
data = data.drop(ii)
years = range(1960, 2012)
years_str = ["%.0f" % y for y in years]
mat = data.loc[:, ["Country Name",] + years_str].dropna()
countries = mat["Country Name"].tolist()
mat = np.asarray(mat.loc[:, years_str])
plt.clf()
mn = mat.mean(0)
plt.plot(years, mn, '-', lw=4)
plt.grid(True)
plt.xlabel("Year", size=17)
plt.ylabel("Global mean fertility rate", size=17)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_LOGISTIC_REGRESSION_V1
Purpose : A Program in Python for Logistic Regression using statsmodels Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:54 hrs
Version : 1.0
/******************************************
## Program Description : Program for Logistic Regression using statsmodels Package in Python
## Python Development Environment & Runtime - Python, Anaconda
from statsmodels.discrete.discrete_model import Logit
import numpy as np
import matplotlib.pyplot as plt
CSLAB_n = 200
CSLAB_p = 10
exog = np.random.normal(size=(CSLAB_n,CSLAB_p))
lpred = exog[:,0] + 0.5*exog[:,1] - 0.5*exog[:,2]
prob = 1 / (1 + np.exp(-lpred))
endog = 1*(np.random.uniform(size=n) <= prob)
mod = Logit(endog, exog)
rslt1 = mod.fit()
print rslt1.summary()
rslt2 = mod.fit_regularized(alpha=10, disp=False)
print rslt2.summary()
alpha = np.linspace(0, 50, 50)
params = []
for a in alpha:
rslt2 = mod.fit_regularized(alpha=a, disp=False)
params.append(rslt2.params)
params = np.asarray(params)
plt.clf()
cmap = {0: "red", 1: "green", 2: "blue"}
for k in range(10):
color = 'grey'
if k in (0, 1, 2):
color = cmap[k]
plt.plot(alpha, params[:,k], color=color)
plt.xlabel("Penalty weight", size=17)
plt.ylabel("Coefficient", size=17)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_SPARSE_MODELS_V1
Purpose : A Program in Python Sparse Models
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:19 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Sparse Models in Python
## Python Development Environment & Runtime - Python, Anaconda
import warnings
import matplotlib.pyplot as vAR_plt
import numpy as vAR_np
from scipy import linalg
from sklearn.linear_model import (RandomizedLasso, lasso_stability_path,
LassoLarsCV)
from sklearn.feature_selection import f_regression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import auc, precision_recall_curve
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.utils.extmath import pinvh
#from sklearn.utils import ConvergenceWarning
def mutual_incoherence(X_relevant, X_irelevant):
vAR_CSLAB_projector = vAR_np.dot(vAR_np.dot(X_irelevant.T, X_relevant),
pinvh(vAR_np.dot(X_relevant.T, X_relevant)))
return vAR_np.max(vAR_np.abs(vAR_CSLAB_projector).sum(axis=1))
for conditioning in (1, 1e-4):
vAR_CSLAB_n_features = 501
vAR_CSLAB_n_relevant_features = 3
vAR_CSLAB_noise_level = .2
vAR_CSLAB_coef_min = .2
vAR_CSLAB_n_samples = 25
vAR_CSLAB_block_size = vAR_CSLAB_n_relevant_features
vAR_CSLAB_rng = vAR_np.random.RandomState(42)
vAR_CSLAB_coef = vAR_np.zeros(vAR_CSLAB_n_features)
vAR_CSLAB_coef[:vAR_CSLAB_n_relevant_features] = vAR_CSLAB_coef_min + vAR_CSLAB_rng.rand(vAR_CSLAB_n_relevant_features)
vAR_CSLAB_corr = vAR_np.zeros((vAR_CSLAB_n_features, vAR_CSLAB_n_features))
for i in range(0, vAR_CSLAB_n_features, vAR_CSLAB_block_size):
vAR_CSLAB_corr[i:i + vAR_CSLAB_block_size, i:i + vAR_CSLAB_block_size] = 1 - conditioning
vAR_CSLAB_corr.flat[::vAR_CSLAB_n_features + 1] = 1
vAR_CSLAB_corr = linalg.cholesky(vAR_CSLAB_corr)
vAR_CSLAB_X = vAR_CSLAB_rng.normal(size=(vAR_CSLAB_n_samples, vAR_CSLAB_n_features))
vAR_CSLAB_X = vAR_np.dot(vAR_CSLAB_X, vAR_CSLAB_corr)
# Keep [Wainwright2006] (26c) constant
vAR_CSLAB_X[:vAR_CSLAB_n_relevant_features] /= vAR_np.abs(
linalg.svdvals(vAR_CSLAB_X[:vAR_CSLAB_n_relevant_features])).max()
vAR_CSLAB_X = StandardScaler().fit_transform(vAR_CSLAB_X.copy())
# The output variable
vAR_CSLAB_y = vAR_np.dot(vAR_CSLAB_X, vAR_CSLAB_coef)
vAR_CSLAB_y /= vAR_np.std(vAR_CSLAB_y)
vAR_CSLAB_y += vAR_CSLAB_noise_level * vAR_CSLAB_rng.normal(size=vAR_CSLAB_n_samples)
vAR_CSLAB_mi = mutual_incoherence(vAR_CSLAB_X[:, :vAR_CSLAB_n_relevant_features],
vAR_CSLAB_X[:, vAR_CSLAB_n_relevant_features:])
vAR_CSLAB_alpha_grid, vAR_CSLAB_scores_path = lasso_stability_path(vAR_CSLAB_X, vAR_CSLAB_y, random_state=42,
eps=0.05)
vAR_plt.figure()
vAR_CSLAB_hg = vAR_plt.plot(vAR_CSLAB_alpha_grid[1:] ** .333, vAR_CSLAB_scores_path[vAR_CSLAB_coef != 0].T[1:], 'r')
vAR_CSLAB_hb = vAR_plt.plot(vAR_CSLAB_alpha_grid[1:] ** .333, vAR_CSLAB_scores_path[vAR_CSLAB_coef == 0].T[1:], 'k')
vAR_CSLAB_ymin, vAR_CSLAB_ymax = vAR_plt.ylim()
vAR_plt.xlabel(r'$(\alpha / \alpha_{max})^{1/3}$')
vAR_plt.ylabel('Stability score: proportion of times selected')
vAR_plt.title('Stability Scores Path - Mutual incoherence: %.1f' % vAR_CSLAB_mi)
vAR_plt.axis('tight')
vAR_plt.legend((vAR_CSLAB_hg[0], vAR_CSLAB_hb[0]), ('relevant features', 'irrelevant features'),
loc='best')
vAR_CSLAB_lars_cv = LassoLarsCV(cv=6).fit(vAR_CSLAB_X, vAR_CSLAB_y)
vAR_CSLAB_alphas = vAR_np.linspace(vAR_CSLAB_lars_cv.alphas_[0], .1 * vAR_CSLAB_lars_cv.alphas_[0], 6)
vAR_CSLAB_clf = RandomizedLasso(alpha=vAR_CSLAB_alphas, random_state=42).fit(vAR_CSLAB_X, vAR_CSLAB_y)
vAR_CSLAB_trees = ExtraTreesRegressor(100).fit(vAR_CSLAB_X, vAR_CSLAB_y)
# Compare with F-score
vAR_CSLAB_F, _ = f_regression(vAR_CSLAB_X, vAR_CSLAB_y)
vAR_plt.figure()
for vAR_CSLAB_name, vAR_CSLAB_score in [('F-test', vAR_CSLAB_F),
('Stability selection', vAR_CSLAB_clf.scores_),
('Lasso coefs', vAR_np.abs(vAR_CSLAB_lars_cv.coef_)),
('Trees', vAR_CSLAB_trees.feature_importances_),
]:
vAR_CSLAB_precision, vAR_CSLAB_recall, vAR_CSLAB_thresholds = precision_recall_curve(vAR_CSLAB_coef != 0,
vAR_CSLAB_score)
vAR_plt.semilogy(vAR_np.maximum(vAR_CSLAB_score / vAR_np.max(vAR_CSLAB_score), 1e-4),
label="%s. AUC: %.3f" % (vAR_CSLAB_name, auc(vAR_CSLAB_recall, vAR_CSLAB_precision)))
vAR_plt.plot(vAR_np.where(vAR_CSLAB_coef != 0)[0], [2e-4] * vAR_CSLAB_n_relevant_features, 'mo',
label="Ground truth")
vAR_plt.xlabel("Features")
vAR_plt.ylabel("Score")
vAR_plt.xlim(0, 100)
vAR_plt.legend(loc='best')
vAR_plt.title('Feature selection scores - Mutual incoherence: %.1f'
% vAR_CSLAB_mi)
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_CROSS_VALIDATION_MODELS_V1
Purpose : A Program in Python Cross Validation Models
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Cross Validation Models in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
import sklearn
from sklearn import datasets
from sklearn import svm
vAR_CSLAB_iris = datasets.load_iris()
print(vAR_CSLAB_iris.data.shape, vAR_CSLAB_iris.target.shape)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_SVM_MODEL_V1
Purpose : A Program in Python for SVM Model SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 19:01 hrs
Version : 1.0
/******************************************
## Program Description : Program for SVM in Python
## Python Development Environment & Runtime - Python, Anaconda
from sklearn import svm
X = [[0, 0], [1, 1]]
y = [0, 1]
clf = svm.SVC()
clf.fit(X, y)
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
max_iter=-1, probability=False, random_state=None, shrinking=True,
tol=0.001, verbose=False)
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SVM_MODEL_MULTICLASS_CLASSIFICATION_V1
Purpose : A Program in Python for SVM Multiclass Classification Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 19:23 hrs
Version : 1.0
/******************************************
## Program Description : Program for SVM Multiclass Classification in Python
## Python Development Environment & Runtime - Python, Anaconda
X = [[0], [1], [2], [3]]
Y = [0, 1, 2, 3]
clf = svm.SVC(decision_function_shape='ovo')
clf.fit(X, Y)
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovo', degree=3, gamma='auto', kernel='rbf',
max_iter=-1, probability=False, random_state=None, shrinking=True,
tol=0.001, verbose=False)
dec = clf.decision_function([[1]])
dec.shape[1] # 4 classes: 4*3/2 = 6
clf.decision_function_shape = "ovr"
dec = clf.decision_function([[1]])
dec.shape[1] # 4 classes
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_SVM_MODEL_SPECIES_DISTRIBUTION_V1
Purpose : A Program in Python for Species Distribution Model Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : for Species Distribution Model 19:58 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Species Distribution Model in Python
## Python Development Environment & Runtime - Python, Anaconda
from __future__ import print_function
from time import time
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
from sklearn.datasets.base import Bunch
from sklearn.datasets import fetch_species_distributions
from sklearn.datasets.species_distributions import construct_grids
from sklearn import svm, metrics
%matplotlib notebook
try:
from mpl_toolkits.basemap import Basemap
basemap = True
except ImportError:
basemap = False
print(__doc__)
def create_species_bunch(species_name, train, test, coverages, xgrid, ygrid):
vAR_CSLAB_bunch = Bunch(name=' '.join(species_name.split("_")[:2]))
vAR_CSLAB_species_name = species_name.encode('ascii')
vAR_CSLAB_points = dict(test=test, train=train)
for label, pts in vAR_CSLAB_points.items():
# choose points associated with the desired species
pts = pts[pts['species'] == vAR_CSLAB_species_name]
vAR_CSLAB_bunch['pts_%s' % label] = pts
# determine coverage values for each of the training & testing points
ix = vAR_np.searchsorted(xgrid, pts['dd long'])
iy = vAR_np.searchsorted(ygrid, pts['dd lat'])
vAR_CSLAB_bunch['cov_%s' % label] = coverages[:, -iy, ix].T
return vAR_CSLAB_bunch
def plot_species_distribution(species=("bradypus_variegatus_0",
"microryzomys_minutus_0")):
if len(species) > 2:
print("Note: when more than two species are provided,"
" only the first two will be used")
vAR_CSLAB_t0 = time()
# Load the compressed data
vAR_CSLAB_data = fetch_species_distributions()
# Set up the data grid
xgrid, ygrid = construct_grids(vAR_CSLAB_data)
# The grid in x,y coordinates
X, Y = vAR_np.meshgrid(xgrid, ygrid[::-1])
# create a bunch for each species
vAR_CSLAB_BV_bunch = create_species_bunch(species[0],
vAR_CSLAB_data.train, vAR_CSLAB_data.test,
vAR_CSLAB_data.coverages, xgrid, ygrid)
vAR_CSLAB_MM_bunch = create_species_bunch(species[1],
vAR_CSLAB_data.train, vAR_CSLAB_data.test,
vAR_CSLAB_data.coverages, xgrid, ygrid)
# background points (grid coordinates) for evaluation
vAR_np.random.seed(13)
background_points = vAR_np.c_[vAR_np.random.randint(low=0, high=vAR_CSLAB_data.Ny,
size=10000),
vAR_np.random.randint(low=0, high=vAR_CSLAB_data.Nx,
size=10000)].T
# We'll make use of the fact that coverages[6] has measurements at all
# land points. This will help us decide between land and water.
vAR_CSLAB_land_reference = vAR_CSLAB_data.coverages[6]
# Fit, predict, and plot for each species.
for i, species in enumerate([vAR_CSLAB_BV_bunch, vAR_CSLAB_MM_bunch]):
print("_" * 80)
print("Modeling distribution of species '%s'" % species.name)
# Standardize features
vAR_CSLAB_mean = species.cov_train.mean(axis=0)
vAR_CSLAB_std = species.cov_train.std(axis=0)
vAR_CSLAB_train_cover_std = (species.cov_train - vAR_CSLAB_mean) / vAR_CSLAB_std
# Fit OneClassSVM
print(" - fit OneClassSVM ... ", end='')
vAR_CSLAB_clf = svm.OneClassSVM(nu=0.1, kernel="rbf", gamma=0.5)
vAR_CSLAB_clf.fit(vAR_CSLAB_train_cover_std)
print("done.")
# Plot map of South America
vAR_plt.subplot(1, 2, i + 1)
if basemap:
print(" - plot coastlines using basemap")
vAR_CSLAB_m = Basemap(projection='cyl', llcrnrlat=Y.min(),
urcrnrlat=Y.max(), llcrnrlon=X.min(),
urcrnrlon=X.max(), resolution='c')
vAR_CSLAB_m.drawcoastlines()
vAR_CSLAB_m.drawcountries()
else:
print(" - plot coastlines from coverage")
vAR_plt.contour(X, Y, vAR_CSLAB_land_reference,
levels=[-9999], colors="k",
linestyles="solid")
vAR_plt.xticks([])
vAR_plt.yticks([])
print(" - predict species distribution")
# Predict species distribution using the training data
vAR_CSLAB_Z = vAR_np.ones((vAR_CSLAB_data.Ny, vAR_CSLAB_data.Nx), dtype=vAR_np.float64)
# We'll predict only for the land points.
idx = vAR_np.where(vAR_CSLAB_land_reference > -9999)
vAR_CSLAB_coverages_land = vAR_CSLAB_data.coverages[:, idx[0], idx[1]].T
vAR_CSLAB_pred = vAR_CSLAB_clf.decision_function((vAR_CSLAB_coverages_land - vAR_CSLAB_mean) / vAR_CSLAB_std)
vAR_CSLAB_Z *= vAR_CSLAB_pred.min()
vAR_CSLAB_Z[idx[0], idx[1]] = vAR_CSLAB_pred
vAR_CSLAB_levels = vAR_np.linspace(vAR_CSLAB_Z.min(), vAR_CSLAB_Z.max(), 25)
vAR_CSLAB_Z[vAR_CSLAB_land_reference == -9999] = -9999
# plot contours of the prediction
vAR_plt.contourf(X, Y, vAR_CSLAB_Z, levels=vAR_CSLAB_levels, cmap=vAR_plt.cm.Reds)
vAR_plt.colorbar(format='%.2f')
# scatter training/testing points
vAR_plt.scatter(species.pts_train['dd long'], species.pts_train['dd lat'],
s=2 ** 2, c='black',
marker='^', label='train')
vAR_plt.scatter(species.pts_test['dd long'], species.pts_test['dd lat'],
s=2 ** 2, c='black',
marker='x', label='test')
vAR_plt.legend()
vAR_plt.title(species.name)
vAR_plt.axis('equal')
# Compute AUC with regards to background points
vAR_CSLAB_pred_background = vAR_CSLAB_Z[background_points[0], background_points[1]]
vAR_CSLAB_pred_test = vAR_CSLAB_clf.decision_function((species.cov_test - vAR_CSLAB_mean)
/ vAR_CSLAB_std)
vAR_CSLAB_scores = vAR_np.r_[vAR_CSLAB_pred_test, vAR_CSLAB_pred_background]
vAR_CSLAB_y = vAR_np.r_[vAR_np.ones(vAR_CSLAB_pred_test.shape), vAR_np.zeros(vAR_CSLAB_pred_background.shape)]
#fpr, tpr, thresholds = metrics.roc_curve(y, vAR_CSLAB_scores)
#roc_auc = metrics.auc(fpr, tpr)
#plt.text(-35, -70, "AUC: %.3f" % roc_auc, ha="right")
#print("\n Area under the ROC curve : %f" % roc_auc)
print("\ntime elapsed: %.2fs" % (time() - vAR_CSLAB_t0))
plot_species_distribution()
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_LASSO_REGRESSION_MODEL_V1
Purpose : A Program in Python for Lasso Regression Model Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 20:11 hrs
Version : 1.0
/******************************************
## Program Description : Program for Lasso Regression Model in Python
## Python Development Environment & Runtime - Python, Anaconda
from sklearn import linear_model
clf = linear_model.Lasso(alpha = 0.1)
clf.fit([[0, 0], [1, 1]], [0, 1])
Lasso(alpha=0.1, copy_X=True, fit_intercept=True, max_iter=1000,
normalize=False, positive=False, precompute=False, random_state=None,
selection='cyclic', tol=0.0001, warm_start=False)
clf.predict([[1, 1]])
array([ 0.8]
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_ISOTONIC_REGRESSION_SCIKIT_LEARN_V1
Purpose : A Program in Python for Isotonic Regression Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:51 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Isotonic Regression in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
from matplotlib.collections import LineCollection
from sklearn.linear_model import LinearRegression
from sklearn.isotonic import IsotonicRegression
from sklearn.utils import check_random_state
vAR_CSLAB_n = 100
vAR_CSLAB_x = vAR_np.arange(vAR_CSLAB_n)
vAR_CSLAB_rs = check_random_state(0)
vAR_CSLAB_y = vAR_CSLAB_rs.randint(-50, 50, size=(vAR_CSLAB_n,)) + 50. * vAR_np.log(1 + vAR_np.arange(vAR_CSLAB_n))
# Fit IsotonicRegression and LinearRegression models
vAR_CSLAB_ir = IsotonicRegression()
vAR_CSLAB_y_ = vAR_CSLAB_ir.fit_transform(vAR_CSLAB_x, vAR_CSLAB_y)
vAR_CSLAB_lr = LinearRegression()
vAR_CSLAB_lr.fit(vAR_CSLAB_x[:, vAR_np.newaxis], vAR_CSLAB_y) # x needs to be 2d for LinearRegression
# plot result
vAR_CSLAB_segments = [[[i, vAR_CSLAB_y[i]], [i, vAR_CSLAB_y_[i]]] for i in range(vAR_CSLAB_n)]
vAR_CSLAB_lc = LineCollection(vAR_CSLAB_segments, zorder=0)
vAR_CSLAB_lc.set_array(vAR_np.ones(len(vAR_CSLAB_y)))
vAR_CSLAB_lc.set_linewidths(0.5 * vAR_np.ones(vAR_CSLAB_n))
vAR_CSLAB_fig = vAR_plt.figure()
vAR_plt.plot(vAR_CSLAB_x, vAR_CSLAB_y, 'r.', markersize=12)
vAR_plt.plot(vAR_CSLAB_x, vAR_CSLAB_y_, 'g.-', markersize=12)
vAR_plt.plot(vAR_CSLAB_x, vAR_CSLAB_lr.predict(vAR_CSLAB_x[:, vAR_np.newaxis]), 'b-')
vAR_plt.gca().add_collection(vAR_CSLAB_lc)
vAR_plt.legend(('Data', 'Isotonic Fit', 'Linear Fit'), loc='lower right')
vAR_plt.title('Isotonic regression')
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_NUERAL_NETWORKS_SCIKIT-LEARN_V1
Purpose : A Program in Python for Nueral Networks using SCIKIT-LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:52 hrs
Version : 1.0
/***********************************
## Program Description : Program for Nueral Networks in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
import matplotlib.pyplot as plt
from scipy.ndimage import convolve
from sklearn import linear_model, datasets, metrics
from sklearn.cross_validation import train_test_split
from sklearn.neural_network import BernoulliRBM
from sklearn.pipeline import Pipeline
def nudge_dataset(X, Y):
shift = lambda x, w: convolve(x.reshape((8, 8)), mode='constant',
weights=w).ravel()
X = np.concatenate([X] +
[np.apply_along_axis(shift, 1, X, vector)
for vector in direction_vectors])
Y = np.concatenate([Y for _ in range(5)], axis=0)
return X, Y
digits = datasets.load_digits()
X = np.asarray(digits.data, 'float32')
X, Y = nudge_dataset(X, digits.target)
X = (X - np.min(X, 0)) / (np.max(X, 0) + 0.0001) # 0-1 scaling
X_train, X_test, Y_train, Y_test = train_test_split(X, Y,
test_size=0.2,
random_state=0)
logistic = linear_model.LogisticRegression()
rbm = BernoulliRBM(random_state=0, verbose=True)
classifier = Pipeline(steps=[('rbm', rbm), ('logistic', logistic)])
rbm.learning_rate = 0.06
rbm.n_iter = 20
rbm.n_components = 100
logistic.C = 6000.0
classifier.fit(X_train, Y_train)
logistic_classifier = linear_model.LogisticRegression(C=100.0)
logistic_classifier.fit(X_train, Y_train)
print()
print("Logistic regression using RBM features:n%sn" % (
metrics.classification_report(
Y_test,
classifier.predict(X_test))))
print("Logistic regression using raw pixel features:n%sn" % (
metrics.classification_report(
Y_test,
logistic_classifier.predict(X_test))))
plt.figure(figsize=(4.2, 4))
for i, comp in enumerate(rbm.components_):
plt.subplot(10, 10, i + 1)
plt.imshow(comp.reshape((8, 8)), cmap=plt.cm.gray_r,
interpolation='nearest')
plt.xticks(())
plt.yticks(())
plt.suptitle('100 components extracted by RBM', fontsize=16)
plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_NON_LINEAR_SVM_SCIKIT-LEARN_V1
Purpose : A Program in Python for Non Linear SVM using SCIKIT-LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:22 hrs
Version : 1.0
/****************************************
## Program Description : Program for Non Linear SVM in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
from sklearn import svm
vAR_CSLAB_xx, vAR_CSLAB_yy = vAR_np.meshgrid(vAR_np.linspace(-3, 3, 500),
vAR_np.linspace(-3, 3, 500))
vAR_np.random.seed(0)
vAR_CSLAB_X = vAR_np.random.randn(300, 2)
vAR_CSLAB_Y = vAR_np.logical_xor(vAR_CSLAB_X[:, 0] > 0, vAR_CSLAB_X[:, 1] > 0)
# fit the model
vAR_CSLAB_clf = svm.NuSVC()
vAR_CSLAB_clf.fit(vAR_CSLAB_X, vAR_CSLAB_Y)
# plot the decision function for each datapoint on the grid
vAR_CSLAB_Z = vAR_CSLAB_clf.decision_function(vAR_np.c_[vAR_CSLAB_xx.ravel(), vAR_CSLAB_yy.ravel()])
vAR_CSLAB_Z = vAR_CSLAB_Z.reshape(vAR_CSLAB_xx.shape)
vAR_plt.imshow(vAR_CSLAB_Z, interpolation='nearest',
extent=(vAR_CSLAB_xx.min(), vAR_CSLAB_xx.max(), vAR_CSLAB_yy.min(), vAR_CSLAB_yy.max()), aspect='auto',
origin='lower', cmap=vAR_plt.cm.PuOr_r)
vAR_CSLAB_contours = vAR_plt.contour(vAR_CSLAB_xx, vAR_CSLAB_yy, vAR_CSLAB_Z, levels=[0], linewidths=2,
linetypes='--')
vAR_plt.scatter(vAR_CSLAB_X[:, 0], vAR_CSLAB_X[:, 1], s=30, c=vAR_CSLAB_Y, cmap=vAR_plt.cm.Paired)
vAR_plt.xticks(())
vAR_plt.yticks(())
vAR_plt.axis([-3, 3, -3, 3])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DECISION_TREES_SCIKIT-LEARN_V1
Purpose : A Program in Python for Decision Trees using SCIKIT-LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:04 hrs
Version : 1.0
/****************************************
## Program Description : Program for Decision Trees in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeRegressor
vAR_CSLAB_iris = load_iris()
# Create a random dataset
vAR_CSLAB_rng = vAR_np.random.RandomState(1)
vAR_CSLAB_X = vAR_np.sort(200 * vAR_CSLAB_rng.rand(100, 1) - 100, axis=0)
vAR_CSLAB_y = vAR_np.array([vAR_np.pi * vAR_np.sin(vAR_CSLAB_X).ravel(), vAR_np.pi * vAR_np.cos(vAR_CSLAB_X).ravel()]).T
#vAR_CSLAB_y[::5, :] += (0.5 - vAR_CSLAB_rng.rand(20, 2))
# Fit regression model
vAR_CSLAB_clf_1 = DecisionTreeRegressor(max_depth=2)
vAR_CSLAB_clf_2 = DecisionTreeRegressor(max_depth=5)
vAR_CSLAB_clf_3 = DecisionTreeRegressor(max_depth=8)
vAR_CSLAB_clf_1.fit(vAR_CSLAB_iris.data, vAR_CSLAB_iris.target)
vAR_CSLAB_clf_2.fit(vAR_CSLAB_iris.data, vAR_CSLAB_iris.target)
vAR_CSLAB_clf_3.fit(vAR_CSLAB_iris.data, vAR_CSLAB_iris.target)
# Predict
vAR_CSLAB_y_1 = vAR_CSLAB_clf_1.predict(vAR_CSLAB_iris.data[:50])
vAR_CSLAB_y_2 = vAR_CSLAB_clf_2.predict(vAR_CSLAB_iris.data[:50])
vAR_CSLAB_y_3 = vAR_CSLAB_clf_3.predict(vAR_CSLAB_iris.data[:50])
print(vAR_CSLAB_y_1)
print(vAR_CSLAB_y_2)
print(vAR_CSLAB_y_3)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_PLOTTING_VALIDATION_CURVE_SCIKIT-LEARN_V1
Purpose : A Program in Python for Plotting Validation Curve using SCIKIT-LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:42 hrs
Version : 1.0
/****************************************
## Program Description : Program for Plotting Validation Curve in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as vAR_plt
import numpy as vAR_np
from sklearn.datasets import load_digits
from sklearn.svm import SVC
from sklearn.model_selection import validation_curve
vAR_CSLAB_digits = load_digits()
vAR_CSLAB_X, vAR_CSLAB_y = vAR_CSLAB_digits.data, vAR_CSLAB_digits.target
vAR_CSLAB_param_range = vAR_np.logspace(-6, -1, 5)
vAR_CSLAB_train_scores, vAR_CSLAB_test_scores = validation_curve(
SVC(), vAR_CSLAB_X, vAR_CSLAB_y, param_name="gamma", param_range=vAR_CSLAB_param_range,
cv=10, scoring="accuracy", n_jobs=1)
vAR_CSLAB_train_scores_mean = vAR_np.mean(vAR_CSLAB_train_scores, axis=1)
vAR_CSLAB_train_scores_std = vAR_np.std(vAR_CSLAB_train_scores, axis=1)
vAR_CSLAB_test_scores_mean = vAR_np.mean(vAR_CSLAB_test_scores, axis=1)
vAR_CSLAB_test_scores_std = vAR_np.std(vAR_CSLAB_test_scores, axis=1)
vAR_plt.title("Validation Curve with SVM")
vAR_plt.xlabel("$\gamma$")
vAR_plt.ylabel("Score")
vAR_plt.ylim(0.0, 1.1)
vAR_plt.semilogx(vAR_CSLAB_param_range, vAR_CSLAB_train_scores_mean, label="Training score", color="r")
vAR_plt.fill_between(vAR_CSLAB_param_range, vAR_CSLAB_train_scores_mean - vAR_CSLAB_train_scores_std,
vAR_CSLAB_train_scores_mean + vAR_CSLAB_train_scores_std, alpha=0.2, color="r")
vAR_plt.semilogx(vAR_CSLAB_param_range, vAR_CSLAB_test_scores_mean, label="Cross-validation score",
color="g")
vAR_plt.fill_between(vAR_CSLAB_param_range, vAR_CSLAB_test_scores_mean - vAR_CSLAB_test_scores_std,
vAR_CSLAB_test_scores_mean + vAR_CSLAB_test_scores_std, alpha=0.2, color="g")
vAR_plt.legend(loc="best")
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_LOADING_DATAETS_SCIKIT-LEARN_V1
Purpose : A Program in Python for Loading a Dataset using SCIKIT-LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:03 hrs
Version : 1.0
/***********************************
## Program Description : Program for Loading a Dataset in Python
## Python Development Environment & Runtime - Python, Anaconda
from sklearn import datasets
iris = datasets.load_iris()
digits = datasets.load_digits()
print(digits.data)
digits.target
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_MEAN_SHIFT_CLUSTERING_ALGORITHM_SCIKIT_LEARN_V1
Purpose : A Program in Python for Mean Shift Clustering Algorithm Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:41 hrs
Version : 1.0
/******************************************
## Program Description : Program for Mean Shift Clustering Algorithm in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
from sklearn.cluster import MeanShift, estimate_bandwidth
from sklearn.datasets.samples_generator import make_blobs
# Generate sample data
centers = [[1, 1], [-1, -1], [1, -1]]
X, _ = make_blobs(n_samples=10000, centers=centers, cluster_std=0.6)
# Compute clustering with MeanShift
# The following bandwidth can be automatically detected using
bandwidth = estimate_bandwidth(X, quantile=0.2, n_samples=500)
ms = MeanShift(bandwidth=bandwidth, bin_seeding=True)
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
labels_unique = np.unique(labels)
n_clusters_ = len(labels_unique)
print("number of estimated clusters : %d" % n_clusters_)
# Plot result
import matplotlib.pyplot as plt
from itertools import cycle
plt.figure(1)
plt.clf()
colors = cycle('bgrcmykbgrcmykbgrcmykbgrcmyk')
for k, col in zip(range(n_clusters_), colors):
my_members = labels == k
cluster_center = cluster_centers[k]
plt.plot(X[my_members, 0], X[my_members, 1], col + '.')
plt.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col,
markeredgecolor='k', markersize=14)
plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()
/************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_AFFINITY_PROPOGATION_CLUSTERING_ALGORITHM_SCIKIT_LEARN_V1
Purpose : A Program in Python for Affinity Propogation Clustering Algorithm Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:41 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Affinity Propogation Clustering Algorithm in Python
## Python Development Environment & Runtime - Python, Anaconda
from sklearn.cluster import AffinityPropagation
from sklearn import metrics
from sklearn.datasets.samples_generator import make_blobs
vAR_CSLAB_centers = [[1, 1], [-1, -1], [1, -1]]
vAR_CSLAB_X, vAR_CSLAB_labels_true = make_blobs(n_samples=300, centers=vAR_CSLAB_centers, cluster_std=0.5,
random_state=0)
vAR_CSLAB_af = AffinityPropagation(preference=-50).fit(vAR_CSLAB_X)
vAR_CSLAB_cluster_centers_indices = vAR_CSLAB_af.cluster_centers_indices_
vAR_CSLAB_labels = vAR_CSLAB_af.labels_
vAR_CSLAB_n_clusters_ = len(vAR_CSLAB_cluster_centers_indices)
print('Estimated number of clusters: %d' % vAR_CSLAB_n_clusters_)
print("Homogeneity: %0.3f" % metrics.homogeneity_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("Completeness: %0.3f" % metrics.completeness_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("V-measure: %0.3f" % metrics.v_measure_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("Adjusted Rand Index: %0.3f"
% metrics.adjusted_rand_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("Adjusted Mutual Information: %0.3f"
% metrics.adjusted_mutual_info_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("Silhouette Coefficient: %0.3f"
% metrics.silhouette_score(vAR_CSLAB_X, vAR_CSLAB_labels, metric='sqeuclidean'))
# Plot result
import matplotlib.pyplot as vAR_plt
from itertools import cycle
vAR_plt.close('all')
vAR_plt.figure(1)
vAR_plt.clf()
vAR_colors = cycle('bgrcmykbgrcmykbgrcmykbgrcmyk')
for vAR_CSLAB_k, col in zip(range(vAR_CSLAB_n_clusters_), vAR_colors):
vAR_CSLAB_class_members = vAR_CSLAB_labels == vAR_CSLAB_k
vAR_CSLAB_cluster_center = vAR_CSLAB_X[vAR_CSLAB_cluster_centers_indices[vAR_CSLAB_k]]
vAR_plt.plot(vAR_CSLAB_X[vAR_CSLAB_class_members, 0], vAR_CSLAB_X[vAR_CSLAB_class_members, 1], col + '.')
vAR_plt.plot(vAR_CSLAB_cluster_center[0], vAR_CSLAB_cluster_center[1], 'o', markerfacecolor=col,
markeredgecolor='k', markersize=14)
for x in vAR_CSLAB_X[vAR_CSLAB_class_members]:
vAR_plt.plot([vAR_CSLAB_cluster_center[0], vAR_CSLAB_x[0]], [vAR_CSLAB_cluster_center[1], vAR_CSLAB_x[1]], col)
vAR_plt.title('Estimated number of clusters: %d' % vAR_CSLAB_n_clusters_)
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DBSCAN_CLUSTERING_ALGORITHM_SCIKIT_LEARN_V1
Purpose : A Program in Python for DBSCAN Clustering Algorithm Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:05 hrs
Version : 1.0
/***********************************************
## Program Description : Program for DBSCAN Clustering Algorithm in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
from sklearn.cluster import DBSCAN
from sklearn import metrics
from sklearn.datasets.samples_generator import make_blobs
from sklearn.preprocessing import StandardScaler
# Generate sample data
vAR_CSLAB_centers = [[1, 1], [-1, -1], [1, -1]]
vAR_CSLAB_X, vAR_CSLAB_labels_true = make_blobs(n_samples=750, centers=vAR_CSLAB_centers, cluster_std=0.4,
random_state=0)
vAR_CSLAB_X = StandardScaler().fit_transform(vAR_CSLAB_X)
# Compute DBSCAN
vAR_CSLAB_db = DBSCAN(eps=0.3, min_samples=10).fit(vAR_CSLAB_X)
vAR_CSLAB_core_samples_mask = vAR_np.zeros_like(vAR_CSLAB_db.labels_, dtype=bool)
vAR_CSLAB_core_samples_mask[vAR_CSLAB_db.core_sample_indices_] = True
vAR_CSLAB_labels = vAR_CSLAB_db.labels_
# Number of clusters in labels, ignoring noise if present.
vAR_CSLAB_n_clusters_ = len(set(vAR_CSLAB_labels)) - (1 if -1 in vAR_CSLAB_labels else 0)
print('Estimated number of clusters: %d' % vAR_CSLAB_n_clusters_)
print("Homogeneity: %0.3f" % metrics.homogeneity_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("Completeness: %0.3f" % metrics.completeness_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("V-measure: %0.3f" % metrics.v_measure_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("Adjusted Rand Index: %0.3f"
% metrics.adjusted_rand_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("Adjusted Mutual Information: %0.3f"
% metrics.adjusted_mutual_info_score(vAR_CSLAB_labels_true, vAR_CSLAB_labels))
print("Silhouette Coefficient: %0.3f"
% metrics.silhouette_score(vAR_CSLAB_X, vAR_CSLAB_labels))
# Plot result
import matplotlib.pyplot as vAR_plt
# Black removed and is used for noise instead.
vAR_CSLAB_unique_labels = set(vAR_CSLAB_labels)
vAR_CSLAB_colors = vAR_plt.cm.Spectral(vAR_np.linspace(0, 1, len(vAR_CSLAB_unique_labels)))
for k, col in zip(vAR_CSLAB_unique_labels, vAR_CSLAB_colors):
if k == -1:
vAR_CSLAB_col = 'k'
vAR_CSLAB_class_member_mask = (vAR_CSLAB_labels == vAR_CSLAB_k)
vAR_CSLAB_xy = vAR_CSLAB_X[vAR_CSLAB_class_member_mask & vAR_CSLAB_core_samples_mask]
vAR_plt.plot(vAR_CSLAB_xy[:, 0], vAR_CSLAB_xy[:, 1], 'o', markerfacecolor=col,
markeredgecolor='k', markersize=14)
vAR_CSLAB_xy = vAR_CSLAB_X[vAR_CSLAB_class_member_mask & ~vAR_CSLAB_core_samples_mask]
vAR_plt.plot(vAR_CSLAB_xy[:, 0], vAR_CSLAB_xy[:, 1], 'o', markerfacecolor=col,
markeredgecolor='k', markersize=6)
vAR_plt.title('Estimated number of clusters: %d' % vAR_CSLAB_n_clusters_)
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_KMEANS_CLUSTERING_ALGORITHM_SCIKIT_LEARN_V1
Purpose : A Program in Python for KMEANS Clustering Algorithm Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:41 hrs
Version : 1.0
/***********************************************
## Program Description : Program for KMEANS Clustering Algorithm in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn.cluster import KMeans
from sklearn import datasets
vAR_np.random.seed(5)
vAR_CSLAB_centers = [[1, 1], [-1, -1], [1, -1]]
vAR_CSLAB_iris = datasets.load_iris()
vAR_CSLAB_X = vAR_CSLAB_iris.data
vAR_CSLAB_y = vAR_CSLAB_iris.target
vAR_CSLAB_estimators = {'k_means_iris_3': KMeans(n_clusters=3),
'k_means_iris_8': KMeans(n_clusters=8),
'k_means_iris_bad_init': KMeans(n_clusters=3, n_init=1,
init='random')}
vAR_CSLAB_fignum = 1
for name, est in vAR_CSLAB_estimators.items():
vAR_CSLAB_fig = vAR_plt.figure(vAR_CSLAB_fignum, figsize=(4, 3))
vAR_plt.clf()
vAR_CSLAB_ax = Axes3D(vAR_CSLAB_fig, rect=[0, 0, .95, 1], elev=48, azim=134)
vAR_plt.cla()
est.fit(vAR_CSLAB_X)
vAR_CSLAB_labels = est.labels_
vAR_CSLAB_ax.scatter(vAR_CSLAB_X[:, 3], vAR_CSLAB_X[:, 0], vAR_CSLAB_X[:, 2], c=vAR_CSLAB_labels.astype(vAR_np.float))
vAR_CSLAB_ax.w_xaxis.set_ticklabels([])
vAR_CSLAB_ax.w_yaxis.set_ticklabels([])
vAR_CSLAB_ax.w_zaxis.set_ticklabels([])
vAR_CSLAB_ax.set_xlabel('Petal width')
vAR_CSLAB_ax.set_ylabel('Sepal length')
vAR_CSLAB_ax.set_zlabel('Petal length')
vAR_CSLAB_fignum = vAR_CSLAB_fignum + 1
# Plot the ground truth
vAR_CSLAB_fig = vAR_plt.figure(vAR_CSLAB_fignum, figsize=(4, 3))
vAR_plt.clf()
vAR_CSLAB_ax = Axes3D(vAR_CSLAB_fig, rect=[0, 0, .95, 1], elev=48, azim=134)
vAR_plt.cla()
for name, label in [('Setosa', 0),
('Versicolour', 1),
('Virginica', 2)]:
vAR_CSLAB_ax.text3D(vAR_CSLAB_X[vAR_CSLAB_y == label, 3].mean(),
vAR_CSLAB_X[vAR_CSLAB_y == label, 0].mean() + 1.5,
vAR_CSLAB_X[vAR_CSLAB_y == label, 2].mean(), name,
horizontalalignment='center',
bbox=dict(alpha=.5, edgecolor='w', facecolor='w'))
# Reorder the labels to have colors matching the cluster results
vAR_CSLAB_y = vAR_np.choose(vAR_CSLAB_y, [1, 2, 0]).astype(vAR_np.float)
vAR_CSLAB_ax.scatter(vAR_CSLAB_X[:, 3], vAR_CSLAB_X[:, 0], vAR_CSLAB_X[:, 2], c=vAR_CSLAB_y)
vAR_CSLAB_ax.w_xaxis.set_ticklabels([])
vAR_CSLAB_ax.w_yaxis.set_ticklabels([])
vAR_CSLAB_ax.w_zaxis.set_ticklabels([])
vAR_CSLAB_ax.set_xlabel('Petal width')
vAR_CSLAB_ax.set_ylabel('Sepal length')
vAR_CSLAB_ax.set_zlabel('Petal length')
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_SPECTRAL_BI-CLUSTERING_ALGORITHM_SCIKIT_LEARN_V1
Purpose : A Program in Python for Spectral Bi-Clustering Algorithm Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:38 hrs
Version : 1.0
/******************************************
## Program Description : Program for Spectral Bi-Clustering Algorithm in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import make_checkerboard
from sklearn.datasets import samples_generator as sg
from sklearn.cluster.bicluster import SpectralBiclustering
from sklearn.metrics import consensus_score
n_clusters = (4, 3)
data, rows, columns = make_checkerboard(
shape=(300, 300), n_clusters=n_clusters, noise=10,
shuffle=False, random_state=0)
plt.matshow(data, cmap=plt.cm.Blues)
plt.title("Original dataset")
data, row_idx, col_idx = sg._shuffle(data, random_state=0)
plt.matshow(data, cmap=plt.cm.Blues)
plt.title("Shuffled dataset")
model = SpectralBiclustering(n_clusters=n_clusters, method='log',
random_state=0)
model.fit(data)
score = consensus_score(model.biclusters_,
(rows[:, row_idx], columns[:, col_idx]))
print("consensus score: {:.1f}".format(score))
fit_data = data[np.argsort(model.row_labels_)]
fit_data = fit_data[:, np.argsort(model.column_labels_)]
plt.matshow(fit_data, cmap=plt.cm.Blues)
plt.title("After biclustering; rearranged to show biclusters")
plt.matshow(np.outer(np.sort(model.row_labels_) + 1,
np.sort(model.column_labels_) + 1),
cmap=plt.cm.Blues)
plt.title("Checkerboard structure of rearranged data")
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SPECTRAL_CO-CLUSTERING_ALGORITHM_SCIKIT_LEARN_V1
Purpose : A Program in Python for Spectral Co-Clustering Algorithm Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:13 hrs
Version : 1.0
/******************************************
## Program Description : Program for Spectral Co-Clustering Algorithm in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import make_biclusters
from sklearn.datasets import samples_generator as sg
from sklearn.cluster.bicluster import SpectralCoclustering
from sklearn.metrics import consensus_score
data, rows, columns = make_biclusters(
shape=(300, 300), n_clusters=5, noise=5,
shuffle=False, random_state=0)
plt.matshow(data, cmap=plt.cm.Blues)
plt.title("Original dataset")
data, row_idx, col_idx = sg._shuffle(data, random_state=0)
plt.matshow(data, cmap=plt.cm.Blues)
plt.title("Shuffled dataset")
model = SpectralCoclustering(n_clusters=5, random_state=0)
model.fit(data)
score = consensus_score(model.biclusters_,
(rows[:, row_idx], columns[:, col_idx]))
print("consensus score: {:.3f}".format(score))
fit_data = data[np.argsort(model.row_labels_)]
fit_data = fit_data[:, np.argsort(model.column_labels_)]
plt.matshow(fit_data, cmap=plt.cm.Blues)
plt.title("After biclustering; rearranged to show biclusters")
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_RIDGE_REGRESSION_SCIKIT_LEARN_V1
Purpose : A Program in Python for Ridge Regression Algorithm Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:49 hrs
Version : 1.0
/******************************************
## Program Description : Program for Ridge Regression Algorithm in Python
## Python Development Environment & Runtime - Python, Anaconda
from sklearn import linear_model
clf = linear_model.Ridge (alpha = .5)
clf.fit ([[0, 0], [0, 0], [1, 1]], [0, .1, 1])
Ridge(alpha=0.5, copy_X=True, fit_intercept=True, max_iter=None,
normalize=False, random_state=None, solver='auto', tol=0.001)
clf.coef_
array([ 0.34545455, 0.34545455])
clf.intercept_
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_ARRAYS_NUMPY_V1
Purpose : A Program in Python for Arrays using Numpy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 11:12 hrs
Version : 1.0
/******************************************
## Program Description : Program for Arrays using Numpy in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
CSLAB_X = np.array([42,47,11], int)
CSLAB_X
CSLAB_X = np.array( ((11,12,13), (21,22,23), (31,32,33)) )
print CSLAB_X
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_ARRAYS_RESHAPING_NUMPY_V1
Purpose : A Program in Python for Reshaping Arrays using Numpy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 11:47 hrs
Version : 1.0
/******************************************
## Program Description : Program for Reshaping Arrays using Numpy in Python
## Python Development Environment & Runtime - Python, Anaconda
CSLAB_X = np.array([[[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 6, 7]],
[[ 8, 9],
[10, 11],
[12, 13],
[14, 15]],
[[16, 17],
[18, 19],
[20, 21],
[22, 23]]])
CSLAB_X.flatten()
CSLAB_X
CSLAB_X.ravel()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_ARRAYS_CONCATENATING_NUMPY_V1
Purpose : A Program in Python for Concatenating Arrays using Numpy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:14 hrs
Version : 1.0
/******************************************
## Program Description : Program for Concatenating Arrays using Numpy in Python
## Python Development Environment & Runtime - Python, Anaconda
CSLAB_X = np.array([11,22])
CSLAB_Y = np.array([18,7,6])
CSLAB_Z = np.array([1,3,5])
np.concatenate((CSLAB_X,CSLAB_Y,CSLAB_Z))
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_ARRAYS_ADDING_NEW_DIMENSIONS_NUMPY_V1
Purpose : A Program in Python for Adding New Dimensions to Arrays using Numpy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:41 hrs
Version : 1.0
/******************************************
## Program Description : Program for Adding New Dimensions to Arrays using Numpy in Python
## Python Development Environment & Runtime - Python, Anaconda
CSLAB_X = np.array([2,5,18,14,4])
CSLAB_X
CSLAB_Y = CSLAB_X[:, np.newaxis]
CSLAB_Y
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_ARRAYS_INITIALIZING_WITH_ZEROS_ONES_NUMPY_V1
Purpose : A Program in Python for Initializing With Zero's & One's to Arrays using Numpy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:41 hrs
Version : 1.0
/******************************************
## Program Description : Program for Initializing With Zero's & One's to Arrays using Numpy in Python
## Python Development Environment & Runtime - Python, Anaconda
np.ones((2,3))
np.ones((3,4),dtype=int)
np.zeros((2,4))
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_MGRID_SCIPY_V1
Purpose : A Program in Python for Mgrid Function in scipy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 13:17 hrs
Version : 1.0
/******************************************
## Program Description : Program for Mgrid Function in scipy in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import *
mgrid[0:5,0:5]
mgrid[0:5:4j,0:5:4j]
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_POLYNOMIAL_SCIPY_V1
Purpose : A Program in Python for Polynomials in scipy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 13:17 hrs
Version : 1.0
/******************************************
## Program Description : Program for Polynomials in scipy in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import *
CSLAB_P = poly1d([3,4,5])
print CSLAB_P
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_VECTORIZING_FUNCTIONS_SCIPY_V1
Purpose : A Program in Python for Vectorizing Functions in scipy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:00 hrs
Version : 1.0
/******************************************
## Program Description : Program for Vectorizing Functions in scipy in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import *
def addsubtract(CSLAB_A,CSLAB_B):
if CSLAB_A > CSLAB_B:
return CSLAB_A - CSLAB_B
else:
return CSLAB_A + CSLAB_B
vec_addsubtract = vectorize(addsubtract)
vec_addsubtract([0,3,6,9],[1,3,5,7])
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_SELECT_FUNCTION_SCIPY_V1
Purpose : A Program in Python for Select Functions in scipy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:27 hrs
Version : 1.0
/******************************************
## Program Description : Program for Select Functions in scipy in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import *
CSLAB_X = r_[-2:3]
CSLAB_X
select([(CSLAB_X) > 3, (CSLAB_X) >= 0],[0,(CSLAB_X)+2])
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SCIENTIFIC_ANALYSIS_GENERAL_INTEGRATION_SCIPY_V1
Purpose : A Program in Python for General Integration in scipy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:45 hrs
Version : 1.0
/******************************************
## Program Description : Program for General Integration in scipy in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import *
result = integrate.quad(lambda x: special.jv(2.5,x), 0, 4.5)
print result
CSLAB_I = sqrt(2/pi)*(18.0/27*sqrt(2)*cos(4.5)-4.0/27*sqrt(2)*sin(4.5) + sqrt(2*pi)*special.fresnl(3/sqrt(pi))[0])
print CSLAB_I
print abs(result[0]-CSLAB_I)
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_TIME_SERIES_ANALYSIS_PANDAS_V1
Purpose : A Program in Python for Time Series Analysis Using Pandas
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:47 hrs
Version : 1.0
/******************************************
## Program Description : Program for Time Series Analysis Using Pandas in Python
## Python Development Environment & Runtime - Python, Anaconda
% matplotlib inline
import matplotlib.pyplot as plt
import datetime
import pandas as pd
yhoo = DataReader("yhoo", "yahoo", datetime.datetime(2007, 1, 1),
datetime.datetime(2012,1,1))
top = plt.subplot2grid((4,4), (0, 0), rowspan=3, colspan=4)
top.plot(yhoo.index, yhoo["Close"])
plt.title('Yahoo Price from 2007 - 2012')
bottom = plt.subplot2grid((4,4), (3,0), rowspan=1, colspan=4)
bottom.bar(yhoo.index, yhoo['Volume'])
plt.title('Yahoo Trading Volume')
plt.gcf().set_size_inches(15,8)
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_EXPORTING_DATA_USING_PANDAS_V1
Purpose : A Program in Python for EXporting Data Using Pandas
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:37 hrs
Version : 1.0
/******************************************
## Program Description : Program for EXporting Data Using Pandas in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as pd
s = pd.Series([1,3,5,np.nan,6,8])
pd.DataFrame(s).to_excel('E:/Python/s.xlsx', 's')
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_IMPORTING_DATA_USING_PANDAS_V1
Purpose : A Program in Python for Importing Data Using Pandas
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:15 hrs
Version : 1.0
/******************************************
## Program Description : Program for Importing Data Using Pandas in Python
## Python Development Environment & Runtime - Python, Anaconda
from pandas import read_csv
from urllib import urlopen
page = urlopen("http://econpy.pythonanywhere.com/ex/NFL_1979.csv")
df = read_csv(page)
print df
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/*******************
File Name : CSLAB_DATA_ANALYSIS_PANDAS_V1
Purpose : A Program in Python for Data Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 10:52 hrs
Version : 1.0
/*******************
## Program Description : Program for Data Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import matplotlib as vAR_plt
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_Customer = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_106_CUSTOMER']
vAR_CSLAB_Customer = vAR_pd.read_excel(vAR_CSLAB_Customer)
vAR_CSLAB_Customer
vAR_CSLAB_FIGURE = vAR_plt.pyplot.figure()
vAR_CSLAB_FIGURE = vAR_plt.pyplot.figure()
vAR_CSLAB_AX = vAR_CSLAB_FIGURE.add_subplot(111)
vAR_CSLAB_AX.hist(vAR_CSLAB_Customer['Customer_ID'], bins = 10, range = (vAR_CSLAB_Customer['Customer_ID'].min(),vAR_CSLAB_Customer['Customer_ID'].max()))
/*******************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************
/************************************
File Name : CSLAB_EMPTY_GRAPH_NETWORKX_V1
Purpose : A Program in Python for Drawing Empty Graph With NetworkX Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:05 hrs
Version : 1.0
/***********************************
## Program Description : Program for Drawing Empty Graph With NetworkX Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import networkx as nx
CSLAB_G=nx.Graph()
print(CSLAB_G.nodes())
print(CSLAB_G.edges())
print(type(CSLAB_G.nodes()))
print(type(CSLAB_G.edges()))
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPH_ADDING_NODES_NETWORKX_V1
Purpose : A Program in Python for Adding Nodes to a Graph With NetworkX Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:29 hrs
Version : 1.0
/***********************************
## Program Description : Program for Adding Nodes to a Graph With NetworkX Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import networkx as nx
CSLAB_G=nx.Graph()
# adding just one node:
CSLAB_G.add_node("a")
# a list of nodes:
CSLAB_G.add_nodes_from(["b","c"])
print("Nodes of graph: ")
print(CSLAB_G.nodes())
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_GRAPH_ADDING_EDGES_NETWORKX_V1
Purpose : A Program in Python for Adding Edges to a Graph With NetworkX Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:54 hrs
Version : 1.0
/****************************************
## Program Description : Program for Adding Edges to a Graph With NetworkX Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import networkx as vAR_nx
vAR_CSLAB_G=vAR_nx.Graph()
vAR_CSLAB_G.add_node("a")
vAR_CSLAB_G.add_nodes_from(["b","c"])
vAR_CSLAB_G.add_edge(1,2)
vAR_edge = ("d", "e")
vAR_CSLAB_G.add_edge(*vAR_edge)
vAR_edge = ("a", "b")
vAR_CSLAB_G.add_edge(*vAR_edge)
print("Nodes of graph: ")
print(vAR_CSLAB_G.nodes())
print("Edges of graph: ")
print(vAR_CSLAB_G.edges())
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_GRAPH_DISPLAY_NETWORKX_V1
Purpose : A Program in Python for the Graph With Nodes & Edges using NetworkX Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 13:22 hrs
Version : 1.0
/******************************************
## Program Description : Program for the Graph With Nodes & Edges using NetworkX Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import networkx as nx
CSLAB_G=nx.Graph()
CSLAB_G.add_node("a")
CSLAB_G.add_nodes_from(["b","c"])
CSLAB_G.add_edge(1,2)
edge = ("d", "e")
CSLAB_G.add_edge(*edge)
edge = ("a", "b")
CSLAB_G.add_edge(*edge)
print("Nodes of graph: ")
print(CSLAB_G.nodes())
print("Edges of graph: ")
print(CSLAB_G.edges())
CSLAB_G.add_edges_from([("a","c"),("c","d"), ("a",1), (1,"d"), ("a",2)])
nx.draw(CSLAB_G)
plt.show() # display
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPH_PATH_NETWORKX_V1
Purpose : A Program in Python for Path Graph using NetworkX Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 13:51 hrs
Version : 1.0
/***********************************
## Program Description : Program for Path Graph using NetworkX Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import networkx as nx
import matplotlib.pyplot as plt
CSLAB_G=nx.path_graph(4)
print("Nodes of graph: ")
print(CSLAB_G.nodes())
print("Edges of graph: ")
print(CSLAB_G.edges())
nx.draw(CSLAB_G)
plt.savefig("path_graph1.png")
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_RENAMING_NODES_NETWORKX_V1
Purpose : A Program in Python for Renaming Nodes of a Graph using NetworkX Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:42 hrs
Version : 1.0
/****************************************
## Program Description : Program for Renaming Nodes a Graph using NetworkX Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import matplotlib.pyplot as vAR_plt
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_Save_Graph = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_112_SAVE_GRAPH']
import networkx as vAR_nx
import matplotlib.pyplot as vAR_plt
vAR_CSLAB_G=vAR_nx.path_graph(4)
vAR_cities = {0:"Toronto",1:"London",2:"Berlin",3:"New York"}
vAR_CSLAB_H=vAR_nx.relabel_nodes(vAR_CSLAB_G,vAR_cities)
print("Nodes of graph: ")
print(vAR_CSLAB_H.nodes())
print("Edges of graph: ")
print(vAR_CSLAB_H.edges())
vAR_nx.draw(vAR_CSLAB_H)
vAR_plt.savefig(vAR_CSLAB_Save_Graph)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_EXAMPLE_PYMC_V1
Purpose : A Program in Python PYMC Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:31 hrs
Version : 1.0
/****************************************
## Program Description : Program for PYMC Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
vAR_plt.style.use('seaborn-darkgrid')
# Initialize random number generator
vAR_np.random.seed(123)
# True parameter values
vAR_CSLAB_alpha, vAR_CSLAB_sigma = 1, 1
vAR_CSLAB_beta = [1, 2.5]
# Size of dataset
vAR_CSLAB_size = 100
# Predictor variable
vAR_CSLAB_X1 = vAR_np.random.randn(vAR_CSLAB_size)
vAR_CSLAB_X2 = vAR_np.random.randn(vAR_CSLAB_size) * 0.2
# Simulate outcome variable
vAR_CSLAB_Y = vAR_CSLAB_alpha + vAR_CSLAB_beta[0]*vAR_CSLAB_X1 + vAR_CSLAB_beta[1]*vAR_CSLAB_X2 + vAR_np.random.randn(vAR_CSLAB_size)*vAR_CSLAB_sigma
%matplotlib inline
fig, axes = vAR_plt.subplots(1, 2, sharex=True, figsize=(10,4))
axes[0].scatter(vAR_CSLAB_X1, vAR_CSLAB_Y)
axes[1].scatter(vAR_CSLAB_X2, vAR_CSLAB_Y)
axes[0].set_ylabel('Y'); axes[0].set_xlabel('vAR_CSLAB_X1'); axes[1].set_xlabel('vAR_CSLAB_X2');
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_L1_BASED_FEATURE_SELECTION_V1
Purpose : A Program in Python for L1 Based Feature Selection
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:07 hrs
Version : 1.0
/***********************************************
## Program Description : Program for L1 Based Feature Selection in Python
## Python Development Environment & Runtime - Python, Anaconda
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectFromModel
vAR_CSLAB_iris = load_iris()
vAR_CSLAB_X, vAR_CSLAB_y = vAR_CSLAB_iris.data, vAR_CSLAB_iris.target
vAR_CSLAB_X.shape
vAR_CSLAB_lsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(vAR_CSLAB_X, vAR_CSLAB_y)
vAR_CSLAB_model = SelectFromModel(vAR_CSLAB_lsvc, prefit=True)
vAR_CSLAB_X_new = vAR_CSLAB_model.transform(vAR_CSLAB_X)
vAR_CSLAB_X_new.shape
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_LINE_PLOT_MATPLOTLIB_V1
Purpose : A Program in Python for Line Plot using Matplotlib Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 10:15 hrs
Version : 1.0
/******************************************
## Program Description : Program for Line Plot using Matplotlib Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as plt
plt.plot([1,2,3,4])
plt.ylabel('Numbers')
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_DOT_PLOT_MATPLOTLIB_V1
Purpose : A Program in Python for Dot Plot using Matplotlib Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 10:31 hrs
Version : 1.0
/******************************************
## Program Description : Program for Dot Plot using Matplotlib Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as plt
plt.plot([1,2,3,4], [1,4,9,16], 'bo')
plt.axis([0, 6, 0, 20])
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_NUMERIC_PLOT_MATPLOTLIB_V1
Purpose : A Program in Python for Numeric Plot using Matplotlib Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 11:04 hrs
Version : 1.0
/******************************************
## Program Description : Program for Numeric Plot using Matplotlib Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
import matplotlib.pyplot as plt
# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)
# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_FIGURES_AXES_MATPLOTLIB_V1
Purpose : A Program in Python for Figures & Axes using Matplotlib Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 11:54 hrs
Version : 1.0
/******************************************
## Program Description : Program for Figures & Axes using Matplotlib Package in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
import matplotlib.pyplot as plt
def f(t):
return np.exp(-t) * np.cos(2*np.pi*t)
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
plt.figure(1)
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_2D_PLOTTING_MAPPLOTLIB_V1
Purpose : A Program in Python for 2D Plotting using Matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:09 hrs
Version : 1.0
/******************************************
## Program Description : Program for 2D Plotting using Matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.gca(projection='3d')
x = np.linspace(0, 1, 100)
y = np.sin(x * 2 * np.pi) / 2 + 0.5
ax.plot(x, y, zs=0, zdir='z', label='zs=0, zdir=z')
colors = ('r', 'g', 'b', 'k')
for c in colors:
x = np.random.sample(20)
y = np.random.sample(20)
ax.scatter(x, y, 0, zdir='y', c=c)
ax.legend()
ax.set_xlim3d(0, 1)
ax.set_ylim3d(0, 1)
ax.set_zlim3d(0, 1)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_2D_PLOT_SCIKIT_LEARN_V1
Purpose : A Program in Python for 2D Plotting Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:45 hrs
Version : 1.0
## Program Description : Program for 2D Plotting Using SCIKIT LEARN in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.gca(projection='3d')
x = np.linspace(0, 1, 100)
y = np.sin(x * 2 * np.pi) / 2 + 0.5
ax.plot(x, y, zs=0, zdir='z', label='zs=0, zdir=z')
colors = ('r', 'g', 'b', 'k')
for c in colors:
x = np.random.sample(20)
y = np.random.sample(20)
ax.scatter(x, y, 0, zdir='y', c=c)
ax.legend()
ax.set_xlim3d(0, 1)
ax.set_ylim3d(0, 1)
ax.set_zlim3d(0, 1)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_CLASSIFICATION_SCIKIT_LEARN_V1
Purpose : A Program in Python for Classification Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:38 hrs
Version : 1.0
/******************************************
## Program Description : Program for Classification Using SCIKIT LEARN in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import linalg
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
from matplotlib import colors
from sklearn.lda import LDA
from sklearn.qda import QDA
cmap = colors.LinearSegmentedColormap(
'red_blue_classes',
{'red': [(0, 1, 1), (1, 0.7, 0.7)],
'green': [(0, 0.7, 0.7), (1, 0.7, 0.7)],
'blue': [(0, 0.7, 0.7), (1, 1, 1)]})
plt.cm.register_cmap(cmap=cmap)
def dataset_fixed_cov():
'''Generate 2 Gaussians samples with the same covariance matrix'''
n, dim = 300, 2
np.random.seed(0)
C = np.array([[0., -0.23], [0.83, .23]])
X = np.r_[np.dot(np.random.randn(n, dim), C),
np.dot(np.random.randn(n, dim), C) + np.array([1, 1])]
y = np.hstack((np.zeros(n), np.ones(n)))
return X, y
def dataset_cov():
'''Generate 2 Gaussians samples with different covariance matrices'''
n, dim = 300, 2
np.random.seed(0)
C = np.array([[0., -1.], [2.5, .7]]) * 2.
X = np.r_[np.dot(np.random.randn(n, dim), C),
np.dot(np.random.randn(n, dim), C.T) + np.array([1, 4])]
y = np.hstack((np.zeros(n), np.ones(n)))
return X, y
def plot_data(lda, X, y, y_pred, fig_index):
splot = plt.subplot(2, 2, fig_index)
if fig_index == 1:
plt.title('Linear Discriminant Analysis')
plt.ylabel('Data with fixed covariance')
elif fig_index == 2:
plt.title('Quadratic Discriminant Analysis')
elif fig_index == 3:
plt.ylabel('Data with varying covariances')
tp = (y == y_pred) # True Positive
tp0, tp1 = tp[y == 0], tp[y == 1]
X0, X1 = X[y == 0], X[y == 1]
X0_tp, X0_fp = X0[tp0], X0[~tp0]
X1_tp, X1_fp = X1[tp1], X1[~tp1]
xmin, xmax = X[:, 0].min(), X[:, 0].max()
ymin, ymax = X[:, 1].min(), X[:, 1].max()
# class 0: dots
plt.plot(X0_tp[:, 0], X0_tp[:, 1], 'o', color='red')
plt.plot(X0_fp[:, 0], X0_fp[:, 1], '.', color='#990000') # dark red
# class 1: dots
plt.plot(X1_tp[:, 0], X1_tp[:, 1], 'o', color='blue')
plt.plot(X1_fp[:, 0], X1_fp[:, 1], '.', color='#000099') # dark blue
# class 0 and 1 : areas
nx, ny = 200, 100
x_min, x_max = plt.xlim()
y_min, y_max = plt.ylim()
xx, yy = np.meshgrid(np.linspace(x_min, x_max, nx),
np.linspace(y_min, y_max, ny))
Z = lda.predict_proba(np.c_[xx.ravel(), yy.ravel()])
Z = Z[:, 1].reshape(xx.shape)
plt.pcolormesh(xx, yy, Z, cmap='red_blue_classes',
norm=colors.Normalize(0., 1.))
plt.contour(xx, yy, Z, [0.5], linewidths=2., colors='k')
# means
plt.plot(lda.means_[0][0], lda.means_[0][1],
'o', color='black', markersize=10)
plt.plot(lda.means_[1][0], lda.means_[1][1],
'o', color='black', markersize=10)
return splot
def plot_ellipse(splot, mean, cov, color):
v, w = linalg.eigh(cov)
u = w[0] / linalg.norm(w[0])
angle = np.arctan(u[1] / u[0])
angle = 180 * angle / np.pi # convert to degrees
# filled Gaussian at 2 standard deviation
ell = mpl.patches.Ellipse(mean, 2 * v[0] ** 0.5, 2 * v[1] ** 0.5,
180 + angle, color=color)
ell.set_clip_box(splot.bbox)
ell.set_alpha(0.5)
splot.add_artist(ell)
splot.set_xticks(())
splot.set_yticks(())
def plot_lda_cov(lda, splot):
plot_ellipse(splot, lda.means_[0], lda.covariance_, 'red')
plot_ellipse(splot, lda.means_[1], lda.covariance_, 'blue')
def plot_qda_cov(qda, splot):
plot_ellipse(splot, qda.means_[0], qda.covariances_[0], 'red')
plot_ellipse(splot, qda.means_[1], qda.covariances_[1], 'blue')
for i, (X, y) in enumerate([dataset_fixed_cov(), dataset_cov()]):
# LDA
lda = LDA(solver="svd", store_covariance=True)
y_pred = lda.fit(X, y).predict(X)
splot = plot_data(lda, X, y, y_pred, fig_index=2 * i + 1)
plot_lda_cov(lda, splot)
plt.axis('tight')
# QDA
qda = QDA()
y_pred = qda.fit(X, y, store_covariances=True).predict(X)
splot = plot_data(qda, X, y, y_pred, fig_index=2 * i + 2)
plot_qda_cov(qda, splot)
plt.axis('tight')
plt.suptitle('LDA vs QDA')
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_MODEL_SELECTION_SCIKIT_LEARN_V1
Purpose : A Program in Python for Model Selection Using SCIKIT LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:41 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Model Selection Using SCIKIT LEARN in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as vAR_plt
import numpy as vAR_np
from sklearn.datasets import load_digits
from sklearn.svm import SVC
from sklearn.model_selection import validation_curve
vAR_CSLAB_digits = load_digits()
vAR_CSLAB_X, vAR_CSLAB_y = vAR_CSLAB_digits.data, vAR_CSLAB_digits.target
vAR_CSLAB_param_range = vAR_np.logspace(-6, -1, 5)
vAR_CSLAB_train_scores, vAR_CSLAB_test_scores = validation_curve(
SVC(), vAR_CSLAB_X, vAR_CSLAB_y, param_name="gamma", param_range=vAR_CSLAB_param_range,
cv=10, scoring="accuracy", n_jobs=1)
vAR_CSLAB_train_scores_mean = vAR_np.mean(vAR_CSLAB_train_scores, axis=1)
vAR_CSLAB_train_scores_std = vAR_np.std(vAR_CSLAB_train_scores, axis=1)
vAR_CSLAB_test_scores_mean = vAR_np.mean(vAR_CSLAB_test_scores, axis=1)
vAR_CSLAB_test_scores_std = vAR_np.std(vAR_CSLAB_test_scores, axis=1)
vAR_plt.title("Validation Curve with SVM")
vAR_plt.xlabel("$\gamma$")
vAR_plt.ylabel("Score")
vAR_plt.ylim(0.0, 1.1)
vAR_plt.semilogx(vAR_CSLAB_param_range, vAR_CSLAB_train_scores_mean, label="Training score", color="r")
vAR_plt.fill_between(vAR_CSLAB_param_range, vAR_CSLAB_train_scores_mean - vAR_CSLAB_train_scores_std,
vAR_CSLAB_train_scores_mean + vAR_CSLAB_train_scores_std, alpha=0.2, color="r")
vAR_plt.semilogx(vAR_CSLAB_param_range, vAR_CSLAB_test_scores_mean, label="Cross-validation score",
color="g")
vAR_plt.fill_between(vAR_CSLAB_param_range, vAR_CSLAB_test_scores_mean - vAR_CSLAB_test_scores_std,
vAR_CSLAB_test_scores_mean + vAR_CSLAB_test_scores_std, alpha=0.2, color="g")
vAR_plt.legend(loc="best")
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_NEAREST_NEIGHBOURS_REGRESSION_SCIKIT-LEARN_V1
Purpose : A Program in Python for Nearest Neighbour Regression using SCIKIT-LEARN
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:28 hrs
Version : 1.0
/***********************************
## Program Description : Program for Nearest Neighbour Regression using SCIKIT-LEARN in Python
## Python Development Environment & Runtime - Python, Anaconda
# Generate sample data
import numpy as np
import matplotlib.pyplot as plt
from sklearn import neighbors
np.random.seed(0)
X = np.sort(5 * np.random.rand(40, 1), axis=0)
T = np.linspace(0, 5, 500)[:, np.newaxis]
y = np.sin(X).ravel()
# Add noise to targets
y[::5] += 1 * (0.5 - np.random.rand(8))
# Fit regression model
n_neighbors = 5
for i, weights in enumerate(['uniform', 'distance']):
knn = neighbors.KNeighborsRegressor(n_neighbors, weights=weights)
y_ = knn.fit(X, y).predict(T)
plt.subplot(2, 1, i + 1)
plt.scatter(X, y, c='k', label='data')
plt.plot(T, y_, c='g', label='prediction')
plt.axis('tight')
plt.legend()
plt.title("KNeighborsRegressor (k = %i, weights = '%s')" % (n_neighbors, weights))
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_REGULAR_PLOT_V1
Purpose : A Program in Python for Regular PLot in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:41 hrs
Version : 1.0
/***********************************
## Program Description : Program for Regular PLot in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
X = np.linspace(-np.pi,np.pi,n,endpoint=True)
Y = np.sin(2*X)
axes([0.025,0.025,0.95,0.95])
plot (X, Y+1, color='blue', alpha=1.00)
fill_between(X, 1, Y+1, color='blue', alpha=.25)
plot (X, Y-1, color='blue', alpha=1.00)
fill_between(X, -1, Y-1, (Y-1) > -1, color='blue', alpha=.25)
fill_between(X, -1, Y-1, (Y-1) < -1, color='red', alpha=.25)
xlim(-np.pi,np.pi), xticks([])
ylim(-2.5,2.5), yticks([])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_SCATTER_PLOT_V1
Purpose : A Program in Python for Scatter Plot in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:12 hrs
Version : 1.0
/***********************************
## Program Description : Program for Regular PLot in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
X = np.random.normal(0,1,n)
Y = np.random.normal(0,1,n)
T = np.arctan2(Y,X)
axes([0.025,0.025,0.95,0.95])
scatter(X,Y, s=75, c=T, alpha=.5)
xlim(-1.5,1.5), xticks([])
ylim(-1.5,1.5), yticks([])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_BAR_PLOT_V1
Purpose : A Program in Python for Bar Plot in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:47 hrs
Version : 1.0
/****************************************
## Program Description : Program for Bar Plot in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
import numpy as vAR_np
vAR_CSLAB_n = 12
vAR_CSLAB_X = vAR_np.arange(vAR_CSLAB_n)
vAR_CSLAB_Y1 = (1-vAR_CSLAB_X/float(vAR_CSLAB_n)) * vAR_np.random.uniform(0.5,1.0,vAR_CSLAB_n)
vAR_CSLAB_Y2 = (1-vAR_CSLAB_X/float(vAR_CSLAB_n)) * vAR_np.random.uniform(0.5,1.0,vAR_CSLAB_n)
axes([0.025,0.025,0.95,0.95])
bar(vAR_CSLAB_X, +vAR_CSLAB_Y1, facecolor='#9999ff', edgecolor='white')
bar(vAR_CSLAB_X, -vAR_CSLAB_Y2, facecolor='#ff9999', edgecolor='white')
for vAR_CSLAB_x,vAR_CSLAB_y in zip(vAR_CSLAB_X,vAR_CSLAB_Y1):
text(vAR_CSLAB_x+0.4, vAR_CSLAB_y+0.05, '%.2f' % vAR_CSLAB_y, ha='center', va= 'bottom')
for vAR_CSLAB_x,vAR_CSLAB_y in zip(vAR_CSLAB_X,vAR_CSLAB_Y2):
text(vAR_CSLAB_x+0.4, -vAR_CSLAB_y-0.05, '%.2f' % vAR_CSLAB_y, ha='center', va= 'top')
xlim(-.5,vAR_CSLAB_n), xticks([])
ylim(-1.25,+1.25), yticks([])
show()/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_CONTOUR_PLOT_V1
Purpose : A Program in Python for Contour Plot in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:09 hrs
Version : 1.0
/***********************************
## Program Description : Program for Contour PLot in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
def f(x,y): return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)
n = 256
x = np.linspace(-3,3,n)
y = np.linspace(-3,3,n)
X,Y = np.meshgrid(x,y)
axes([0.025,0.025,0.95,0.95])
contourf(X, Y, f(X,Y), 8, alpha=.75, cmap=cm.hot)
C = contour(X, Y, f(X,Y), 8, colors='black', linewidth=.5)
clabel(C, inline=1, fontsize=10)
xticks([]), yticks([])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_IMSHOW_V1
Purpose : A Program in Python for IMSHOW in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:07 hrs
Version : 1.0
/***********************************
## Program Description : Program for IMSHOW in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
def f(x,y): return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)
n = 10
x = np.linspace(-3,3,3.5*n)
y = np.linspace(-3,3,3.0*n)
X,Y = np.meshgrid(x,y)
Z = f(X,Y)
axes([0.025,0.025,0.95,0.95])
imshow(Z,interpolation='nearest', cmap='bone', origin='lower')
colorbar(shrink=.92)
xticks([]), yticks([])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_PIE_CHART_V1
Purpose : A Program in Python for Pie Charts in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 14:31 hrs
Version : 1.0
/****************************************
## Program Description : Program for Pie Charts in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
vAR_CSLAB_n = 20
vAR_CSLAB_Z = vAR_np.ones(vAR_CSLAB_n)
vAR_CSLAB_Z[-1] *= 2
axes([0.025,0.025,0.95,0.95])
pie(vAR_CSLAB_Z, explode=vAR_CSLAB_Z*.05, colors = ['%f' % (i/float(vAR_CSLAB_n)) for i in range(vAR_CSLAB_n)])
gca().set_aspect('equal')
xticks([]), vAR_plt.yticks([])
show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_QUIVER_PLOT_V1
Purpose : A Program in Python for Quiver Plot in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:00 hrs
Version : 1.0
/***********************************
## Program Description : Program for Quiver Plog in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
n = 8
X,Y = np.mgrid[0:n,0:n]
T = np.arctan2(Y-n/2.0, X-n/2.0)
R = 10+np.sqrt((Y-n/2.0)**2+(X-n/2.0)**2)
U,V = R*np.cos(T), R*np.sin(T)
axes([0.025,0.025,0.95,0.95])
quiver(X,Y,U,V,R, alpha=.5)
quiver(X,Y,U,V, edgecolor='k', facecolor='None', linewidth=.5)
xlim(-1,n), xticks([])
ylim(-1,n), yticks([])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_GRIDS_V1
Purpose : A Program in Python for Grids in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:24 hrs
Version : 1.0
/***********************************
## Program Description : Program for Grids in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
ax = axes([0.025,0.025,0.95,0.95])
ax.set_xlim(0,4)
ax.set_ylim(0,3)
ax.xaxis.set_major_locator(MultipleLocator(1.0))
ax.xaxis.set_minor_locator(MultipleLocator(0.1))
ax.yaxis.set_major_locator(MultipleLocator(1.0))
ax.yaxis.set_minor_locator(MultipleLocator(0.1))
ax.grid(which='major', axis='x', linewidth=0.75, linestyle='-', color='0.75')
ax.grid(which='minor', axis='x', linewidth=0.25, linestyle='-', color='0.75')
ax.grid(which='major', axis='y', linewidth=0.75, linestyle='-', color='0.75')
ax.grid(which='minor', axis='y', linewidth=0.25, linestyle='-', color='0.75')
ax.set_xticklabels([])
ax.set_yticklabels([])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_MULTI_PLOTS_V1
Purpose : A Program in Python for Multi Plots in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:49 hrs
Version : 1.0
/***********************************
## Program Description : Program for Multi Plots in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
fig =figure()
fig.subplots_adjust(bottom=0.025, left=0.025, top = 0.975, right=0.975)
subplot(2,1,1)
xticks([]), yticks([])
subplot(2,3,4)
xticks([]), yticks([])
subplot(2,3,5)
xticks([]), yticks([])
subplot(2,3,6)
xticks([]), yticks([])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_POLAR_AXIS_V1
Purpose : A Program in Python for Polar Axis in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:12 hrs
Version : 1.0
/***********************************
## Program Description : Program for Polar Axis in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
ax = axes([0.025,0.025,0.95,0.95], polar=True)
N = 20
theta = np.arange(0.0, 2*np.pi, 2*np.pi/N)
radii = 10*np.random.rand(N)
width = np.pi/4*np.random.rand(N)
bars = bar(theta, radii, width=width, bottom=0.0)
for r,bar in zip(radii, bars):
bar.set_facecolor( cm.jet(r/10.))
bar.set_alpha(0.5)
ax.set_xticklabels([])
ax.set_yticklabels([])
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_3D_PLOT_V1
Purpose : A Program in Python for 3D Plot in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:37 hrs
Version : 1.0
/***********************************
## Program Description : Program for 3D Plot in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
from pylab import *
from mpl_toolkits.mplot3d import Axes3D
fig = figure()
ax = Axes3D(fig)
X = np.arange(-4, 4, 0.25)
Y = np.arange(-4, 4, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.hot)
ax.contourf(X, Y, Z, zdir='z', offset=-2, cmap=cm.hot)
ax.set_zlim(-2,2)
show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_GRAPHING_MATPLOTLIB_TEXTS_V1
Purpose : A Program in Python for Texts in matplotlib
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:03 hrs
Version : 1.0
/****************************************
## Program Description : Program for Texts in matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib
import matplotlib.pyplot as vAR_plt
vAR_CSLAB_fig = vAR_plt.figure()
vAR_CSLAB_fig.suptitle('bold figure suptitle', fontsize=14, fontweight='bold')
vAR_CSLAB_ax = vAR_CSLAB_fig.add_subplot(111)
vAR_CSLAB_fig.subplots_adjust(top=0.85)
vAR_CSLAB_ax.set_title('axes title')
vAR_CSLAB_ax.set_xlabel('xlabel')
vAR_CSLAB_ax.set_ylabel('ylabel')
vAR_CSLAB_ax.text(3, 8, 'boxed italics text in data coords', style='italic',
bbox={'facecolor': 'red', 'alpha': 0.5, 'pad': 10})
vAR_CSLAB_ax.text(2, 6, r'an equation: $E=mc^2$', fontsize=15)
vAR_CSLAB_ax.text(3, 2, 'unicode: Institut für Festkörperphysik')
vAR_CSLAB_ax.text(0.95, 0.01, 'colored text in axes coords',
verticalalignment='bottom', horizontalalignment='right',
transform=vAR_CSLAB_ax.transAxes,
color='green', fontsize=15)
vAR_CSLAB_ax.plot([2], [1], 'o')
vAR_CSLAB_ax.annotate('annotate', xy=(2, 1), xytext=(3, 4),
arrowprops=dict(facecolor='black', shrink=0.05))
vAR_CSLAB_ax.axis([0, 10, 0, 10])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_HISTOGRAM_MATPLOTLIB_V1
Purpose : A Program in Python for Histogram using Matplotlib Package
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 12:32 hrs
Version : 1.0
/******************************************
## Program Description : Program for Histogram using Matplotlib in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
import matplotlib.pyplot as plt
mu, sigma = 100, 15
CSLAB_X = mu + sigma * np.random.randn(10000)
# the histogram of the data
n, bins, patches = plt.hist(CSLAB_X, 50, normed=1, facecolor='g', alpha=0.75)
plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, .025, r'$mu=100, sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_BED_OCCUPANCY_OPTIMIZATION_V1
Purpose : A Program in Python Bed Occupancy Optimization Usecase
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 9:42 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Bed Occupancy Optimization Usecase in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
vAR_CSLAB_fig = vAR_plt.figure()
vAR_CSLAB_ax = vAR_CSLAB_fig.gca(projection='3d')
vAR_CSLAB_x = vAR_np.linspace(0, 1, 100)
vAR_CSLAB_y = vAR_np.sin(vAR_CSLAB_x * 2 * vAR_np.pi) / 2 + 0.5
vAR_CSLAB_ax.plot(vAR_CSLAB_x, vAR_CSLAB_y, zs=0, zdir='z')
vAR_CSLAB_colors = ('r', 'g', 'b', 'k')
for vAR_CSLAB_c in vAR_CSLAB_colors:
vAR_CSLAB_x = vAR_np.random.sample(20)
vAR_CSLAB_y = vAR_np.random.sample(20)
vAR_CSLAB_ax.scatter(vAR_CSLAB_x, vAR_CSLAB_y, 0, zdir='y', c=vAR_CSLAB_c)
vAR_CSLAB_ax.legend()
vAR_CSLAB_ax.set_xlim3d(0, 1)
vAR_CSLAB_ax.set_ylim3d(0, 1)
vAR_CSLAB_ax.set_zlim3d(0, 1)
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/************************************
File Name : CSLAB_LIFE_TIME_VALUE_CUSTOMER_PREDICTION_V1
Purpose : A Program in Python For Predicting Life Time Value Customers
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:04 hrs
Version : 1.0
/******************************************
## Program Description : Program For Predicting Life Time Value Customers in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib
from numpy.random import randn
import matplotlib.pyplot as plt
from matplotlib.ticker import FuncFormatter
def to_percent(y, position):
# Ignore the passed in position. This has the effect of scaling the default
# tick locations.
s = str(100 * y)
# The percent symbol needs escaping in latex
if matplotlib.rcParams['text.usetex'] is True:
return s + r'$%$'
else:
return s + '%'
x = randn(5000)
plt.hist(x, bins=50, normed=True)
formatter = FuncFormatter(to_percent)
plt.gca().yaxis.set_major_formatter(formatter)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_CUSTOMER_UPSELLING_CHARACTERISTICS_PREDICTION_V1
Purpose : A Program in Python For Predicting Customers Upselling Characteristics
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 15:41 hrs
Version : 1.0
/******************************************
## Program Description : Program For Predicting Customers Upselling Characteristics in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0.01, 5.0, 0.01)
s = np.exp(-t)
plt.plot(t, s)
plt.xlim(5, 0)
plt.xlabel('Incresing time (s)')
plt.ylabel('Upselling (%)')
plt.title('Should be growing...')
plt.grid(True)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_SALES_LEAD_PRIORTIZATION_V1
Purpose : A Program in Python For Lead Priortization
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:17 hrs
Version : 1.0
/******************************************
## Program Description : Program For Lead Priortization in Python
## Python Development Environment & Runtime - Python, Anaconda
from __future__ import print_function
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cbook as cbook
import matplotlib.dates as mdates
from matplotlib.dates import bytespdate2num
datafile = cbook.get_sample_data('msft.csv', asfileobj=False)
print('loading', datafile)
dates, closes = np.loadtxt(datafile, delimiter=',',
converters={0: bytespdate2num('%d-%b-%y')},
skiprows=1, usecols=(0, 2), unpack=True)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot_date(dates, closes, '-')
fig.autofmt_xdate()
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_INVENTORY_DEMAND_FORECASTING_V1
Purpose : A Program in Python For Inventory Demand Forecasting
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 16:55 hrs
Version : 1.0
/******************************************
## Program Description : Program For Inventory Demand Forecasting in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as plt
import numpy as np
t1 = np.arange(0.0, 2.0, 0.1)
t2 = np.arange(0.0, 2.0, 0.01)
l1, = plt.plot(t2, np.exp(-t2))
l2, l3 = plt.plot(t2, np.sin(2 * np.pi * t2), '--go', t1, np.log(1 + t1), '.')
l4, = plt.plot(t2, np.exp(-t2) * np.sin(2 * np.pi * t2), 'rs-.')
plt.legend((l2, l4), ('Actual Demand', 'Forecated Demand'), loc='upper right', shadow=True)
plt.xlabel('time')
plt.ylabel('Demand %')
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_CREDIT_CARD_FRAUD_RISK_V1
Purpose : A Program in Python For Credit Card Fraud Risk
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:21 hrs
Version : 1.0
/******************************************
## Program Description : Program For Credit Card Fraud Risk in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as plt
from numpy import arange, pi, cos, sin
from numpy.random import rand
rx, ry = 3., 1.
area = rx * ry * pi
theta = arange(0, 2*pi + 0.01, 0.1)
verts = list(zip(rx/area*cos(theta), ry/area*sin(theta)))
x, y, s, c = rand(4, 30)
s *= 10**2.
fig, ax = plt.subplots()
ax.scatter(x, y, s, c, marker=None, verts=verts)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_EMPLOYEE_CHURN_PREDICTION_V1
Purpose : A Program in Python For Predicting Employee Churn Rate
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 17:43 hrs
Version : 1.0
/******************************************
## Program Description : Program For Predicting Employee Churn Rate in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)
def layers(n, m):
"""
Return *n* random Gaussian mixtures, each of length *m*.
"""
def bump(a):
x = 1 / (.1 + np.random.random())
y = 2 * np.random.random() - .5
z = 10 / (.1 + np.random.random())
for i in range(m):
w = (i / float(m) - y) * z
a[i] += x * np.exp(-w * w)
a = np.zeros((m, n))
for i in range(n):
for j in range(5):
bump(a[:, i])
return a
d = layers(3, 100)
plt.subplots()
plt.stackplot(range(100), d.T, baseline='wiggle')
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_PATIENT_MEDICATION_COMPLAINCE_PREDICTION_V1
Purpose : A Program in Python For Predicting Patient Medication Compliance
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:12 hrs
Version : 1.0
/******************************************
## Program Description : Program For Predicting Patient Medication Compliance in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
import matplotlib.pyplot as plt
def fnx():
return np.random.randint(5, 50, 10)
y = np.row_stack((fnx(), fnx(), fnx()))
x = np.arange(10)
y1, y2, y3 = fnx(), fnx(), fnx()
fig, ax = plt.subplots()
ax.stackplot(x, y)
plt.show()
fig, ax = plt.subplots()
ax.stackplot(x, y1, y2, y3)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_PHYSICIAN_ATTRITION_PREDICTION_V1
Purpose : A Program in Python For Predicting Physician Attrition
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:12 hrs
Version : 1.0
/******************************************
## Program Description : Program For Predicting Physician Attrition in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for c, z in zip(['r', 'g', 'b', 'y'], [30, 20, 10, 0]):
xs = np.arange(20)
ys = np.random.rand(20)
# You can provide either a single color or an array. To demonstrate this,
# the first bar of each set will be colored cyan.
cs = [c] * len(xs)
cs[0] = 'c'
ax.bar(xs, ys, zs=z, zdir='y', color=cs, alpha=0.8)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_PATIENT_READMITTANCE_RATE_PREDICTION_V1
Purpose : A Program in Python For Predicting Patient Readmittacnce
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:58 hrs
Version : 1.0
/******************************************
## Program Description : Program For Predicting Patient Readmittacnce in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import axes3d
import matplotlib.pyplot as plt
from matplotlib import cm
fig = plt.figure()
ax = fig.gca(projection='3d')
X, Y, Z = axes3d.get_test_data(0.05)
cset = ax.contour(X, Y, Z, extend3d=True, cmap=cm.coolwarm)
ax.clabel(cset, fontsize=9, inline=1)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_PATIENT_INSURANCE_CLAIM_PREDICTION_V1
Purpose : A Program in Python For Predicting Patient Insurance Claim
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 18:58 hrs
Version : 1.0
/******************************************
## Program Description : Program For Predicting Patient Insurance Claim in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
def f(t):
s1 = np.cos(2*np.pi*t)
e1 = np.exp(-t)
return np.multiply(s1, e1)
ax = fig.add_subplot(2, 1, 2, projection='3d')
X = np.arange(-5, 5, 0.25)
xlen = len(X)
Y = np.arange(-5, 5, 0.25)
ylen = len(Y)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
linewidth=0, antialiased=False)
ax.set_zlim3d(-1, 1)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/************************************
File Name : CSLAB_DRUG_DEMAND_FORECASTING_V1
Purpose : A Program in Python For Drug Demad Forecasting
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 19:22 hrs
Version : 1.0
/******************************************
## Program Description : Program For Drug Demad Forecasting in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.gca(projection='3d')
X, Y = np.mgrid[0:6*np.pi:0.25, 0:4*np.pi:0.25]
Z = np.sqrt(np.abs(np.cos(X) + np.cos(Y)))
surf = ax.plot_surface(X + 1e5, Y + 1e5, Z, cmap='autumn', cstride=2, rstride=2)
ax.set_zlim(0, 2)
plt.show()
/***********************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/***********************************
/**************************************
File Name : CSLAB_CUSTOMER_RETENTION_ANALYSIS_V1
Purpose : A Program in Python For Customer Retention Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 19:45 hrs
Version : 1.0
/***********************************************
## Program Description : Program For Customer Retention Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.collections import PolyCollection
from matplotlib.colors import colorConverter
import matplotlib.pyplot as vAR_plt
import numpy as vAR_np
vAR_CSLAB_fig = vAR_plt.figure()
vAR_CSLAB_ax = vAR_CSLAB_fig.gca(projection='3d')
def cc(arg):
return colorConverter.to_rgba(arg, alpha=0.6)
vAR_CSLAB_xs = vAR_np.arange(0, 10, 0.4)
vAR_CSLAB_verts = []
vAR_CSLAB_zs = [0.0, 1.0, 2.0, 3.0]
for z in vAR_CSLAB_zs:
vAR_CSLAB_ys = vAR_np.random.rand(len(vAR_CSLAB_xs))
vAR_CSLAB_ys[0], vAR_CSLAB_ys[-1] = 0, 0
vAR_CSLAB_verts.append(list(zip(vAR_CSLAB_xs, vAR_CSLAB_ys)))
vAR_CSLAB_poly = PolyCollection(vAR_CSLAB_verts, facecolors=[cc('r'), cc('g'), cc('b'),
cc('y')])
vAR_CSLAB_poly.set_alpha(0.7)
vAR_CSLAB_ax.add_collection3d(vAR_CSLAB_poly, zs=vAR_CSLAB_zs, zdir='y')
vAR_CSLAB_ax.set_xlim3d(0, 10)
vAR_CSLAB_ax.set_ylim3d(-1, 4)
vAR_CSLAB_ax.set_zlabel('Z')
vAR_CSLAB_ax.set_zlim3d(0, 1)
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/*********************************
File Name : CSLAB_HOSPITAL_BED_TURN_ANALYSIS_V1
Purpose : A Program in Python For Hospital Bed Turn Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 20:11 hrs
Version : 1.0
/*************************************
## Program Description : Program For Hospital Bed Turn Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x, y = np.random.rand(2, 100) * 4
hist, xedges, yedges = np.histogram2d(x, y, bins=4)
elements = (len(xedges) - 1) * (len(yedges) - 1)
xpos, ypos = np.meshgrid(xedges[:-1] + 0.25, yedges[:-1] + 0.25)
xpos = xpos.flatten()
ypos = ypos.flatten()
zpos = np.zeros(elements)
dx = 0.5 * np.ones_like(zpos)
dy = dx.copy()
dz = hist.flatten()
ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color='b', zsort='average')
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_PATIENT_SURVIVAL_ANALYSIS_V1
Purpose : A Program in Python For Patient Survival Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 20:31 hrs
Version : 1.0
/*************************************
## Program Description : Program For Patient Survival Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
def randrange(n, vmin, vmax):
return (vmax - vmin)*np.random.rand(n) + vmin
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
n = 100
for c, m, zl, zh in [('r', 'o', -50, -25), ('b', '^', -30, -5)]:
xs = randrange(n, 23, 32)
ys = randrange(n, 0, 100)
zs = randrange(n, zl, zh)
ax.scatter(xs, ys, zs, c=c, marker=m)
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_PATIENT_MEDICATION_EFFECTIVENESS_ANALYSIS_V1
Purpose : A Program in Python For Patient Medication Effectiveness Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 21:03 hrs
Version : 1.0
/*************************************
## Program Description : Program For Patient Medication Effectiveness Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.gca(projection='3d')
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
ax.set_zlim(-1.01, 1.01)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_SALES_GROWTH_ANALYSIS_V1
Purpose : A Program in Python For Sales Growth Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 21:12 hrs
Version : 1.0
/*************************************
## Program Description : Program For Sales Growth Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
x = 10 * np.outer(np.cos(u), np.sin(v))
y = 10 * np.outer(np.sin(u), np.sin(v))
z = 10 * np.outer(np.ones(np.size(u)), np.cos(v))
ax.plot_surface(x, y, z, rstride=4, cstride=4, color='b')
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_CUSTOMER_CROSS_SELLING_ANALYSIS_V1
Purpose : A Program in Python For Customer Cross Selling Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 21:35 hrs
Version : 1.0
/*************************************
## Program Description : Program For Customer Cross Selling Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.gca(projection='3d')
X = np.arange(-5, 5, 0.25)
xlen = len(X)
Y = np.arange(-5, 5, 0.25)
ylen = len(Y)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
colortuple = ('y', 'b')
colors = np.empty(X.shape, dtype=str)
for y in range(ylen):
for x in range(xlen):
colors[x, y] = colortuple[(x + y) % len(colortuple)]
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=colors,
linewidth=0, antialiased=False)
ax.set_zlim3d(-1, 1)
ax.w_zaxis.set_major_locator(LinearLocator(6))
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_PRODUCT_CUSTOMER_SEGMENTATION_V1
Purpose : A Program in Python For Product Customer Segmentation Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 21:52 hrs
Version : 1.0
/*************************************
## Program Description : Program For Product Customer Segmentation Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
import matplotlib
import numpy as np
from matplotlib import cm
from matplotlib import pyplot as plt
step = 0.04
maxval = 1.0
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# create supporting points in polar coordinates
r = np.linspace(0, 1.25, 50)
p = np.linspace(0, 2*np.pi, 50)
R, P = np.meshgrid(r, p)
# transform them to cartesian system
X, Y = R*np.cos(P), R*np.sin(P)
Z = ((R**2 - 1)**2)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.YlGnBu_r)
ax.set_zlim3d(0, 1)
ax.set_zlabel(r'$V(phi)$')
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_EMPLOYEE_TALENT_MANGEMENT_V1
Purpose : A Program in Python For Employee Talent Mangement Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 22:07 hrs
Version : 1.0
/*************************************
## Program Description : Program For Employee Talent Mangement Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.tri as tri
import numpy as np
import math
# First create the x and y coordinates of the points.
n_angles = 48
n_radii = 8
min_radius = 0.25
radii = np.linspace(min_radius, 0.95, n_radii)
angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += math.pi/n_angles
x = (radii*np.cos(angles)).flatten()
y = (radii*np.sin(angles)).flatten()
z = (np.cos(radii)*np.cos(angles*3.0)).flatten()
# Create a custom triangulation
triang = tri.Triangulation(x, y)
# Mask off unwanted triangles.
xmid = x[triang.triangles].mean(axis=1)
ymid = y[triang.triangles].mean(axis=1)
mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
triang.set_mask(mask)
plt.figure()
plt.gca(projection='3d')
plt.tricontourf(triang, z)
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_PATIENT_BED_OCCUPANCY_V1
Purpose : A Program in Python For Patient Bed Occupancy
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 22:21 hrs
Version : 1.0
/*************************************
## Program Description : Program For Patient Bed Occupancy in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import matplotlib.pyplot as plt
import numpy as np
n_angles = 36
n_radii = 8
radii = np.linspace(0.125, 1.0, n_radii)
angles = np.linspace(0, 2*np.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
x = np.append(0, (radii*np.cos(angles)).flatten())
y = np.append(0, (radii*np.sin(angles)).flatten())
z = np.sin(-x*y)
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0.2)
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_PRODUCT_MARKET_BASKET_ANALYSIS_V1
Purpose : A Program in Python For Product Basket Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 22:47 hrs
Version : 1.0
/*************************************
## Program Description : Program For Product Basket Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.tri as mtri
# u, v are parameterisation variables
u = (np.linspace(0, 2.0 * np.pi, endpoint=True, num=50) * np.ones((10, 1))).flatten()
v = np.repeat(np.linspace(-0.5, 0.5, endpoint=True, num=10), repeats=50).flatten()
x = (1 + 0.5 * v * np.cos(u / 2.0)) * np.cos(u)
y = (1 + 0.5 * v * np.cos(u / 2.0)) * np.sin(u)
z = 0.5 * v * np.sin(u / 2.0)
# Triangulate parameter space to determine the triangles
tri = mtri.Triangulation(u, v)
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1, projection='3d')
ax.plot_trisurf(x, y, z, triangles=tri.triangles, cmap=plt.cm.Spectral)
ax.set_zlim(-1, 1)
n_angles = 36
n_radii = 8
min_radius = 0.25
radii = np.linspace(min_radius, 0.95, n_radii)
angles = np.linspace(0, 2*np.pi, n_angles, endpoint=False)
angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
angles[:, 1::2] += np.pi/n_angles
x = (radii*np.cos(angles)).flatten()
y = (radii*np.sin(angles)).flatten()
z = (np.cos(radii)*np.cos(angles*3.0)).flatten()
triang = mtri.Triangulation(x, y)
xmid = x[triang.triangles].mean(axis=1)
ymid = y[triang.triangles].mean(axis=1)
mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
triang.set_mask(mask)
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1, projection='3d')
ax.plot_trisurf(triang, z, cmap=plt.cm.CMRmap)
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_AUTOMOBILE_CLAIMS_HANDLING_ANALYSIS_V1
Purpose : A Program in Python For Auto Claims Handling
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 23:04 hrs
Version : 1.0
/*************************************
## Program Description : Program For Auto Claims Handling Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
from mpl_toolkits.mplot3d import axes3d
import matplotlib.pyplot as plt
import numpy as np
import time
def generate(X, Y, phi):
R = 1 - np.sqrt(X**2 + Y**2)
return np.cos(2 * np.pi * X + phi) * R
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
xs = np.linspace(-1, 1, 50)
ys = np.linspace(-1, 1, 50)
X, Y = np.meshgrid(xs, ys)
Z = generate(X, Y, 0.0)
wframe = None
tstart = time.time()
for phi in np.linspace(0, 360 / 2 / np.pi, 100):
oldcol = wframe
Z = generate(X, Y, phi)
wframe = ax.plot_wireframe(X, Y, Z, rstride=2, cstride=2)
ax.collections.remove(oldcol)
plt.pause(.001)
print('FPS: %f' % (100 / (time.time() - tstart)))
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_CUSTOMER_MARKET_SHARE_V1
Purpose : A Program in Python For Market Share Analysis
Author : DeepSphere.AI, Inc.
Date and Time : 14/12/2018 23:17 hrs
Version : 1.0
/*************************************
## Program Description : Program For Market Share Analysis in Python
## Python Development Environment & Runtime - Python, Anaconda
import matplotlib.pyplot as plt
import numpy as np
data = ((3, 1000), (10, 3), (100, 30), (500, 800), (50, 1))
plt.yscale('log')
dim = len(data[0])
w = 0.75
dimw = w / dim
x = np.arange(len(data))
for i in range(len(data[0])):
y = [d[i] for d in data]
b = plt.bar(x + i * dimw, y, dimw, bottom=0.001)
plt.xticks(x + w / 2)
plt.ylim((0.001, 1000))
plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_EXCEL_V1
Purpose : A Program in Python for Collecting Data from an Excel File
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 9:51 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from Excel File into a Dataframe in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_Data = vAR_pd.read_excel('C:/Python_Programs/Train_Data_Unplanned_Expenses.xlsx')
vAR_CSLAB_Data
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_CSV_V1
Purpose : A Program in Python for Collecting Data from a CSV File
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 10:01 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from a CSV File in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_Data = vAR_pd.read_csv('C:/Python_Programs/Test_Data_Unplanned_Expenses_RF.csv')
vAR_CSLAB_Data
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_CLIPBOARD_V1
Purpose : A Program in Python for Collecting Data from Clipboard
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 10:08 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from Clipboard in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_Data = vAR_pd.read_clipboard('C:/Python_Programs/Train_Data_Unplanned_Expenses.txt')
vAR_CSLAB_Data
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_HTML_V1
Purpose : A Program in Python for Colecting Data from HTML
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 10:17 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from HTML in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_Data = vAR_pd.read_html('https://www.fnb.co.za/Controller?nav=rates.forex.list.ForexRatesList',index_col=1, header=0)
vAR_CSLAB_Data
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_XML_V1
Purpose : A Program in Python for Collecting Data from XML
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 10:22 hrs
Version : 1.0
/*************************************
## Program Description : Program for Colecting Data from XML in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
import requests
vAR_CSLAB_user_agent_url = 'http://www.user-agents.org/allagents.xml'
vAR_CSLAB_xml_data = requests.get(vAR_CSLAB_user_agent_url).content
vAR_CSLAB_xml_data
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_JSON_V1
Purpose : A Program in Python for Collecting JSON Data
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 10:31 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from JSON in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_url = 'https://raw.githubusercontent.com/chrisalbon/simulated_datasets/master/data.json'
vAR_CSLAB_df = vAR_pd.read_json(vAR_CSLAB_url, orient='columns')
vAR_CSLAB_df
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_PDF_V1
Purpose : A Program in Python for Collecting Data from a PDF File
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 10:42 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from a PDF File in Python
## Python Development Environment & Runtime - Python, Anaconda
import PyPDF2
vAR_CSLAB_pdf_file = open('C:/Python_Programs/201308FCR.pdf','rb')
vAR_CSLAB_read_pdf = PyPDF2.PdfFileReader(vAR_CSLAB_pdf_file)
vAR_CSLAB_number_of_pages = vAR_CSLAB_read_pdf.getNumPages()
vAR_CSLAB_page = vAR_CSLAB_read_pdf.getPage(0)
vAR_CSLAB_page_content = vAR_CSLAB_page.extractText()
print (vAR_CSLAB_page_content.encode('utf-8'))
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_PLAINTEXT_V1
Purpose : A Program in Python for Collecting Data from Plaintext
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 10:55 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from Plaintext in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_File = open('C:/Python_Programs/Train_Data_Unplanned_Expenses.dat')
vAR_CSLAB_LIST = vAR_CSLAB_File.readlines()
vAR_CSLAB_LIST = vAR_pd.DataFrame(vAR_CSLAB_LIST)
vAR_CSLAB_LIST
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_WORD_V1
Purpose : A Program in Python for Collecting Data from a Word Document
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 11:12 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from a Word Document in Python
## Python Development Environment & Runtime - Python, Anaconda
from docx import Document
vAR_CSLAB_document = Document('C:/Python_Programs/Docker.docx')
for table in vAR_CSLAB_document.tables:
for row in table.rows:
for cell in row.cells:
print (cell.text)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_HDF_V1
Purpose : A Program in Python for Collecting Data from HDF
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 11:23 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from HDF in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_df = vAR_pd.DataFrame([[1, 1.0, 'a']], columns=['x', 'y', 'z'])
vAR_CSLAB_df.to_hdf('./store.h5', 'data')
vAR_CSLAB_reread = vAR_pd.read_hdf('./store.h5')
vAR_CSLAB_reread
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/**************************************
File Name : CSLAB_DATA_COLLECTION_FROM_IMAGE_V1
Purpose : A Program in Python for Collecting Data from an Image File
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 11:34 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Collecting Data from an Image in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import matplotlib.pyplot as vAR_plt
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_DC_IMG = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_171_DATA_COLLECTION_IMG']
from scipy import misc
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
vAR_CSLAB_DC_IMG_W = {'img':[misc.imread(vAR_CSLAB_DC_IMG)]}
vAR_CSLAB_DC_IMG_W
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_MP3_V1
Purpose : A Program in Python for Collecting Data from a MP3 File
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 11:48 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from a MP3 File in Python
## Python Development Environment & Runtime - Python, Anaconda
from pydub import AudioSegment
vAR_CSLAB_sound = AudioSegment.from_mp3("C:/Python_Programs/test.mp3",'rb')
vAR_CSLAB_raw_data = vAR_CSLAB_sound._data
vAR_CSLAB_raw_data
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_MP3_V1
Purpose : A Program in Python for Colecting Data from a MP3 File
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 12:14 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from SAP HANA in Python
## Python Development Environment & Runtime - Python, Anaconda
import pypyodbc as vAR_pyodbc
vAR_CSLAB_CONN = vAR_pyodbc.connect('DSN=DS;UID=DURGA;PWD=Delhi123')
vAR_CSLAB_CURSOR = CSLAB_CONN.cursor()
vAR_CSLAB_STMNT = 'SELECT * FROM DURGA.TICKETS'
vAR_CSLAB_CURSOR.execute(vAR_CSLAB_STMNT)
vAR_CSLAB_RESULT = vAR_CSLAB_CURSOR.fetchall()
print (vAR_CSLAB_RESULT)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_COLLECTION_FROM_HADOOP_V1
Purpose : A Program in Python for Collecting Data from Hadoop
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 12:28 hrs
Version : 1.0
/*************************************
## Program Description : Program for Collecting Data from Hadoop in Python
## Python Development Environment & Runtime - Python, Anaconda
import pypyodbc as vAR_pyodbc
vAR_CSLAB_CONN = vAR_pyodbc.connect('DSN=Hive;UID=hive;PWD=hive',autocommit=True)
vAR_CSLAB_CURSOR = vAR_CSLAB_CONN.cursor()
vAR_CSLAB_STMNT = 'SHOW TABLES'
vAR_CSLAB_CURSOR.execute(vAR_CSLAB_STMNT)
vAR_CSLAB_RESULT = vAR_CSLAB_CURSOR.fetchall()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_INTEGRATION_CONCATENATE_V1
Purpose : A Program in Python for Integrating Data using Concatenate function
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 12:50 hrs
Version : 1.0
/*************************************
## Program Description : Program for Integrating Data using Concatenate function in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_df1 = pd.DataFrame({'Asset No': ['Asset 101', 'Asset 102', 'Asset 103'],'Asset Type': ['Building', 'Vehicle', 'Equipment']})
vAR_CSLAB_df2 = pd.DataFrame({'Asset No': ['Asset 104', 'Asset 105', 'Asset 107'],'Asset Type': ['Building', 'Vehicle', 'Equipment']})
vAR_CSLAB_df3 = pd.DataFrame({'Asset No': ['Asset 108', 'Asset 109', 'Asset 110'],'Asset Type': ['Building', 'Vehicle', 'Equipment']})
vAR_CSLAB_frames = [vAR_CSLAB_df1, vAR_CSLAB_df2, vAR_CSLAB_df3]
import pandas as vAR_pd
vAR_CSLAB_result = vAR_pd.concat(vAR_CSLAB_frames)
vAR_CSLAB_result = vAR_pd.DataFrame(vAR_CSLAB_result)
vAR_CSLAB_result
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_INTEGRATION_MERGE_V1
Purpose : A Program in Python for Integrating Data using Merge function
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 13:45 hrs
Version : 1.0
/*************************************
## Program Description : Program for Integrating Data using Merge function in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_df1 = vAR_pd.DataFrame({'Asset No': ['Asset 101', 'Asset 102', 'Asset 103'],'Asset Location': ['CA', 'LA', 'UT']})
vAR_CSLAB_df2 = vAR_pd.DataFrame({'Asset No': ['Asset 101', 'Asset 102', 'Asset 103'],'Age in Years': [20, 27, 24]})
vAR_CSLAB_df3 = vAR_pd.DataFrame({'Asset No': ['Asset 101', 'Asset 102', 'Asset 103'],'No of Repairs': [5, 4, 10]})
vAR_CSLAB_frames = [vAR_CSLAB_df1, vAR_CSLAB_df2, vAR_CSLAB_df3]
vAR_CSLAB_df4 = vAR_pd.merge(vAR_CSLAB_df1,vAR_CSLAB_df2, how='inner')
vAR_CSLAB_df5 = vAR_pd.merge(vAR_CSLAB_df3,vAR_CSLAB_df4, how='outer')
vAR_CSLAB_df5
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_INTEGRATION_MERGE_V1
Purpose : A Program in Python for Integrating Data using Join function
Author : DeepSphere.AI, Inc.
Date and Time : 17/12/2018 14:05 hrs
Version : 1.0
/*************************************
## Program Description : Program for Integrating Data using Join function in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_df1 = vAR_pd.DataFrame({'Asset No': ['Asset 101', 'Asset 102', 'Asset 103'],'Asset Location': ['CA', 'LA', 'UT']})
vAR_CSLAB_df2 = vAR_pd.DataFrame({'Asset No': ['Asset 104', 'Asset 105', 'Asset 107'],'Age in Years': [20, 27, 24]})
vAR_CSLAB_df3 = vAR_pd.DataFrame({'Asset No': ['Asset 108', 'Asset 109', 'Asset 110'],'No of Repairs': [5, 4, 10]})
vAR_CSLAB_frames = [vAR_CSLAB_df1, vAR_CSLAB_df2, vAR_CSLAB_df3]
vAR_CSLAB_result = vAR_pd.concat(vAR_CSLAB_frames, axis=1, join='inner')
vAR_CSLAB_result = vAR_pd.DataFrame(vAR_CSLAB_result)
vAR_CSLAB_result
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_MAPPING_DICTIONARY_LITERAL_VALUES_V1
Purpose : A Program in Python for Mapping Data using Dictionary Literal Values
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 9:20 hrs
Version : 1.0
/*************************************
## Program Description : Program for Mapping Data using Dictionary Literal Values in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_diceRoll = { (1,1): "snake eyes", (6,6): "box cars" }
vAR_CSLAB_myBoat = { "NAME":"KaDiMa", "LOA":18, "SAILS":["main","jib","spinnaker"] }
vAR_CSLAB_theBets = { }
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_MAPPING_DICTIONARY_OPERATIONS_V1
Purpose : A Program in Python for Mapping Data using Dictionary Operations
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 9:38 hrs
Version : 1.0
/*************************************
## Program Description : Program for Mapping Data using Dictionary Operations in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_d= {}
vAR_CSLAB_d[2] = [ (1,1) ]
vAR_CSLAB_d[3] = [ (1,2), (2,1) ]
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_MAPPING_DICTIONARY_COMPARISION_OPERATIONS_V1
Purpose : A Program in Python for Mapping Data using Dictionary Comparision Operations
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 9:47 hrs
Version : 1.0
/*************************************
## Program Description : Program for Mapping Data using Dictionary Comparision Operations in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_colors = { "blue": (0x30,0x30,0xff), "green": (0x30,0xff,0x97),"red": (0xff,0x30,0x97), "yellow": (0xff,0xff,0x30) }
"blue" in CSLAB_colors
(0x30,0x30,0xff) in vAR_CSLAB_colors
"orange" not in vAR_CSLAB_colors
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_MAPPING_DICTIONARY_STATMENTS_V1
Purpose : A Program in Python for Mapping Data using Dictionary Statements
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 9:59 hrs
Version : 1.0
/*************************************
## Program Description : Program for Mapping Data using Dictionary Dictionary Statements in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_colors = { "blue": (0x30,0x30,0xff), "green": (0x30,0xff,0x97),"red": (0xff,0x30,0x97), "yellow": (0xff,0xff,0x30) }
for c in vAR_CSLAB_colors:
print (c, vAR_CSLAB_colors[c])
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_PROVISIONING_EXTRACTION_V1
Purpose : A Program in Python for Data Provisioning - Extraction
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 10:21 hrs
Version : 1.0
/*************************************
## Program Description : Program for Data Provisioning - Extraction in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_Data = vAR_pd.read_excel('C:/Python_Programs/Train_Data_Unplanned_Expenses.xlsx')
vAR_CSLAB_Data
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_PROVISIONING_TRANSFORMATION_V1
Purpose : A Program in Python for Data Provisioning - Transformation
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 10:30 hrs
Version : 1.0
/*************************************
## Program Description : Program for Data Provisioning - Transformation in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_Data = vAR_pd.read_excel('C:/Python_Programs/Train_Data_Unplanned_Expenses.xlsx')
vAR_CSLAB_Data.head(4)
vAR_CSLAB_Data.groupby('Asset Type')["Casualities"].transform('sum')
vAR_CSLAB_Data["Total Casualities"] = vAR_CSLAB_Data.groupby('Asset Type')["Casualities"].transform('sum')
vAR_CSLAB_Data.head(2)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DATA_PROVISIONING_LOADING_V1
Purpose : A Program in Python for Data Provisioning - Loading
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 11:03 hrs
Version : 1.0
/*************************************
## Program Description : Program for Data Provisioning - Loading in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
vAR_CSLAB_CONN = vAR_pyodbc.connect('DSN=DS;UID=DURGA;PWD=Delhi123')
vAR_CSLAB_CURSOR = CSLAB_CONN.cursor()
vAR_CSLAB_STMNT = 'INSERT INTO DURGA.LEASE'
vAR_CSLAB_CURSOR.execute(vAR_CSLAB_STMNT)
vAR_CSLAB_RESULT = vAR_CSLAB_CURSOR.fetchall()
print (vAR_CSLAB_RESULT)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_ITERATORS_V1
Purpose : A Program in Python for Iterators
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 11:24 hrs
Version : 1.0
/*************************************
## Program Description : Program for Iterators in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_nums = [1, 2, 3]
iter(vAR_CSLAB_nums)
vAR_CSLAB_it = iter(vAR_CSLAB_nums)
next(vAR_CSLAB_it)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_ITERATORS_V1
Purpose : A Program in Python for Generator Expressions
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 11:33 hrs
Version : 1.0
/*************************************
## Program Description : Program for Generator Expressions in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_nums = [1, 2, 3]
iter(vAR_CSLAB_nums)
vAR_CSLAB_it = iter(vAR_CSLAB_nums)
next(vAR_CSLAB_it)
(i for i in vAR_CSLAB_nums)
[i for i in vAR_CSLAB_nums]
{i for i in range(3)}
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_ITERATORS_V1
Purpose : A Program in Python for Generators
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 11:41 hrs
Version : 1.0
/*************************************
## Program Description : Program for Generators in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_CSLAB_f():
... yield 1
... yield 2
vAR_CSLAB_f()
vAR_CSLAB_gen = vAR_CSLAB_f()
next(vAR_CSLAB_gen)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_BIDIRECTIONAL_COMMUNICATION_V1
Purpose : A Program in Python for Bidirectional Communication
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 11:55 hrs
Version : 1.0
/*************************************
## Program Description : Program for Bidirectional Communication in Python
## Python Development Environment & Runtime - Python, Anaconda
import itertools
def vAR_CSLAB_g():
print('--start--')
for i in itertools.count():
print('--yielding %i--' % i)
try:
vAR_CSLAB_ans = yield i
except GeneratorExit:
print('--closing--')
raise
except Exception as e:
print('--yield raised %r--' % e)
else:
print('--yield returned %s--' % vAR_CSLAB_ans)
vAR_CSLAB_it = vAR_CSLAB_g()
next(vAR_CSLAB_it)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_CHAINING_GENERATORS_V1
Purpose : A Program in Python for Chaining Generators
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 12:14 hrs
Version : 1.0
/*************************************
## Program Description : Program for Chaining Generators in Python
## Python Development Environment & Runtime - Python, Anaconda
import itertools
def vAR_CSLAB_g():
print('--start--')
for i in itertools.count():
print('--yielding %i--' % i)
try:
vAR_CSLAB_ans = yield i
except GeneratorExit:
print('--closing--')
raise
except Exception as e:
print('--yield raised %r--' % e)
else:
print('--yield returned %s--' % vAR_CSLAB_ans)
vAR_CSLAB_it = vAR_CSLAB_g()
next(vAR_CSLAB_it)
vAR_CSLAB_it.send(11)
#subgen = some_other_generator()
#for v in subgen:
#yield v
CSLAB_it = g()
next(CSLAB_it)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DECORATORS_V1
Purpose : A Program in Python for Decorators
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 12:14 hrs
Version : 1.0
/*************************************
## Program Description : Program for Decorators in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_CSLAB_inc(vAR_x):
return vAR_x + 1
def vAR_CSLAB_dec(vAR_x):
return vAR_x - 1
def vAR_CSLAB_operate(func, vAR_x):
vAR_result = func(vAR_x)
return vAR_result
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DECORATORS_AS_FUNCTIONS_V1
Purpose : A Program in Python for Decorators as Functions
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 12:28 hrs
Version : 1.0
/*************************************
## Program Description : Program for Decorators as Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_replacing_decorator_with_args(arg):
print("defining the decorator")
def vAR_decorator(function):
# in this inner function, arg is available too
print("doing decoration, %r" % arg)
def vAR_wrapper(*args, **kwargs):
print("inside wrapper, %r %r" % (args, kwargs))
return function(*args, **kwargs)
return vAR_wrapper
return vAR_decorator
@replacing_decorator_with_args("abc")
def vAR_function(*args, **kwargs):
print("inside function, %r %r" % (args, kwargs))
return 14
vAR_function(11, 12)
function(11, 12)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DECORATORS_AS_CLASSES_V1
Purpose : A Program in Python for Decorators as Classes
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 12:41 hrs
Version : 1.0
/*************************************
## Program Description : Program for Decorators as Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
class vAR_decorator_class(object):
def __init__(self, arg):
# this method is called in the decorator expression
print("in decorator init, %s" % arg)
self.arg = arg
def __call__(self, function):
# this method is called to do the job
print("in decorator call, %s" % self.arg)
return function
vAR_deco_instance = vAR_decorator_class('foo')
@deco_instance
def vAR_function(*args, **kwargs):
print("in function, %s %s" % (args, kwargs))
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_DECORATORS_COPYING_DOCSTRING_OTHER_ATTRIBUTES_V1
Purpose : A Program in Python for Decorators - Copying the docstring and other attributes of the original function
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 12:55 hrs
Version : 1.0
/*************************************
## Program Description : Program for Copying the docstring and other attributes of the original function in Python
## Python Development Environment & Runtime - Python, Anaconda
import functools
def vAR_replacing_decorator_with_args(arg):
print("defining the decorator")
def vAR_decorator(function):
print("doing decoration, %r" % arg)
def vAR_wrapper(*args, **kwargs):
print("inside wrapper, %r %r" % (args, kwargs))
return function(*args, **kwargs)
return functools.update_wrapper(_wrapper, function)
return vAR_decorator
@replacing_decorator_with_args("abc")
def vAR_function():
"extensive documentation"
print("inside function")
return 14
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/**************************************
File Name : CSLAB_EXAMPLE_STANDARD_LIBRARY_V1
Purpose : A Program in Python for Example of Standard Library
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 14:00 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Example of Standard Library in Python
## Python Development Environment & Runtime - Python, Anaconda
import os
import platform
import logging
if platform.platform().startswith('Windows'):
vAR_CSLAB_logging_file = os.path.join(os.getenv('HOMEDRIVE'),
os.getenv('HOMEPATH'),
'test.log')
else:
vAR_CSLAB_logging_file = os.path.join(os.getenv('HOME'),
'test.log')
print("Logging to", vAR_CSLAB_logging_file)
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s : %(levelname)s : %(message)s',
filename=vAR_CSLAB_logging_file,
filemode='w',
)
logging.debug("Start of the program")
logging.info("Doing something")
logging.warning("Dying now")
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEPRICIATION_OF_FUNCTIONS_V1
Purpose : A Program in Python for Depriciation of Functions
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 14:21 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Depriciation of Functions in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_BV=5000
vAR_CSLAB_Life=5
vAR_CSLAB_slvg=200
def Depreciation_Function():
print ('%15s'%"Year"'%15s'%"Dep"'%15s'% "BV")
for i in range(0,vAR_CSLAB_Life):
Dep=((vAR_CSLAB_BV-vAR_CSLAB_slvg)*i)/vAR_CSLAB_Life
AccDep=((vAR_CSLAB_BV-vAR_CSLAB_slvg)*(vAR_CSLAB_Life-i))/vAR_CSLAB_Life
print ('%12.0f'%i,'%12.2f'%Dep, '%12.2f'%AccDep)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/*********************************
File Name : CSLAB_WHILE_LOOP_REMOVING_DECORATOR_V1
Purpose : A Program in Python for While Loop Removing Decorator
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 14:42 hrs
Version : 1.0
/*************************************
## Program Description : Program for While Loop Removing Decorator in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_find_answers():
vAR_answers = []
while True:
vAR_ans = look_for_next_answer()
if vAR_ans is None:
break
answers.append(vAR_ans)
return answers
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_PLUGIN_REGISTRATION_SYSTEM_V1
Purpose : A Program in Python for Plugin Registartion System
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 15:05 hrs
Version : 1.0
/*************************************
## Program Description : Program for Plugin Registartion System in Python
## Python Development Environment & Runtime - Python, Anaconda
class vAR_WordProcessor(object):
vAR_PLUGINS = []
def vAR_process(self, text):
for plugin in self.PLUGINS:
vAR_text = plugin().cleanup(text)
return vAR_text
@classmethod
def vAR_plugin(cls, plugin):
cls.vAR_PLUGINS.append(plugin)
@WordProcessor.plugin
class vAR_CleanMdashesExtension(object):
def vAR_cleanup(self, text):
return vAR_text.replace('—', u'N{em dash}')
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_CONTEXT_MANAGERS_V1
Purpose : A Program in Python for Context Mangers
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 15:28 hrs
Version : 1.0
/*************************************
## Program Description : Program for Context Mangers in Python
## Python Development Environment & Runtime - Python, Anaconda
class vAR_closing(object):
def __init__(self, obj):
self.obj = obj
def __enter__(self):
return self.obj
def __exit__(self, *args):
self.obj.close()
#with closing(open('/C:/Python_Programs/Train_Data_Unplanned_Expenses.xlsx', 'w')) as f:
#f.write('the contentsn')
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_CONTEXT_MANAGERS_CATCHING_EXCEPTIONS_V1
Purpose : A Program in Python for Context Mangers - Catching Exceptions
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 15:47 hrs
Version : 1.0
/*************************************
## Program Description : Program for Context Mangers - Catching Exceptions in Python
## Python Development Environment & Runtime - Python, Anaconda
class vAR_assert_raises(object):
# based on pytest and unittest.TestCase
def __init__(self, type):
self.type = type
def __enter__(self):
pass
def __exit__(self, type, value, traceback):
if type is None:
raise AssertionError('exception expected')
if issubclass(type, self.type):
return True # swallow the expected exception
raise AssertionError('wrong exception type')
with assert_raises(KeyError):
{}['foo']
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_CONTEXT_MANAGERS_DEFINING_USING_GENERATORS_V1
Purpose : A Program in Python for Defining Context Mangers using Generators
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 16:14 hrs
Version : 1.0
/*************************************
## Program Description : Program for Defining Context Mangers using Generators in Python
## Python Development Environment & Runtime - Python, Anaconda
@contextlib.contextmanager
def vAR_some_generator(<arguments>):
<setup>
try:
yield <value>
finally:
<cleanup>
@contextlib.contextmanager
def vAR_closing(obj):
try:
yield obj
finally:
obj.close()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_V1
Purpose : A Program in Python for ndarray
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 16:38 hrs
Version : 1.0
/*************************************
## Program Description : Program for for ndarray in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_CSLAB_ndarray = vAR_np.ndarray(shape=(2,2), dtype=float, order='F')
vAR_CSLAB_ndarray = vAR_np.ndarray((2,), buffer=np.array([1,2,3]),offset=np.int_().itemsize,dtype=int)
vAR_CSLAB_ndarray
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_BLOCK_OF_MEMORY_V1
Purpose : A Program in Python for ndarray - Block of Memory
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 16:38 hrs
Version : 1.0
/*************************************
## Program Description : Program for for ndarray - Block of Memory in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_CSLAB_X = vAR_np.array([1, 2, 3], dtype=np.int32)
vAR_CSLAB_X.data
bytes(vAR_CSLAB_X.data)
vAR_CSLAB_X.__array_interface__['data'][0]
vAR_CSLAB_X.__array_interface__
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_DATA_TYPE_V1
Purpose : A Program in Python for ndarray - Data Type
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 16:47 hrs
Version : 1.0
/*************************************
## Program Description : Program for ndarray - Data Type in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_CSLAB_X = vAR_np.array([1, 2, 3])
vAR_CSLAB_X.dtype
vAR_np.dtype(int).itemsize
vAR_np.dtype(int).byteorder
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_INDEXING_SCHEME_STRIDES_V1
Purpose : A Program in Python for ndarray - Indexing Scheme Strides
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 17:05 hrs
Version : 1.0
/*************************************
## Program Description : Program for ndarray - Indexing Scheme Strides in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_CSLAB_X = vAR_np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]], dtype=np.int8)
str(vAR_CSLAB_X.data)
vAR_CSLAB_X.strides
vAR_CSLAB_byte_offset = 3*1 + 1*2
vAR_CSLAB_X.flat[CSLAB_byte_offset]
vAR_CSLAB_X[1, 2]
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_SLICING_WITH_INTEGERS_V1
Purpose : A Program in Python for ndarray - Slicing With Integers
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 17:18 hrs
Version : 1.0
/*************************************
## Program Description : Program for ndarray - Slicing With Integers in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_CSLAB_X = vAR_np.array([1, 2, 3, 4, 5, 6], dtype=np.int32)
vAR_CSLAB_y = x[::-1]
vAR_CSLAB_y.strides
vAR_CSLAB_y = x[2:]
vAR_CSLAB_y
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_TRANSPOSING_WITH_INTEGERS_V1
Purpose : A Program in Python for ndarray - Transposing With Integers
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 17:31 hrs
Version : 1.0
/*************************************
## Program Description : Program for ndarray - Transposing With Integers in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_CSLAB_X = vAR_np.array([1, 2, 3, 4, 5, 6], dtype=np.int32)
vAR_CSLAB_y = vAR_CSLAB_x[::-1]
VAR_CSLAB_y.strides
vAR_CSLAB_y = vAR_CSLAB_x[2:]
vAR_CSLAB_y
vAR_CSLAB_Z = vAR_np.zeros((10, 10, 10), dtype=np.float)
vAR_CSLAB_Z.strides
vAR_CSLAB_Z[::2,::3,::4].strides
vAR_CSLAB_A = np.zeros((10, 10, 10), dtype=np.float)
vAR_CSLAB_A.T.strides
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_RESHAPING_INTEGERS_V1
Purpose : A Program in Python for ndarray - Reshaping Integers
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 17:47 hrs
Version : 1.0
/*************************************
## Program Description : Program for ndarray - Reshaping Integers in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_CSLAB_X = vAR_np.array([1, 2, 3, 4, 5, 6], dtype=np.int32)
vAR_CSLAB_y = vAR_CSLAB_X[::-1]
vAR_CSLAB_y.strides
vAR_CSLAB_y = vAR_CSLAB_X[2:]
vAR_CSLAB_y
vAR_CSLAB_Z = vAR_np.zeros((10, 10, 10), dtype=np.float)
vAR_CSLAB_Z.strides
vAR_CSLAB_Z[::2,::3,::4].strides
vAR_CSLAB_A = vAR_np.arange(6, dtype=np.int8).reshape(3, 2)
vAR_CSLAB_A
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_BROADCASTING_V1
Purpose : A Program in Python for ndarray - Broadcasing
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 18:03 hrs
Version : 1.0
/*************************************
## Program Description : Program for ndarray - Broadcasing in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
from numpy.lib.stride_tricks import as_strided
vAR_CSLAB_X = np.array([1, 2, 3, 4], dtype=np.int16)
vAR_CSLAB_X2 = as_strided(vAR_CSLAB_X, strides=(0, 1*2), shape=(3, 4))
vAR_CSLAB_Y = vAR_np.array([5, 6, 7], dtype=np.int16)
vAR_CSLAB_Y2 = as_strided(vAR_CSLAB_Y, strides=(1*2, 0), shape=(3, 4))
vAR_CSLAB_X2 * vAR_CSLAB_Y2
vAR_CSLAB_X = vAR_np.array([1, 2, 3, 4], dtype=np.int16)
vAR_CSLAB_Y = vAR_np.array([5, 6, 7], dtype=np.int16)
vAR_CSLAB_X[vAR_np.newaxis,:] * vAR_CSLAB_Y[:,vAR_np.newaxis]
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/**************************************
File Name : CSLAB_NDARRAY_UNIVERSAL_FUNCTION_V1
Purpose : A Program in Python for Universal Function on ndarray
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 18:24 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Universal Function on ndarray in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_np.random.seed(0)
def vAR_CSLAB_compute_reciprocals(vAR_CSLAB_values):
vAR_CSLAB_output = vAR_np.empty(len(vAR_CSLAB_values))
for i in range(len(vAR_CSLAB_values)):
vAR_CSLAB_output[i] = 1.0 / vAR_CSLAB_values[i]
return vAR_CSLAB_output
vAR_CSLAB_values = vAR_np.random.randint(1, 10, size=5)
vAR_CSLAB_compute_reciprocals(vAR_CSLAB_values)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/*********************************
File Name : CSLAB_NDARRAY_GENERALIZED_UNIVERSAL_FUNCTION_V1
Purpose : A Program in Python for ndarray - Generalized Universal Function
Author : DeepSphere.AI, Inc.
Date and Time : 18/12/2018 19:02 hrs
Version : 1.0
/*************************************
## Program Description : Program for ndarray - Universal Function in Python
## Python Development Environment & Runtime - Python, Anaconda
void gufunc_loop(void **args, int *dimensions, int *steps, void *data)
{
char *input_1 = (char*)args[0]; /* these are as previously */
char *input_2 = (char*)args[1];
char *output = (char*)args[2];
int input_1_stride_m = steps[3]; /* strides for the core dimensions */
int input_1_stride_n = steps[4]; /* are added after the non-core */
int input_2_strides_n = steps[5]; /* steps */
int input_2_strides_p = steps[6];
int output_strides_n = steps[7];
int output_strides_p = steps[8];
int m = dimension[1]; /* core dimensions are added after */
int n = dimension[2]; /* the main dimension; order as in */
int p = dimension[3]; /* signature */
int i;
for (i = 0; i < dimensions[0]; ++i) {
matmul_for_strided_matrices(input_1, input_2, output,
strides for each array...);
input_1 += steps[0];
input_2 += steps[1];
output += steps[2];
}
}
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_NDARRAY_OLD_BUFFER_PROTOCOL_V1
Purpose : A Program in Python for ndarray - Old Buffer Protocol
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 9:51 hrs
Version : 1.0
/*************************************
## Program Description : Program for ndarray - Old Buffer Protocol in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
from PIL import Image
vAR_CSLAB_data = vAR_np.zeros((200, 200, 4), dtype=np.int8)
vAR_CSLAB_data[:, :] = [255, 0, 0, 255] # Red
vAR_CSLAB_data = vAR_CSLAB_data.view(np.int32).squeeze()
vAR_CSLAB_img = Image.frombuffer("RGBA", (200, 200), data, "raw", "RGBA", 0, 1)
vAR_CSLAB_img.save('test.png')
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_OPENING_WRITING_TO_IMAGE_V1
Purpose : A Program in Python for Opening & Writing to Image Files
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 10:32 hrs
Version : 1.0
/*************************************
## Program Description : Program for Opening & Writing to Image Files in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import misc
vAR_CSLAB_f = misc.face()
misc.imsave('face.png', vAR_CSLAB_f) # uses the Image module (PIL)
import matplotlib.pyplot as vAR_plt
vAR_plt.imshow(vAR_CSLAB_f)
vAR_plt.show()
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_DISPLAYING_IMAGES_V1
Purpose : A Program in Python for Displaying Images
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 11:25 hrs
Version : 1.0
/*************************************
## Program Description : Program for Displaying Images in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_f = misc.face(gray=True)
import matplotlib.pyplot as vAR_plt
vAR_plt.imshow(vAR_CSLAB_f, cmap=vAR_plt.cm.gray)
vAR_plt.imshow(vAR_CSLAB_f, cmap=vAR_plt.cm.gray, vmin=30, vmax=200)
vAR_plt.axis('off')
vAR_plt.contour(vAR_CSLAB_f, [50, 200])
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_DISPLAYING_IMAGES_BASIC_MANIPULATION_V1
Purpose : A Program in Python for Image Processing - Basic Manipulation
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 11:25 hrs
Version : 1.0
/*************************************
## Program Description : Program for for Image Processing - Basic Manipulation in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
vAR_CSLAB_face = misc.face(gray=True)
vAR_CSLAB_face[0, 40]
vAR_CSLAB_face[10:13, 20:23]
vAR_CSLAB_face[100:120] = 255
vAR_lx, vAR_ly = vAR_CSLAB_face.shape
vAR_X, vAR_Y = vAR_np.ogrid[0:vAR_lx, 0:vAR_ly]
vAR_CSLAB_mask = (vAR_X - vAR_lx / 2) ** 2 + (vAR_Y - vAR_ly / 2) ** 2 > vAR_lx * vAR_ly / 4
vAR_CSLAB_face[vAR_CSLAB_mask] = 0
vAR_CSLAB_face[range(400), range(400)] = 255
vAR_plt.imshow(CSLAB_face)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_GEOMETRICAL_TRANSFORMATIONS_V1
Purpose : A Program in Python for Image Processing - Geometrical Transformations
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 11:44 hrs
Version : 1.0
/*************************************
## Program Description : Program for Image Processing - Geometrical Transformations in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
from scipy import ndimage
vAR_CSLAB_face = misc.face(gray=True)
vAR_lx, vAR_ly = vAR_CSLAB_face.shape
vAR_crop_face = vAR_CSLAB_face[vAR_lx // 4: - vAR_lx // 4, vAR_ly // 4: - vAR_ly // 4]
vAR_CSLAB_flip_ud_face = vAR_np.flipud(vAR_CSLAB_face)
vAR_CSLAB_rotate_face = ndimage.rotate(vAR_CSLAB_face, 45)
vAR_CSLAB_rotate_face_noreshape = ndimage.rotate(vAR_CSLAB_face, 45, reshape=False)
vAR_plt.imshow(vAR_CSLAB_flip_ud_face)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_FILTERING_BLURRING_V1
Purpose : A Program in Python for Image Processing - Blurring
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 12:07 hrs
Version : 1.0
/*************************************
## Program Description : Program for Image Processing - Blurring in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import misc
from scipy import ndimage
vAR_CSLAB_face = misc.face(gray=True)
vAR_CSLAB_blurred_face = ndimage.gaussian_filter(vAR_CSLAB_face, sigma=3)
vAR_CSLAB_very_blurred = ndimage.gaussian_filter(vAR_CSLAB_face, sigma=5)
vAR_plt.imshow(vAR_CSLAB_very_blurred)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_FILTERING_SHARPENING_V1
Purpose : A Program in Python for Image Processing - Sharpeneing
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 12:34 hrs
Version : 1.0
/*************************************
## Program Description : Program for Image Processing - Blurring in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import misc
from scipy import ndimage
vAR_CSLAB_face = misc.face(gray=True).astype(float)
vAR_CSLAB_blurred_f = ndimage.gaussian_filter(vAR_CSLAB_face, 3)
vAR_plt.imshow(vAR_CSLAB_very_blurred)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_FILTERING_DENOISING_V1
Purpose : A Program in Python for Image Processing - Denoising
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 12:53 hrs
Version : 1.0
/*************************************
## Program Description : Program for Image Processing - Denoising in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
from scipy import misc
vAR_CSLAB_f = misc.face(gray=True)
vAR_CSLAB_f = vAR_CSLAB_f[230:290, 220:320]
vAR_CSLAB_noisy = vAR_CSLAB_f + 0.4 * vAR_CSLAB_f.std() * vAR_np.random.random(CSLAB_f.shape)
vAR_plt.imshow(vAR_CSLAB_noisy)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_FILTERING_APPLY_GAUSSIAN_FILTER_V1
Purpose : A Program in Python for Image Processing - Applying Gaussian Filter
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 13:42 hrs
Version : 1.0
/*************************************
## Program Description : Program for Image Processing - Applying Gaussian Filter in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
from scipy import ndimage
import matplotlib.pyplot as vAR_plt
from scipy import misc
vAR_CSLAB_f = misc.face(gray=True)
vAR_CSLAB_f = vAR_CSLAB_f[230:290, 220:320]
vAR_CSLAB_noisy = vAR_CSLAB_f + 0.4 * vAR_CSLAB_f.std() * vAR_np.random.random(vAR_CSLAB_f.shape)
vAR_CSLAB_gauss_denoised = ndimage.gaussian_filter(vAR_CSLAB_noisy, 2)
vAR_plt.imshow(vAR_CSLAB_gauss_denoised)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_FILTERING_APPLY_MEDIAN_FILTER_V1
Purpose : A Program in Python for Image Processing - Applying Median Filter
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 14:08 hrs
Version : 1.0
/*************************************
## Program Description : Program for Image Processing - Applying Median Filter in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
from scipy import ndimage
import matplotlib.pyplot as vAR_plt
from scipy import misc
vAR_CSLAB_f = misc.face(gray=True)
vAR_CSLAB_f = vAR_CSLAB_f[230:290, 220:320]
vAR_CSLAB_noisy = vAR_CSLAB_f + 0.4 * vAR_CSLAB_f.std() * vAR_np.random.random(vAR_CSLAB_f.shape)
vAR_CSLAB_med_denoised = ndimage.median_filter(vAR_CSLAB_noisy, 3)
vAR_plt.imshow(CSLAB_med_denoised)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_FEATURE_EXTRACTION_EDGE_DETECTION_V1
Purpose : A Program in Python for Image Processing - Edge Detection
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 14:22 hrs
Version : 1.0
/*************************************
## Program Description : Program for Image Processing - Edge Detection in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import misc
import numpy as vAR_np
import numpy as vAR_np
from scipy import ndimage
import matplotlib.pyplot as vAR_plt
import matplotlib.pyplot as vAR_plt
vAR_CSLAB_im = vAR_np.zeros((256, 256))
vAR_CSLAB_im[64:-64, 64:-64] = 1
CSLAB_im = ndimage.rotate(CSLAB_im, 15, mode='constant')
CSLAB_im = ndimage.gaussian_filter(CSLAB_im, 8)
plt.imshow(CSLAB_im)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/*********************************
File Name : CSLAB_IMAGE_PROCESSING_FEATURE_EXTRACTION_SEGMENTATION_V1
Purpose : A Program in Python for Image Processing - Segmentation
Author : DeepSphere.AI, Inc.
Date and Time : 19/12/2018 14:38 hrs
Version : 1.0
## Program Description : Program for Image Processing - Edge Detection in Python
## Python Development Environment & Runtime - Python, Anaconda
from scipy import misc
import numpy as vAR_np
from scipy import ndimage
import matplotlib.pyplot as vAR_plt
vAR_CSLAB_n = 10
vAR_CSLAB_l = 256
vAR_CSLAB_im = vAR_np.zeros((CSLAB_l, CSLAB_l))
vAR_np.random.seed(1)
vAR_CSLAB_points = vAR_CSLAB_l*vAR_np.random.random((2, vAR_CSLAB_n**2))
vAR_CSLAB_im[(vAR_CSLAB_points[0]).astype(vAR_np.int), (vAR_CSLAB_points[1]).astype(vAR_np.int)] = 1
vAR_CSLAB_im = ndimage.gaussian_filter(vAR_CSLAB_im, sigma=vAR_CSLAB_l/(4.*vAR_CSLAB_n))
vAR_plt.imshow(vAR_CSLAB_im)
/*******************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*******************************
/**************************************
File Name : CSLAB_TENSORFLOW_HELLO_WORLD_V1
Purpose : A Program in Python Tensorflow for Basic Hello World
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 9:38 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Basic Hello World using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as tf
vAR_CSLAB_hello = tf.constant('Hello, TensorFlow!')
# Start tf session
VAR_CSLAB_sess = tf.Session()
# Run the operation of initializing the constant
print(VAR_CSLAB_sess.run(vAR_CSLAB_hello))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_TENSORS_V1
Purpose : A Program in Python Tensorflow for Tensors
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 9:47 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Tensors using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_C = vAR_tf.constant([[1.0, 2.0], [3.0, 4.0]])
vAR_CSLAB_D = vAR_tf.constant([[1.0, 1.0], [0.0, 1.0]])
# Construct a `Session` to execute the graph.
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_E = vAR_tf.matmul(vAR_CSLAB_C, vAR_CSLAB_D)
# Execute the graph and store the value that `e` represents in `result`.
vAR_CSLAB_result = vAR_CSLAB_sess.run(vAR_CSLAB_E)
vAR_CSLAB_result
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_FIXED_TENSORS_V1
Purpose : A Program in Python Tensorflow for Fixed Tensors
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 9:58 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Fixed Tensors using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
VAR_CSLAB_zero_tsr = tf.zeros([4,5])
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_result = vAR_CSLAB_sess.run(VAR_CSLAB_zero_tsr)
vAR_CSLAB_result
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_SEQUENCE_TENSORS_V1
Purpose : A Program in Python Tensorflow for Sequence Tensors
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 10:12 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Sequence Tensors using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
VAR_CSLAB_linear_tsr = tf.linspace(start=0.0, stop=1.0, num=3)
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_result = vAR_CSLAB_sess.run(VAR_CSLAB_linear_tsr)
vAR_CSLAB_result
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_RANDON_TENSORS_V1
Purpose : A Program in Python Tensorflow for Random Tensors
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 10:29 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Random Tensors using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_rand_tsr = tf.random_uniform([3,4],minval=0,maxval=1)
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_result = vAR_CSLAB_sess.run(vAR_CSLAB_rand_tsr)
vAR_CSLAB_result
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_CONSTANTS_V1
Purpose : A Program in Python Tensorflow for Constants
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 10:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Constants using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_C = vAR_tf.constant([[1.0, 2.0], [3.0, 4.0]])
vAR_CSLAB_D = vAR_tf.constant([[1.0, 1.0], [0.0, 1.0]])
vAR_CSLAB_sess = vAR_tf.Session()
print(vAR_CSLAB_sess.run(vAR_CSLAB_C))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_VARIABLES_V1
Purpose : A Program in Python Tensorflow for Variables
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 10:48 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Variables using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_my_var = vAR_tf.Variable(tf.zeros([2,3]))
vAR_CSLAB_my_var
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_PLACEHOLDERS_V1
Purpose : A Program in Python Tensorflow for Placeholders
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 10:59 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Placeholders using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
import numpy as vAR_np
vAR_CSLAB_X = vAR_tf.placeholder(tf.float32, shape=[2,2])
vAR_CSLAB_Y = vAR_tf.identity(vAR_CSLAB_X)
vAR_CSLAB_X_VALS = vAR_np.random.rand(2,2)
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_sess.run(vAR_CSLAB_Y, feed_dict={vAR_CSLAB_X:vAR_CSLAB_X_VALS})
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_GRAPHS_V1
Purpose : A Program in Python Tensorflow for Graphs
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 11:14 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Graphs using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_g = vAR_tf.Graph()
with vAR_CSLAB_g.as_default():
VAR_CSLAB_A = vAR_tf.constant(15, name="input_a")
VAR_CSLAB_B = vAR_tf.constant(13, name="input_b")
VAR_CSLAB_C = vAR_tf.add(VAR_CSLAB_A,VAR_CSLAB_B)
vAR_CSLAB_sess = vAR_tf.Session(graph=vAR_CSLAB_g)
vAR_CSLAB_sess
print(vAR_CSLAB_C)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_SESSION_V1
Purpose : A Program in Python Tensorflow for Sessions
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 11:28 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Sessions using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_C = vAR_tf.constant([[1.0, 2.0], [3.0, 4.0]])
vAR_CSLAB_D = vAR_tf.constant([[1.0, 1.0], [0.0, 1.0]])
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_E = vAR_tf.matmul(vAR_CSLAB_C, vAR_CSLAB_D)
print(vAR_CSLAB_sess.run(vAR_CSLAB_E))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_FEED_DICTIONARY_V1
Purpose : A Program in Python Tensorflow for Feed Dictionary
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 11:43 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Feed Dictionary using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
import numpy as vAR_np
vAR_CSLAB_X = vAR_tf.placeholder(tf.float32, shape=[2,2])
vAR_CSLAB_Y = vAR_tf.identity(vAR_CSLAB_X)
vAR_CSLAB_X_VALS = vAR_np.random.rand(2,2)
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_sess.run(vAR_CSLAB_Y, feed_dict={vAR_CSLAB_X:vAR_CSLAB_X_VALS})
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_DATA_TYPE_V1
Purpose : A Program in Python Tensorflow for Data Types
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 11:51 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Data Types using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
import numpy as vAR_np
vAR_CSLAB_X = vAR_tf.placeholder(dtype = tf.float32, shape=[2,2])
vAR_CSLAB_X.dtype
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_ADD_TWO_CONSATNTS_V1
Purpose : A Program in Python Tensorflow for Adding Two Constants
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 12:04 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Adding Two Constants using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_C = vAR_tf.constant([[1.0, 2.0], [3.0, 4.0]])
vAR_CSLAB_D = vAR_tf.constant([[1.0, 1.0], [0.0, 1.0]])
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_E = vAR_tf.add(vAR_CSLAB_C,vAR_CSLAB_D)
print(vAR_CSLAB_sess.run(vAR_CSLAB_E))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_MULTIPLY_TWO_CONSATNTS_V1
Purpose : A Program in Python Tensorflow for Multiplying Two Constants
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 12:17 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Multiplying Two Constants using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_C = vAR_tf.constant([[1.0, 2.0], [3.0, 4.0]])
vAR_CSLAB_D = vAR_tf.constant([[1.0, 1.0], [0.0, 1.0]])
vAR_CSLAB_sess = vAR_tf.Session()
vAR_CSLAB_E = vAR_tf.matmul(vAR_CSLAB_C,vAR_CSLAB_D)
print(vAR_CSLAB_sess.run(vAR_CSLAB_E))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_MATRIX_INVERSE_METHOD_V1
Purpose : A Program in Python Tensorflow for Matrix Inverse Method
Author : DeepSphere.AI, Inc.
Date and Time : 21/12/2018 12:44 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Matrix Inverse Method using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
import numpy as vAR_np
import tensorflow as vAR_tf
vAR_CSLAB_x_vals = vAR_np.linspace(0, 10, 100)
vAR_CSLAB_y_vals = vAR_CSLAB_x_vals + vAR_np.random.normal(0, 1, 100)
vAR_CSLAB_x_vals_column = vAR_CSLAB_x_vals[:,vAR_np.newaxis]
vAR_CSLAB_ones_column = vAR_np.repeat(1, 100)[:,vAR_np.newaxis]
vAR_CSLAB_A_tensor = vAR_tf.constant([[1.0, 2.0], [3.0, 4.0]])
vAR_CSLAB_b_tensor = vAR_tf.constant([[1.0, 1.0], [0.0, 1.0]])
vAR_CSLAB_tA_A = vAR_tf.matmul(vAR_tf.transpose(vAR_CSLAB_A_tensor), vAR_CSLAB_A_tensor)
vAR_CSLAB_tA_A_inv = vAR_tf.matrix_inverse(vAR_CSLAB_tA_A)
vAR_CSLAB_product = vAR_tf.matmul(vAR_CSLAB_tA_A_inv, vAR_tf.transpose(vAR_CSLAB_A_tensor))
print(vAR_CSLAB_sess.run(vAR_CSLAB_product))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_QUEUES_V1
Purpose : A Program in Python Tensorflow for Queues
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 9:43 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Queues using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_CSLAB_vAR_tf
def simple_shuffle_batch(vAR_source, vAR_capacity, vAR_batch_size=10):
vAR_CSLAB_queue = vAR_tf.RandomShuffleQueue(capacity=vAR_CSLAB_capacity,
min_after_dequeue=int(0.9*vAR_CSLAB_capacity),
shapes=vAR_CSLAB_source.shape, dtypes=vAR_CSLABvAR_CSLAB__sourvAR_CSLAB_ce.dtvAR_ype)
vAR_CSLAB_enqueue = vAR_CSLAB_queue.enqueue(vAR_CSLAB_source)
vAR_CSLAB_num_threads = 4
vAR_CSLAB_qr = vAR_tf.train.QueueRunner(vAR_CSLAB_queue, [vAR_CSLAB_enquvAR_CSLAB_eue] * vAR_CSLAB_nuvAR_CSLAB_m_threads)
# Register the queue runner so it can be found and started by
# <a href="../../api_docs/python/tf/train/start_queue_runners"><code>tf.train.start_queue_runners</code></a> later (the threads are not launched yet).
vAR_tf.train.add_queue_runner(vAR_CSLAB_qr)
return vAR_CSLAB_queue.dequeue_many(vAR_CSLAB_batch_size)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_SAVING_VARIABLES_V1
Purpose : A Program in Python Tensorflow for Saving Variables
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 10:29 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Saving Variables using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_tf.reset_default_graph()
vAR_CSLAB_v1 = vAR_tf.get_variable("v1", shape=[3], initializer=vAR_tf.zeros_initializer)
vAR_CSLAB_v2 = vAR_tf.get_variable("v2", shape=[5], initializer=vAR_tf.zeros_initializer)
vAR_CSLAB_inc_v1 = vAR_CSLAB_v1.assign(vAR_CSLAB_v1+1)
vAR_CSLAB_dec_v2 = vAR_CSLAB_v2.assign(vAR_CSLAB_v2-1)
vAR_CSLAB_init_op = vAR_tf.global_variables_initializer()
vAR_CSLAB_saver = vAR_tf.train.Saver()
with vAR_tf.Session() as vAR_CSLAB_sess:
vAR_CSLAB_sess.run(vAR_CSLAB_init_op)
vAR_CSLAB_inc_v1.op.run()
vAR_CSLAB_dec_v2.op.run()
vAR_CSLAB_save_path = vAR_CSLAB_saver.save(vAR_CSLAB_sess, "/tmp/model.ckpt")
print("Model saved in path: %s" % vAR_CSLAB_save_path)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_RESTORING_VARIABLES_V1
Purpose : A Program in Python Tensorflow for Restoring Variables
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 10:53 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Restoring Variables using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_tf.reset_default_graph()
vAR_CSLAB_v1 = vAR_tf.get_variable("v1", shape=[3], initializer=vAR_tf.zeros_initializer)
vAR_CSLAB_v2 = vAR_tf.get_variable("v2", shape=[5], initializer=vAR_tf.zeros_initializer)
vAR_CSLAB_inc_v1 = vAR_CSLAB_v1.assign(vAR_CSLAB_v1+1)
vAR_CSLAB_dec_v2 = vAR_CSLAB_v2.assign(vAR_CSLAB_v2-1)
vAR_CSLAB_init_op = vAR_tf.global_variables_initializer()
vAR_CSLAB_saver = vAR_tf.train.Saver()
with vAR_tf.Session() as vAR_CSLAB_sess:
vAR_CSLAB_saver.restore(vAR_CSLAB_sess,"/tmp/model.ckpt")
print ("Model restored")
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_TENSORBOARD_V1
Purpose : A Program in Python Tensorflow for Tensorboard
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 11:27 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Tensorboard using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_CSLAB_a = vAR_tf.constant(5)
vAR_CSLAB_b = vAR_tf.placeholder(vAR_tf.int32,shape=[2,2])
vAR_CSLAB_f = vAR_CSLAB_b + vAR_CSLAB_a
with vAR_tf.Session() as sess:
vAR_fetches = [vAR_CSLAB_a,vAR_CSLAB_b]
vAR_outs = sess.run(vAR_fetches,feed_dict={vAR_CSLAB_b:[[4,4],[5,5]]})
vAR_tf.summary.FileWriter('tensorboard/logs',sess.graph)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_NAMESCOPE_V1
Purpose : A Program in Python Tensorflow for Namescopes
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 11:48 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Namescopes using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
with vAR_tf.name_scope("Scope_A"):
vAR_CSLAB_a = vAR_tf.add(1, 2, name="A_add")
#b = tf.mul(a, 3, name="A_mul")
with vAR_tf.name_scope("Scope_B"):
vAR_CSLAB_c = vAR_tf.add(4, 5, name="B_add")
#d = tf.mul(c, 6, name="B_mul")
vAR_CSLAB_e = vAR_tf.add(vAR_CSLAB_a,vAR_CSLAB_c, name="output")
print(vAR_CSLAB_e)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_LINEAR_REGRESSION_V1
Purpose : A Program in Python Tensorflow for Linear Regression
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 12:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Linear Regression using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import numpy as vAR_np
import tensorflow as vAR_tf
import matplotlib.pyplot as vAR_plt
vAR_np.random.seed(101)
vAR_tf.set_random_seed(101)
# Genrating random linear data
# There will be 50 data points ranging from 0 to 50
vAR_CSLAB_x = vAR_np.linspace(0, 50, 50)
vAR_CSLAB_y = vAR_np.linspace(0, 50, 50)
# Adding noise to the random linear data
vAR_CSLAB_x += vAR_np.random.uniform(-4, 4, 50)
vAR_CSLAB_y += vAR_np.random.uniform(-4, 4, 50)
vAR_CSLAB_n = len(vAR_CSLAB_x) # Number of data points
vAR_CSLAB_X = tf.placeholder("float")
vAR_CSLAB_Y = tf.placeholder("float")
vAR_CSLAB_W = tf.Variable(vAR_np.random.randn(), name = "W")
vAR_CSLAB_b = tf.Variable(vAR_np.random.randn(), name = "b")
vAR_CSLAB_learning_rate = 0.01
vAR_CSLAB_training_epochs = 1000
# Hypothesis
vAR_CSLAB_y_pred = vAR_tf.add(vAR_tf.multiply(vAR_CSLAB_X, vAR_CSLAB_W), vAR_CSLAB_b)
# MeanvAR_ Squared Error Cost Function
vAR_CSLAB_cost = vAR_tf.reduce_sum(vAR_tf.pow(vAR_CSLAB_y_pred-vAR_CSLAB_Y, 2)) / (2 * vAR_CSLAB_n)
# Gradient Descent Optimizer
vAR_CSLAB_optimizer = vAR_tf.train.GradientDescentOptimizer(vAR_CSLAB_learning_rate).minimize(vAR_CSLAB_cost)
# Global Variables Initializer
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
# Starting the Tensorflow Session
with vAR_tf.Session() as sess:
# Initializing the Variables
sess.run(vAR_CSLAB_init)
# Iterating through all the epochs
for epoch in range(vAR_CSLAB_training_epochs):
# Feeding each data point into the optimizer using Feed Dictionary
for (_x, _y) in zip(vAR_CSLAB_x, vAR_CSLAB_y):
sess.run(vAR_CSLAB_optimizer, feed_dict = {vAR_CSLAB_X : _x, vAR_CSLAB_Y : _y})
# Displaying the result after every 50 epochs
if (epoch + 1) % 50 == 0:
# Calculating the cost a every epoch
vAR_CSLAB_c = sess.run(vAR_CSLAB_cost, feed_dict = {vAR_CSLAB_X : vAR_CSLAB_x, vAR_CSLAB_Y : vAR_CSLAB_y})
print("Epoch", (epoch + 1), ": vAR_CSLAB_cost =", vAR_CSLAB_c, "W =", sess.run(vAR_CSLAB_W), "b =", sess.run(vAR_CSLAB_b))
# Storing necessary values to be used outside the Session
vAR_CSLAB_training_cost = sess.run(vAR_CSLAB_cost, feed_dict ={vAR_CSLAB_X: vAR_CSLAB_x, vAR_CSLAB_Y: vAR_CSLAB_y})
vAR_CSLAB_weight = sess.run(vAR_CSLAB_W)
vAR_CSLAB_bias = sess.run(vAR_CSLAB_b)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_LOGISTIC_REGRESSION_V1
Purpose : A Program in Python Tensorflow for Logistic Regression
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 13:54 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Logistic Regression using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
import numpy as vAR_np
import tensorflow as vAR_tf
import requests
from sklearn import datasets
from sklearn.preprocessing import normalize
from tensorflow.python.framework import ops
ops.reset_default_graph()
vAR_sess = vAR_tf.Session()
vAR_CSLAB_bc = datasets.load_breast_cancer()
vAR_CSLAB_bc.data.shape
vAR_CSLAB_x_vals = vAR_CSLAB_bc.data
vAR_CSLAB_y_vals = vAR_CSLAB_bc.target
vAR_CSLAB_train_indices = vAR_np.random.choice(len(vAR_CSLAB_x_vals), round(len(vAR_CSLAB_x_vals)*0.8), replace=False)
vAR_CSLAB_test_indices = vAR_np.array(list(set(range(len(vAR_CSLAB_x_vals))) - set(vAR_CSLAB_train_indices)))
vAR_CSLAB_x_vals_train = vAR_CSLAB_x_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_x_vals_test = vAR_CSLAB_x_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_y_vals_train = vAR_CSLAB_y_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_y_vals_test = vAR_CSLAB_y_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_batch_size = 25
vAR_CSLAB_x_data = vAR_tf.placeholder(shape=[None, 30], dtype=vAR_tf.float32)
vAR_CSLAB_y_target = vAR_tf.placeholder(shape=[None, 1], dtype=vAR_tf.float32)
vAR_CSLAB_A = vAR_tf.Variable(vAR_tf.random_normal(shape=[30,1]))
vAR_CSLAB_b = vAR_tf.Variable(vAR_tf.random_normal(shape=[1,1]))
vAR_CSLAB_model_output = vAR_tf.add(vAR_tf.matmul(vAR_CSLAB_x_data, vAR_CSLAB_A), vAR_CSLAB_b)
vAR_CSLAB_loss = vAR_tf.reduce_mean(vAR_tf.nn.sigmoid_cross_entropy_with_logits(logits=vAR_CSLAB_model_output, labels=vAR_CSLAB_y_target))
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
vAR_sess.run(vAR_CSLAB_init)
vAR_CSLAB_my_opt = vAR_tf.train.GradientDescentOptimizer(0.01)
vAR_CSLAB_train_step = vAR_CSLAB_my_opt.minimize(vAR_CSLAB_loss)
vAR_CSLAB_prediction = vAR_tf.round(vAR_tf.sigmoid(vAR_CSLAB_model_output))
vAR_CSLAB_predictions_correct = vAR_tf.cast(vAR_tf.equal(vAR_CSLAB_prediction, vAR_CSLAB_y_target), vAR_tf.float32)
vAR_CSLAB_accuracy = vAR_tf.reduce_mean(vAR_CSLAB_predictions_correct)
vAR_CSLAB_loss_vec = []
vAR_CSLAB_train_acc = []
vAR_CSLAB_test_acc = []
vAR_CSLAB_loss_vec = []
vAR_CSLAB_train_acc = []
vAR_CSLAB_test_acc = []
for i in range(2000):
vAR_CSLAB_rand_index = vAR_np.random.choice(len(vAR_CSLAB_x_vals_train), size=vAR_CSLAB_batch_size)
vAR_CSLAB_rand_x = vAR_CSLAB_x_vals_train[vAR_CSLAB_rand_index]
vAR_CSLAB_rand_y = vAR_np.transpose([vAR_CSLAB_y_vals_train[vAR_CSLAB_rand_index]])
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_temp_loss = vAR_sess.run(vAR_CSLAB_loss, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_loss_vec.append(vAR_CSLAB_temp_loss)
vAR_CSLAB_temp_acc_train = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_vals_train, vAR_CSLAB_y_target: vAR_np.transpose([vAR_CSLAB_y_vals_train])})
vAR_CSLAB_train_acc.append(vAR_CSLAB_temp_acc_train)
vAR_CSLAB_temp_acc_test = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_vals_test, vAR_CSLAB_y_target: vAR_np.transpose([vAR_CSLAB_y_vals_test])})
vAR_CSLAB_test_acc.append(int(vAR_CSLAB_temp_acc_test))
print((vAR_CSLAB_temp_acc_test))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_RANDOM_FOREST_V1
Purpose : A Program in Python Tensorflow for Random Forest
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 15:25 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Random Forest using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
from __future__ import print_function
import numpy as vAR_np
import sklearn
from sklearn import datasets
import pandas as vAR_pd
import tensorflow as vAR_tf
#from tensorflow.contrib.tensor_forest.python import tensor_forest
from tensorflow.python.ops import resources
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_DATA = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_245_TENSORFLOW_RF']
vAR_CSLAB_data = vAR_pd.read_csv(vAR_CSLAB_DATA)
vAR_CSLAB_input_x = vAR_CSLAB_data.iloc[:, 0:-1].values
vAR_CSLAB_input_y = vAR_CSLAB_data.iloc[:,4].values
from sklearn.model_selection import train_test_split
vAR_CSLAB_X_train, vAR_CSLAB_X_test, vAR_CSLAB_y_train, vAR_CSLAB_y_test = train_test_split(vAR_CSLAB_input_x, vAR_CSLAB_input_y, test_size = 0.25, random_state = 0)
vAR_CSLAB_data1 = vAR_CSLAB_data.iloc[:,:].values
# Parameters
vAR_CSLAB_num_steps = 100 # Total steps to train
vAR_CSLAB_num_classes = 2
vAR_CSLAB_num_features = 108
vAR_CSLAB_num_trees = 10
vAR_CSLAB_max_nodes = 1000
# Input and Target placeholders
vAR_CSLAB_X = vAR_tf.placeholder(vAR_tf.float32, shape=[None, vAR_CSLAB_num_features])
vAR_CSLAB_Y = vAR_tf.placeholder(vAR_tf.int64, shape=[None])
print(vAR_CSLAB_X)
print(vAR_CSLAB_Y)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_KMEANS_CLUSTERING_V1
Purpose : A Program in Python Tensorflow for Kmeans Clustering
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 16:48 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Kmeans Clustering using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
import numpy as vAR_np
vAR_CSLAB_seed = 700
def vAR_CSLAB_create_samples(vAR_CSLAB_n_clusters, vAR_CSLAB_n_samples_per_cluster, vAR_CSLAB_n_features, vAR_CSLAB_embiggen_factor, vAR_CSLAB_seed):
vAR_np.random.seed(vAR_CSLAB_seed)
vAR_CSLAB_slices = []
vAR_CSLAB_centroids = []
# Create samples for each cluster
for i in range(vAR_CSLAB_n_clusters):
vAR_CSLAB_samples = vAR_tf.random_normal((vAR_CSLAB_n_samples_per_cluster, vAR_CSLAB_n_features),
mean=0.0, stddev=5.0, dtype=vAR_tf.float32, seed=vAR_CSLAB_seed, name="cluster_{}".format(i))
vAR_CSLAB_current_centroid = (vAR_np.random.random((1, vAR_CSLAB_n_features)) * vAR_CSLAB_embiggen_factor) - (vAR_CSLAB_embiggen_factor/2)
vAR_CSLAB_centroids.append(vAR_CSLAB_current_centroid)
vAR_CSLAB_samples += vAR_CSLAB_current_centroid
vAR_CSLAB_slices.append(vAR_CSLAB_samples)
# Create a big "samples" dataset
vAR_CSLAB_samples = vAR_tf.concat(vAR_CSLAB_slices, 0, name='samples')
vAR_CSLAB_centroids = vAR_tf.concat(vAR_CSLAB_centroids, 0, name='centroids')
return vAR_CSLAB_centroids, vAR_CSLAB_samples
import matplotlib.pyplot as vAR_plt
%matplotlib inline
def vAR_CSLAB_plot_clusters(vAR_CSLAB_all_samples, vAR_CSLAB_centroids, vAR_CSLAB_n_samples_per_cluster):
#Plot out the different clusters
#Choose a different colour for each cluster
vAR_CSLAB_colour = vAR_plt.cm.rainbow(vAR_np.linspace(0,1,len(vAR_CSLAB_centroids)))
for i, vAR_CSLAB_centroid in enumerate(vAR_CSLAB_centroids):
vAR_CSLAB_samples = vAR_CSLAB_all_samples[i*vAR_CSLAB_n_samples_per_cluster:(i+1)*vAR_CSLAB_n_samples_per_cluster]
vAR_plt.scatter(vAR_CSLAB_samples[:,0], vAR_CSLAB_samples[:,1], c=vAR_CSLAB_colour[i])
#Grab just the samples fpr the given cluster and plot them out with a new colour
#Also plot centroid
vAR_plt.plot(vAR_CSLAB_centroid[0], vAR_CSLAB_centroid[1], markersize=35, marker="x", color='k', mew=10)
vAR_plt.plot(vAR_CSLAB_centroid[0], vAR_CSLAB_centroid[1], markersize=30, marker="x", color='m', mew=5)
vAR_plt.show()
vAR_CSLAB_n_features = 2
vAR_CSLAB_n_clusters = 3
vAR_CSLAB_n_samples_per_cluster = 500
vAR_CSLAB_vAR_CSLAB_seed = 700
vAR_CSLAB_embiggen_factor = 70
vAR_CSLAB_centroids, vAR_CSLAB_samples = vAR_CSLAB_create_samples(vAR_CSLAB_n_clusters, vAR_CSLAB_n_samples_per_cluster, vAR_CSLAB_n_features, vAR_CSLAB_embiggen_factor, vAR_CSLAB_seed)
vAR_CSLAB_model = vAR_tf.global_variables_initializer()
with vAR_tf.Session() as session:
vAR_CSLAB_sample_values = session.run(vAR_CSLAB_samples)
vAR_CSLAB_centroid_values = session.run(vAR_CSLAB_centroids)
vAR_CSLAB_plot_clusters(vAR_CSLAB_sample_values, vAR_CSLAB_centroid_values, vAR_CSLAB_n_samples_per_cluster)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_LINEAR_SUPPORT_VECTOR_MACHINE_V1
Purpose : A Program in Python Tensorflow for Linear Support Vector Machine
Author : DeepSphere.AI, Inc.
Date and Time : 24/12/2018 17:54 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Linear Support Vector Machine using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
%matplotlib inline
import numpy as vAR_np
import tensorflow as vAR_tf
from sklearn import datasets
vAR_sess = vAR_tf.Session()
vAR_CSLAB_iris = datasets.load_iris()
vAR_CSLAB_x_vals = vAR_np.array([[x[0], x[3]] for x in vAR_CSLAB_iris.data])
vAR_CSLAB_y_vals = vAR_np.array([1 if y==0 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_train_indices = vAR_np.random.choice(len(vAR_CSLAB_x_vals), round(len(vAR_CSLAB_x_vals)*0.8), replace=False)
vAR_CSLAB_test_indices = vAR_np.array(list(set(range(len(vAR_CSLAB_x_vals))) - set(vAR_CSLAB_train_indices)))
vAR_CSLAB_x_vals_train = vAR_CSLAB_x_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_x_vals_test = vAR_CSLAB_x_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_y_vals_train = vAR_CSLAB_y_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_y_vals_test = vAR_CSLAB_y_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_batch_size = 100
vAR_CSLAB_x_data = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_y_target = vAR_tf.placeholder(shape=[None, 1], dtype=vAR_tf.float32)
vAR_CSLAB_A = vAR_tf.Variable(vAR_tf.random_normal(shape=[2,1]))
vAR_CSLAB_b = vAR_tf.Variable(vAR_tf.random_normal(shape=[1,1]))
vAR_CSLAB_model_output = vAR_tf.subtract(vAR_tf.matmul(vAR_CSLAB_x_data, vAR_CSLAB_A), vAR_CSLAB_b)
vAR_CSLAB_l2_norm = vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_A))
vAR_CSLAB_alpha = vAR_tf.constant([0.1])
vAR_CSLAB_classification_term = vAR_tf.reduce_mean(vAR_tf.maximum(0., vAR_tf.subtract(1., vAR_tf.multiply(vAR_CSLAB_model_output, vAR_CSLAB_y_target))))
vAR_CSLAB_loss = vAR_tf.add(vAR_CSLAB_classification_term, vAR_tf.multiply(vAR_CSLAB_alpha, vAR_CSLAB_l2_norm))
vAR_CSLAB_prediction = vAR_tf.sign(vAR_CSLAB_model_output)
vAR_CSLAB_accuracy = vAR_tf.reduce_mean(vAR_tf.cast(vAR_tf.equal(vAR_CSLAB_prediction, vAR_CSLAB_y_target), vAR_tf.float32))
vAR_CSLAB_my_opt = vAR_tf.train.GradientDescentOptimizer(0.01)
vAR_CSLAB_train_step = vAR_CSLAB_my_opt.minimize(vAR_CSLAB_loss)
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
vAR_sess.run(vAR_CSLAB_init)
vAR_CSLAB_loss_vec = []
vAR_CSLAB_train_accuracy = []
vAR_CSLAB_test_accuracy = []
vAR_CSLAB_batch_size=25
for i in range(5000):
vAR_CSLAB_rand_index = vAR_np.random.choice(len(vAR_CSLAB_x_vals_train), size=vAR_CSLAB_batch_size)
vAR_CSLAB_rand_x = vAR_CSLAB_x_vals_train[vAR_CSLAB_rand_index]
vAR_CSLAB_rand_y = vAR_np.transpose([vAR_CSLAB_y_vals_train[vAR_CSLAB_rand_index]])
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_temp_loss = vAR_sess.run(vAR_CSLAB_loss, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_loss_vec.append(vAR_CSLAB_temp_loss)
vAR_CSLAB_train_acc_temp = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_vals_train, vAR_CSLAB_y_target: vAR_np.transpose([vAR_CSLAB_y_vals_train])})
vAR_CSLAB_train_accuracy.append(vAR_CSLAB_train_acc_temp)
vAR_CSLAB_test_acc_temp = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_vals_test, vAR_CSLAB_y_target: vAR_np.transpose([vAR_CSLAB_y_vals_test])})
vAR_CSLAB_test_accuracy.append(vAR_CSLAB_test_acc_temp)
if (i+1)%100==0:
print('Step #' + str(i+1) + ' A = ' + str(vAR_sess.run(vAR_CSLAB_A)) + ' b = ' + str(vAR_sess.run(vAR_CSLAB_b)))
print('Loss = ' + str(vAR_CSLAB_temp_loss))
[[vAR_CSLAB_a1], [vAR_CSLAB_a2]] = vAR_sess.run(vAR_CSLAB_A)
[[vAR_CSLAB_b]] = vAR_sess.run(vAR_CSLAB_b)
vAR_CSLAB_slope = -vAR_CSLAB_a2/vAR_CSLAB_a1
vAR_CSLAB_y_intercept = vAR_CSLAB_b/vAR_CSLAB_a1
vAR_CSLAB_x1_vals = [d[1] for d in x_vals]
vAR_CSLAB_best_fit = []
for i in vAR_CSLAB_x1_vals:
vAR_CSLAB_best_fit.append(vAR_CSLAB_slope*i+vAR_CSLAB_y_intercept)
vAR_CSLAB_setosa_x = [d[1] for i,d in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==1]
vAR_CSLAB_setosa_y = [d[0] for i,d in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==1]
vAR_CSLAB_not_setosa_x = [d[1] for i,d in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==-1]
vAR_CSLAB_not_setosa_y = [d[0] for i,d in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==-1]
vAR_plt.plot(vAR_CSLAB_setosa_x, vAR_CSLAB_setosa_y, 'o', label='I. setosa')
vAR_plt.plot(vAR_CSLAB_not_setosa_x, vAR_CSLAB_not_setosa_y, 'x', label='Non-setosa')
vAR_plt.plot(vAR_CSLAB_x1_vals, vAR_CSLAB_best_fit, 'r-', label='Linear Separator', linewidth=3)
vAR_plt.ylim([0, 10])
vAR_plt.legend(loc='lower right')
vAR_plt.title('Sepal Length vs Pedal Width')
vAR_plt.xlabel('Pedal Width')
vAR_plt.ylabel('Sepal Length')
vAR_plt.show()
vAR_plt.plot(vAR_CSLAB_train_accuracy, 'k-', label='Training Accuracy')
vAR_plt.plot(vAR_CSLAB_test_accuracy, 'r--', label='Test Accuracy')
vAR_plt.title('Train and Test Set Accuracies')
vAR_plt.xlabel('Generation')
vAR_plt.ylabel('Accuracy')
vAR_plt.legend(loc='lower right')
vAR_plt.show()
vAR_plt.plot(vAR_CSLAB_loss_vec, 'k-')
vAR_plt.title('Loss per Generation')
vAR_plt.xlabel('Generation')
vAR_plt.ylabel('Loss')
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_NON_LINEAR_SUPPORT_VECTOR_MACHINE_V1
Purpose : A Program in Python Tensorflow for Linear Support Vector Machine
Author : DeepSphere.AI, Inc.
Date and Time : 26/12/2018 9:42 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Linear Support Vector Machine using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
%matplotlib inline
import numpy as vAR_np
import tensorflow as vAR_tf
from sklearn import datasets
vAR_sess = vAR_tf.Session()
vAR_CSLAB_iris = datasets.load_iris()
vAR_CSLAB_x_vals = vAR_np.array([[x[0], x[3]] for x in vAR_CSLAB_iris.data])
vAR_CSLAB_y_vals = vAR_np.array([1 if y==0 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_train_indices = vAR_np.random.choice(len(vAR_CSLAB_x_vals), round(len(vAR_CSLAB_x_vals)*0.8), replace=False)
vAR_CSLAB_test_indices = vAR_np.array(list(set(range(len(vAR_CSLAB_x_vals))) - set(vAR_CSLAB_train_indices)))
vAR_CSLAB_x_vals_train = vAR_CSLAB_x_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_x_vals_test = vAR_CSLAB_x_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_y_vals_train = vAR_CSLAB_y_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_y_vals_test = vAR_CSLAB_y_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_batch_size = 101
vAR_CSLAB_x_data = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_y_target = vAR_tf.placeholder(shape=[None, 1], dtype=vAR_tf.float32)
vAR_CSLAB_prediction_grid = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_b = vAR_tf.Variable(vAR_tf.random_normal(shape=[1,vAR_CSLAB_batch_size]))
#Gaussian kernel
vAR_CSLAB_gamma = vAR_tf.constant(-50.0)
vAR_CSLAB_dist = vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_x_data), 1)
vAR_CSLAB_dist = vAR_tf.reshape(vAR_CSLAB_dist, [-1,1])
vAR_CSLAB_sq_dists = vAR_tf.add(vAR_tf.subtract(vAR_CSLAB_dist, vAR_tf.multiply(2., vAR_tf.matmul(vAR_CSLAB_x_data, vAR_tf.transpose(vAR_CSLAB_x_data)))), vAR_tf.transpose(vAR_CSLAB_dist))
vAR_CSLAB_my_kernel = vAR_tf.exp(vAR_tf.multiply(vAR_CSLAB_gamma, vAR_tf.abs(vAR_CSLAB_sq_dists)))
vAR_CSLAB_model_output = vAR_tf.matmul(vAR_CSLAB_b, vAR_CSLAB_my_kernel)
vAR_CSLAB_first_term = vAR_tf.reduce_sum(vAR_CSLAB_b)
vAR_CSLAB_b_vec_cross = vAR_tf.matmul(vAR_tf.transpose(vAR_CSLAB_b), vAR_CSLAB_b)
vAR_CSLAB_y_target_cross = vAR_tf.matmul(vAR_CSLAB_y_target, vAR_tf.transpose(vAR_CSLAB_y_target))
vAR_CSLAB_second_term = vAR_tf.reduce_sum(vAR_tf.multiply(vAR_CSLAB_my_kernel, vAR_tf.multiply(vAR_CSLAB_b_vec_cross, vAR_CSLAB_y_target_cross)))
vAR_CSLAB_loss = vAR_tf.negative(vAR_tf.subtract(vAR_CSLAB_first_term, vAR_CSLAB_second_term))
vAR_CSLAB_rA = vAR_tf.reshape(vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_x_data), 1),[-1,1])
vAR_CSLAB_rB = vAR_tf.reshape(vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_prediction_grid), 1),[-1,1])
vAR_CSLAB_pred_sq_dist = vAR_tf.add(vAR_tf.subtract(vAR_CSLAB_rA, vAR_tf.multiply(2., vAR_tf.matmul(vAR_CSLAB_x_data, vAR_tf.transpose(vAR_CSLAB_prediction_grid)))), vAR_tf.transpose(vAR_CSLAB_rB))
vAR_CSLAB_pred_kernel = vAR_tf.exp(vAR_tf.multiply(vAR_CSLAB_gamma, vAR_tf.abs(vAR_CSLAB_pred_sq_dist)))
vAR_CSLAB_prediction_output = vAR_tf.matmul(vAR_tf.multiply(vAR_tf.transpose(vAR_CSLAB_y_target),vAR_CSLAB_b), vAR_CSLAB_pred_kernel)
vAR_CSLAB_prediction = vAR_tf.sign(vAR_CSLAB_prediction_output-vAR_tf.reduce_mean(vAR_CSLAB_prediction_output))
vAR_CSLAB_accuracy = vAR_tf.reduce_mean(vAR_tf.cast(vAR_tf.equal(vAR_tf.squeeze(vAR_CSLAB_prediction), vAR_tf.squeeze(vAR_CSLAB_y_target)), vAR_tf.float32))
vAR_CSLAB_my_opt = vAR_tf.train.GradientDescentOptimizer(0.001)
vAR_CSLAB_train_step = vAR_CSLAB_my_opt.minimize(vAR_CSLAB_loss)
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
vAR_sess.run(vAR_CSLAB_init)
vAR_CSLAB_loss_vec = []
vAR_CSLAB_batch_accuracy = []
for i in range(500):
vAR_CSLAB_rand_index = vAR_np.random.choice(len(vAR_CSLAB_x_vals_train), size=vAR_CSLAB_batch_size)
vAR_CSLAB_rand_x = vAR_CSLAB_x_vals_train[vAR_CSLAB_rand_index]
vAR_CSLAB_rand_y = vAR_np.transpose([vAR_CSLAB_y_vals_train[vAR_CSLAB_rand_index]])
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_temp_loss = vAR_sess.run(vAR_CSLAB_loss, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_loss_vec.append(vAR_CSLAB_temp_loss)
vAR_CSLAB_acc_temp = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x,vAR_CSLAB_y_target: vAR_CSLAB_rand_y,vAR_CSLAB_prediction_grid:vAR_CSLAB_rand_x})
vAR_CSLAB_batch_accuracy.append(vAR_CSLAB_acc_temp)
if (i+1)%100==0:
print('Step #' + str(i+1))
print('Loss = ' + str(vAR_CSLAB_temp_loss))
vAR_CSLAB_x_min, vAR_CSLAB_x_max = vAR_CSLAB_x_vals[:, 0].min() - 1, vAR_CSLAB_x_vals[:, 0].max() + 1
vAR_CSLAB_y_min, vAR_CSLAB_y_max = vAR_CSLAB_x_vals[:, 1].min() - 1, vAR_CSLAB_x_vals[:, 1].max() + 1
vAR_CSLAB_xx, vAR_CSLAB_yy = vAR_np.meshgrid(vAR_np.arange(vAR_CSLAB_x_min, vAR_CSLAB_x_max, 0.02),vAR_np.arange(vAR_CSLAB_y_min, vAR_CSLAB_y_max, 0.02))
vAR_CSLAB_grid_points = vAR_np.c_[vAR_CSLAB_xx.ravel(), vAR_CSLAB_yy.ravel()]
[vAR_CSLAB_grid_predictions] = vAR_sess.run(vAR_CSLAB_prediction, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y,vAR_CSLAB_prediction_grid: vAR_CSLAB_grid_points})
vAR_CSLAB_grid_predictions = vAR_CSLAB_grid_predictions.reshape(vAR_CSLAB_xx.shape)
(vAR_CSLAB_x_vals, vAR_CSLAB_y_vals) = datasets.make_circles(n_samples=1500, factor=.5, noise=.1)
vAR_CSLAB_y_vals = vAR_np.array([1 if y==1 else -1 for y in vAR_CSLAB_y_vals])
vAR_CSLAB_class1_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==1]
vAR_CSLAB_class1_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==1]
vAR_CSLAB_class2_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==-1]
vAR_CSLAB_class2_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==-1]
vAR_plt.contourf(vAR_CSLAB_xx, vAR_CSLAB_yy, vAR_CSLAB_grid_predictions, cmap=vAR_plt.cm.Paired, alpha=0.8)
vAR_plt.plot(vAR_CSLAB_class1_x, vAR_CSLAB_class1_y, 'ro', label='Class 1')
vAR_plt.plot(vAR_CSLAB_class2_x, vAR_CSLAB_class1_y, 'kx', label='Class -1')
vAR_plt.legend(loc='lower right')
vAR_plt.ylim([-1.5, 1.5])
vAR_plt.xlim([-1.5, 1.5])
vAR_plt.show()
vAR_plt.plot(vAR_CSLAB_batch_accuracy, 'k-', label='Accuracy')
vAR_plt.title('Batch Accuracy')
vAR_plt.xlabel('Generation')
vAR_plt.ylabel('Accuracy')
vAR_plt.legend(loc='lower right')
vAR_plt.show()
vAR_plt.plot(vAR_CSLAB_loss_vec, 'k-')
vAR_plt.title('Loss per Generation')
vAR_plt.xlabel('Generation')
vAR_plt.ylabel('Loss')
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_MULTI_CLASS_SUPPORT_VECTOR_MACHINE_V1
Purpose : A Program in Python Tensorflow for Multiclass Support Vector Machine
Author : DeepSphere.AI, Inc.
Date and Time : 26/12/2018 10:58 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Multiclass Support Vector Machine using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
%matplotlib inline
import numpy as vAR_np
import tensorflow as vAR_tf
from sklearn import datasets
vAR_CSLAB_iris = datasets.load_iris()
vAR_CSLAB_x_vals = vAR_np.array([[x[0], x[3]] for x in vAR_CSLAB_iris.data])
vAR_CSLAB_y_vals1 = vAR_np.array([1 if y==0 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_y_vals2 = vAR_np.array([1 if y==1 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_y_vals3 = vAR_np.array([1 if y==2 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_y_vals = vAR_np.array([vAR_CSLAB_y_vals1, vAR_CSLAB_y_vals2, vAR_CSLAB_y_vals3])
vAR_CSLAB_class1_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==0]
vAR_CSLAB_class1_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==0]
vAR_CSLAB_class2_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==1]
vAR_CSLAB_class2_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==1]
vAR_CSLAB_class3_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==2]
vAR_CSLAB_class3_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==2]
vAR_CSLAB_batch_size = 50
vAR_CSLAB_x_data = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_y_target = vAR_tf.placeholder(shape=[3, None], dtype=vAR_tf.float32)
vAR_CSLAB_prediction_grid = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_b = vAR_tf.Variable(vAR_tf.random_normal(shape=[3,vAR_CSLAB_batch_size]))
vAR_CSLAB_gamma = vAR_tf.constant(-10.0)
vAR_CSLAB_dist = vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_x_data), 1)
vAR_CSLAB_dist = vAR_tf.reshape(vAR_CSLAB_dist, [-1,1])
vAR_CSLAB_sq_dists = vAR_tf.add(vAR_tf.subtract(vAR_CSLAB_dist, vAR_tf.multiply(2., vAR_tf.matmul(vAR_CSLAB_x_data, vAR_tf.transpose(vAR_CSLAB_x_data)))), vAR_tf.transpose(vAR_CSLAB_dist))
vAR_CSLAB_my_kernel = vAR_tf.exp(vAR_tf.multiply(vAR_CSLAB_gamma, vAR_tf.abs(vAR_CSLAB_sq_dists)))
def vAR_CSLAB_reshape_matmul(mat):
vAR_CSLAB_v1 = vAR_tf.expand_dims(mat, 1)
vAR_CSLAB_v2 = vAR_tf.reshape(vAR_CSLAB_v1, [3, vAR_CSLAB_batch_size, 1])
return(vAR_tf.batch_matmul(vAR_CSLAB_v2, vAR_CSLAB_v1))
vAR_CSLAB_model_output = vAR_tf.matmul(vAR_CSLAB_b, vAR_CSLAB_my_kernel)
vAR_CSLAB_first_term = vAR_tf.reduce_sum(vAR_CSLAB_b)
vAR_CSLAB_b_vec_cross = vAR_tf.matmul(vAR_tf.transpose(vAR_CSLAB_b), vAR_CSLAB_b)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_NEAREST_NEIGHBOURS_V1
Purpose : A Program in Python Tensorflow for Nearest Neighbours
Author : DeepSphere.AI, Inc.
Date and Time : 26/12/2018 11:47 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Nearest Neighbours using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import numpy as vAR_np
import tensorflow as vAR_tf
from tensorflow.examples.tutorials.mnist import input_data
vAR_CSLAB_mnist = input_data.read_data_sets("mnist", one_hot=True)
vAR_CSLAB_mnist.train.images.shape
vAR_CSLAB_Xtr, vAR_CSLAB_Ytr = vAR_CSLAB_mnist.train.next_batch(5000) #5000 for training (nn candidates)
vAR_CSLAB_Xte, vAR_CSLAB_Yte = vAR_CSLAB_mnist.test.next_batch(200) #200 for testing
vAR_CSLAB_xtr = vAR_tf.placeholder("float", [None, 784])
vAR_CSLAB_xte = vAR_tf.placeholder("float", [784])
vAR_CSLAB_distance = vAR_tf.reduce_sum(vAR_tf.abs(vAR_tf.add(vAR_CSLAB_xtr, vAR_tf.negative(vAR_CSLAB_xte))), reduction_indices=1)
vAR_CSLAB_pred = vAR_tf.arg_min(vAR_CSLAB_distance, 0)
vAR_CSLAB_accuracy = 0.
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
with vAR_tf.Session() as vAR_sess:
vAR_sess.run(vAR_CSLAB_init)
for i in range(len(vAR_CSLAB_Xte)):
#Get nearest neighbor
vAR_CSLAB_nn_index = vAR_sess.run(vAR_CSLAB_pred, feed_dict={vAR_CSLAB_xtr: vAR_CSLAB_Xtr, vAR_CSLAB_xte:vAR_CSLAB_Xte[i ,:]})
print ("Test", i, "Prediction:", vAR_np.argmax(vAR_CSLAB_Ytr[vAR_CSLAB_nn_index]), "True Class:", vAR_np.argmax(vAR_CSLAB_Yte[i]))
if vAR_np.argmax(vAR_CSLAB_Ytr[vAR_CSLAB_nn_index]) == vAR_np.argmax(vAR_CSLAB_Yte[i]):
vAR_CSLAB_accuracy += 1./len(vAR_CSLAB_Xte)
print ('Done')
print ("Accuracy : ", vAR_CSLAB_accuracy)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_NEURAL_NETWORKS_V1
Purpose : A Program in Python Tensorflow for Neural Networks
Author : DeepSphere.AI, Inc.
Date and Time : 26/12/2018 12:32 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Neural Networks using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_sess = vAR_tf.Session()
vAR_CSLAB_a = vAR_tf.Variable(vAR_tf.constant(4.))
vAR_CSLAB_x_val = 5.
vAR_CSLAB_x_data = vAR_tf.placeholder(dtype=vAR_tf.float32)
vAR_CSLAB_multiplication = vAR_tf.multiply(vAR_CSLAB_a, vAR_CSLAB_x_data)
vAR_CSLAB_loss = vAR_tf.square(vAR_tf.subtract(vAR_CSLAB_multiplication, 50.))
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
vAR_sess.run(vAR_CSLAB_init)
vAR_CSLAB_my_opt = vAR_tf.train.GradientDescentOptimizer(0.01)
vAR_CSLAB_train_step = vAR_CSLAB_my_opt.minimize(vAR_CSLAB_loss)
print('Optimizing a Multiplication Gate Output to 50.')
for i in range(10):
vAR_CSLAB_a_val_old = vAR_sess.run(vAR_CSLAB_a)
print(vAR_CSLAB_a_val_old)
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_val})
vAR_CSLAB_a_val = vAR_sess.run(vAR_CSLAB_a)
vAR_CSLAB_mult_output = vAR_sess.run(vAR_CSLAB_multiplication, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_val})
print(str(vAR_CSLAB_a_val) + ' * ' + str(vAR_CSLAB_x_val) + ' = ' + str(vAR_CSLAB_mult_output))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_CONVOLUTIONAL_NEURAL_NETWORKS_V1
Purpose : A Program in Python Tensorflow for Convolutional Neural Networks
Author : DeepSphere.AI, Inc.
Date and Time : 26/12/2018 13:57 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Convolutional Neural Networks using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
import numpy as vAR_np
import tensorflow as vAR_tf
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.python.framework import ops
ops.reset_default_graph()
vAR_sess = vAR_tf.Session()
vAR_CSLAB_mnist = input_data.read_data_sets("mnist", one_hot=True)
vAR_CSLAB_train_xdata = vAR_np.array([vAR_np.reshape(x, (28,28)) for x in vAR_CSLAB_mnist.train.images])
vAR_CSLAB_test_xdata = vAR_np.array([vAR_np.reshape(x, (28,28)) for x in vAR_CSLAB_mnist.test.images])
vAR_CSLAB_train_labels = vAR_CSLAB_mnist.train.labels
vAR_CSLAB_vAR_CSLAB_test_labels = vAR_CSLAB_mnist.test.labels
vAR_CSLAB_batch_size = 100
vAR_CSLAB_learning_rate = 0.005
vAR_CSLAB_evaluation_size = 500
vAR_CSLAB_image_width = vAR_CSLAB_train_xdata[0].shape[0] # 28
vAR_CSLAB_image_height = vAR_CSLAB_train_xdata[0].shape[1] # 28
vAR_CSLAB_target_size = vAR_CSLAB_train_labels + 1
vAR_CSLAB_num_channels = 1 # greyscale = 1 channel
vAR_CSLAB_generations = 500 #total num of iterations
vAR_CSLAB_eval_every = 5 #show status after every 5 iteration
vAR_CSLAB_conv1_features = 25
vAR_CSLAB_conv2_features = 50
vAR_CSLAB_max_pool_size1 = 2 # NxN window for 1st max pool layer
vAR_CSLAB_max_pool_size2 = 2 # NxN window for 2nd max pool layer
vAR_CSLAB_fully_connected_size1 = 100
vAR_CSLAB_x_input_shape = (vAR_CSLAB_batch_size, vAR_CSLAB_image_width, vAR_CSLAB_image_height, vAR_CSLAB_num_channels)
vAR_CSLAB_x_input = vAR_tf.placeholder(vAR_tf.float32, shape=vAR_CSLAB_x_input_shape)
vAR_CSLAB_y_target = vAR_tf.placeholder(vAR_tf.int32, shape=(vAR_CSLAB_batch_size))
vAR_CSLAB_eval_input_shape = (vAR_CSLAB_evaluation_size, vAR_CSLAB_image_width, vAR_CSLAB_image_height, vAR_CSLAB_num_channels)
vAR_CSLAB_eval_input = vAR_tf.placeholder(vAR_tf.float32, shape=vAR_CSLAB_eval_input_shape)
vAR_CSLAB_eval_target = vAR_tf.placeholder(vAR_tf.int32, shape=(vAR_CSLAB_evaluation_size))
vAR_CSLAB_conv1_weight = vAR_tf.Variable(vAR_tf.truncated_normal([4, 4, vAR_CSLAB_num_channels, vAR_CSLAB_conv1_features],stddev=0.1, dtype=vAR_tf.float32))
vAR_CSLAB_conv1_bias = vAR_tf.Variable(vAR_tf.zeros([vAR_CSLAB_conv1_features], dtype=vAR_tf.float32))
vAR_CSLAB_conv2_weight = vAR_tf.Variable(vAR_tf.truncated_normal([4, 4, vAR_CSLAB_conv1_features, vAR_CSLAB_conv2_features],stddev=0.1, dtype=vAR_tf.float32))
vAR_CSLAB_conv2_bias = vAR_tf.Variable(vAR_tf.zeros([vAR_CSLAB_conv2_features], dtype=vAR_tf.float32))
vAR_CSLAB_resulting_width = vAR_CSLAB_image_width // (vAR_CSLAB_max_pool_size1 * vAR_CSLAB_max_pool_size2)
vAR_CSLAB_resulting_height = vAR_CSLAB_image_height // (vAR_CSLAB_max_pool_size1 * vAR_CSLAB_max_pool_size2)
vAR_CSLAB_full1_input_size = vAR_CSLAB_resulting_width * vAR_CSLAB_resulting_height * vAR_CSLAB_conv2_features
vAR_CSLAB_full1_weight = vAR_tf.Variable(vAR_tf.truncated_normal([vAR_CSLAB_full1_input_size, vAR_CSLAB_fully_connected_size1],stddev=0.1, dtype=vAR_tf.float32))
vAR_CSLAB_full1_bias = vAR_tf.Variable(vAR_tf.truncated_normal([vAR_CSLAB_fully_connected_size1], stddev=0.1, dtype=vAR_tf.float32))
vAR_CSLAB_full2_weight = vAR_tf.Variable(vAR_tf.truncated_normal([vAR_CSLAB_full1_input_size, vAR_CSLAB_fully_connected_size1],stddev=0.1, dtype=vAR_tf.float32))
vAR_CSLAB_full2_bias = vAR_tf.Variable(vAR_tf.truncated_normal([vAR_CSLAB_fully_connected_size1], stddev=0.1, dtype=vAR_tf.float32))
def vAR_CSLAB_my_conv_net(vAR_CSLAB_input_data):
# First Conv-ReLU-MaxPool Layer
vAR_CSLAB_conv1 = vAR_tf.nn.conv2d(vAR_CSLAB_input_data, vAR_CSLAB_conv1_weight, strides=[1, 1, 1, 1], padding='SAME')
vAR_CSLAB_relu1 = vAR_tf.nn.relu(vAR_tf.nn.bias_add(vAR_CSLAB_conv1, vAR_CSLAB_conv1_bias))
vAR_CSLAB_max_pool1 = vAR_tf.nn.max_pool(vAR_CSLAB_relu1, ksize=[1, vAR_CSLAB_max_pool_size1, vAR_CSLAB_max_pool_size1, 1],strides=[1, vAR_CSLAB_max_pool_size1, vAR_CSLAB_max_pool_size1, 1], padding='SAME')
# Second Conv-ReLU-MaxPool Layer
vAR_CSLAB_conv2 = vAR_tf.nn.conv2d(vAR_CSLAB_max_pool1, vAR_CSLAB_conv2_weight, strides=[1, 1, 1, 1], padding='SAME')
vAR_CSLAB_relu2 = vAR_tf.nn.relu(vAR_tf.nn.bias_add(vAR_CSLAB_conv2, vAR_CSLAB_conv2_bias))
vAR_CSLAB_max_pool2 = vAR_tf.nn.max_pool(vAR_CSLAB_relu2, ksize=[1, vAR_CSLAB_max_pool_size2, vAR_CSLAB_max_pool_size2, 1],strides=[1, vAR_CSLAB_max_pool_size2, vAR_CSLAB_max_pool_size2, 1], padding='SAME')
# Transform Output into a 1xN layer for next fully connected layer
vAR_CSLAB_final_conv_shape = vAR_CSLAB_max_pool2.get_shape().as_list()
print (vAR_CSLAB_final_conv_shape)
vAR_CSLAB_final_shape = vAR_CSLAB_final_conv_shape[1] * vAR_CSLAB_final_conv_shape[2] * vAR_CSLAB_final_conv_shape[3]
vAR_CSLAB_flat_output = vAR_tf.reshape(vAR_CSLAB_max_pool2, [vAR_CSLAB_final_conv_shape[0], vAR_CSLAB_final_shape])
# First Fully Connected Layer
vAR_CSLAB_fully_connected1 = vAR_tf.nn.relu(vAR_tf.add(vAR_tf.matmul(vAR_CSLAB_flat_output, vAR_CSLAB_full1_weight), vAR_CSLAB_full1_bias))
# Second Fully Connected Layer
vAR_CSLAB_final_model_output = vAR_tf.add(vAR_tf.matmul(vAR_CSLAB_fully_connected1, vAR_CSLAB_full2_weight), vAR_CSLAB_full2_bias)
return(vAR_CSLAB_final_model_output)
print(vAR_CSLAB_model_output)
#vAR_CSLAB_model_output = vAR_CSLAB_my_conv_net(vAR_CSLAB_x_input)
#vAR_CSLAB_test_model_output = vAR_CSLAB_my_conv_net(vAR_CSLAB_eval_input)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_TENSORFLOW_DEEP_NEURAL_NETWORKS_V1
Purpose : A Program in Python Tensorflow for Deep Neural Networks
Author : DeepSphere.AI, Inc.
Date and Time : 26/12/2018 14:58 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Deep Neural Networks using Tensorflow in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
from sklearn import datasets
from tensorflow.python.framework import ops
ops.reset_default_graph()
vAR_CSLAB_iris = datasets.load_iris()
vAR_CSLAB_sl= vAR_tf.feature_column.numeric_column("sl")
vAR_CSLAB_sw = vAR_tf.feature_column.numeric_column("sw")
vAR_CSLAB_pl = vAR_tf.feature_column.numeric_column("pl")
vAR_CSLAB_estimator = vAR_tf.estimator.DNNRegressor(feature_columns = [vAR_CSLAB_sl,vAR_CSLAB_sw,vAR_CSLAB_pl],hidden_units = [5])
def vAR_CSLAB_input_fn( vAR_CSLAB_num_epochs, vAR_CSLAB_shuffle):
vAR_CSLAB_x = {'sl':vAR_CSLAB_iris.data.T[0],'sw':vAR_CSLAB_iris.data.T[1],'pl':vAR_CSLAB_iris.data.T[2]}
vAR_CSLAB_labels = vAR_CSLAB_iris.data.T[3]
return vAR_tf.estimator.inputs.numpy_input_fn(vAR_CSLAB_x,y=vAR_CSLAB_labels,batch_size=100,num_epochs=vAR_CSLAB_num_epochs,shuffle=vAR_CSLAB_shuffle)
vAR_CSLAB_estimator.train(input_fn=vAR_CSLAB_input_fn(vAR_CSLAB_num_epochs=None, vAR_CSLAB_shuffle=True), steps=100)
vAR_CSLAB_df_data = vAR_CSLAB_iris.data.T[:3]
vAR_CSLAB_estimator.predict
def vAR_CSLAB_input_fn_pred( vAR_CSLAB_num_epochs, vAR_CSLAB_shuffle):
vAR_CSLAB_x = {'sl':vAR_CSLAB_iris.data.T[0][:5],'sw':vAR_CSLAB_iris.data.T[1][:5],'pl':vAR_CSLAB_iris.data.T[2][:5]}
vAR_CSLAB_labels = None
return vAR_tf.estimator.inputs.numpy_input_fn(vAR_CSLAB_x,y=vAR_CSLAB_labels,batch_size=100,num_epochs=vAR_CSLAB_num_epochs,shuffle=vAR_CSLAB_shuffle)
vAR_CSLAB_pred = vAR_CSLAB_estimator.predict(input_fn=vAR_CSLAB_input_fn_pred)
print(vAR_CSLAB_pred)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_INSTALLING_NLTK_V1
Purpose : A Program in Python NLP for Installing NLTK
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 9:32 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Installing NLTK in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
nltk.download()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_COUNT_WORD_FREQUENCY_NLTK_V1
Purpose : A Program in Python using NLP for Counting Word Frequency
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 9:54 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Counting Word Frequency using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from bs4 import BeautifulSoup
import urllib.request
import nltk
vAR_CSLAB_response = urllib.request.urlopen('http://php.net/')
vAR_CSLAB_html = vAR_CSLAB_response.read()
vAR_CSLAB_soup = BeautifulSoup(vAR_CSLAB_html,"html5lib")
vAR_CSLAB_text = vAR_CSLAB_soup.get_text(strip=True)
vAR_CSLAB_tokens = [t for t in vAR_CSLAB_text.split()]
vAR_CSLAB_freq = nltk.FreqDist(vAR_CSLAB_tokens)
for key,val in vAR_CSLAB_freq.items():
print (str(key) + ':' + str(val))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_REMOVE_STOP_WORDS_V1
Purpose : A Program in Python using NLP for Removing Stop Words
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 10:12 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Removing Stop Words using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from bs4 import BeautifulSoup
import urllib.request
import nltk
from nltk.corpus import stopwords
vAR_CSLAB_response = urllib.request.urlopen('http://php.net/')
vAR_CSLAB_html = vAR_CSLAB_response.read()
vAR_CSLAB_soup = BeautifulSoup(vAR_CSLAB_html,"html5lib")
vAR_CSLAB_text = vAR_CSLAB_soup.get_text(strip=True)
vAR_CSLAB_tokens = [t for t in vAR_CSLAB_text.split()]
vAR_CSLAB_clean_tokens = vAR_CSLAB_tokens[:]
vAR_CSLAB_sr = stopwords.words('english')
for token in vAR_CSLAB_tokens:
if token in stopwords.words('english'):
vAR_CSLAB_clean_tokens.remove(token)
vAR_CSLAB_freq = nltk.FreqDist(vAR_CSLAB_clean_tokens)
for key,val in vAR_CSLAB_freq.items():
print (str(key) + ':' + str(val))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_TOKENIZE_TEXT_NLTK_V1
Purpose : A Program in Python using NLP for Tokenizing Texts
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 10:29 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Tokenizing Texts using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.tokenize import sent_tokenize
vAR_CSLAB_mytext = "Hello Mr. Adam, how are you? I hope everything is going well. Today is a good day, see you dude."
print(sent_tokenize(vAR_CSLAB_mytext))
from nltk.tokenize import word_tokenize
vAR_CSLAB_mytext = "Hello Mr. Adam, how are you? I hope everything is going well. Today is a good day, see you dude."
print(word_tokenize(vAR_CSLAB_mytext))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_TOKENIZE_NON_ENGLISH_TEXT_NLTK_V1
Purpose : A Program in Python using NLP for Tokenizing Non English Texts
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 10:47 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Tokenizing Non English Texts using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.tokenize import sent_tokenize
vAR_CSLAB_mytext = "Bonjour M. Adam, comment allez-vous? J'espère que tout va bien. Aujourd'hui est un bon jour."
print(sent_tokenize(vAR_CSLAB_mytext,"french"))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_GET_SYNONYMS_NLTK_V1
Purpose : A Program in Python using NLP for Getting Synonyms from Wordnet
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 11:08 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Getting Synonyms from Wordnet using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.corpus import wordnet
vAR_CSLAB_syn = wordnet.synsets("NLP")
print(vAR_CSLAB_syn[0].definition())
vAR_CSLAB_syn = wordnet.synsets("Python")
print(vAR_CSLAB_syn[0].definition())
vAR_CSLAB_synonyms = []
for vAR_CSLAB_syn in wordnet.synsets('Computer'):
for vAR_CSLAB_lemma in vAR_CSLAB_syn.lemmas():
vAR_CSLAB_synonyms.append(vAR_CSLAB_lemma.name())
print(vAR_CSLAB_synonyms)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_GET_ANTONYMS_NLTK_V1
Purpose : A Program in Python using NLP for Getting Antonyms from Wordnet
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 11:22 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Getting Antonyms from Wordnet using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.corpus import wordnet
vAR_CSLAB_syn = wordnet.synsets("NLP")
#print(vAR_CSLAB_syn[0].definition())
vAR_CSLAB_syn = wordnet.synsets("Python")
#print(vAR_CSLAB_syn[0].definition())
vAR_CSLAB_antonyms = []
for vAR_CSLAB_syn in wordnet.synsets("small"):
for vAR_CSLAB_l in vAR_CSLAB_syn.lemmas():
if vAR_CSLAB_l.antonyms():
vAR_CSLAB_antonyms.append(vAR_CSLAB_l.antonyms()[0].name())
print(vAR_CSLAB_antonyms)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_WORD_STEMMING_NLTK_V1
Purpose : A Program in Python using NLP for Word Stemming
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 11:38 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Word Stemming using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.stem import PorterStemmer
vAR_CSLAB_stemmer = PorterStemmer()
print(vAR_CSLAB_stemmer.stem('working'))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_NON_ENGLISH_WORD_STEMMING_NLTK_V1
Purpose : A Program in Python using NLP for Stemming Non English Words
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 11:53 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Stemming Non English Words using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.stem import SnowballStemmer
print(SnowballStemmer.languages)
from nltk.stem import SnowballStemmer
vAR_CSLAB_french_stemmer = SnowballStemmer('french')
print(vAR_CSLAB_french_stemmer.stem("French word"))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_LEMMATIZING_WORDS_NLTK_V1
Purpose : A Program in Python using NLP for Lemmatizing Words
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 12:18 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Lemmatizing Words using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.stem import PorterStemmer
vAR_CSLAB_stemmer = PorterStemmer()
print(vAR_CSLAB_stemmer.stem('increases'))
from nltk.stem import WordNetLemmatizer
vAR_CSLAB_lemmatizer = WordNetLemmatizer()
print(vAR_CSLAB_lemmatizer.lemmatize('increases'))
from nltk.stem import WordNetLemmatizer
vAR_CSLAB_lemmatizer = WordNetLemmatizer()
print(vAR_CSLAB_lemmatizer.lemmatize('playing', pos="v"))
from nltk.stem import WordNetLemmatizer
vAR_CSLAB_lemmatizer = WordNetLemmatizer()
print(vAR_CSLAB_lemmatizer.lemmatize('playing', pos="v"))
print(vAR_CSLAB_lemmatizer.lemmatize('playing', pos="n"))
print(vAR_CSLAB_lemmatizer.lemmatize('playing', pos="a"))
print(vAR_CSLAB_lemmatizer.lemmatize('playing', pos="r"))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_PART_OF_SPEECH_TAGGING_NLTK_V1
Purpose : A Program in Python using NLP for Part of Speech Tagging
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 12:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Part of Speech Tagging using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
from nltk.corpus import state_union
from nltk.tokenize import PunktSentenceTokenizer
vAR_CSLAB_train_text = state_union.raw("2005-GWBush.txt")
vAR_CSLAB_sample_text = state_union.raw("2006-GWBush.txt")
vAR_CSLAB_custom_sent_tokenizer = PunktSentenceTokenizer(vAR_CSLAB_train_text)
vAR_CSLAB_tokenized = vAR_CSLAB_custom_sent_tokenizer.tokenize(vAR_CSLAB_sample_text)
def vAR_CSLAB_process_content():
try:
for i in vAR_CSLAB_tokenized[:5]:
vAR_CSLAB_words = nltk.word_tokenize(i)
vAR_CSLAB_tagged = nltk.pos_tag(vAR_CSLAB_words)
print(vAR_CSLAB_tagged)
except Exception as vAR_CSLAB_e:
print(str(vAR_CSLAB_e))
vAR_CSLAB_process_content()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_CHINKING_NLTK_V1
Purpose : A Program in Python using NLP for Chinking
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 12:58 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Chinking using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
from nltk.corpus import state_union
from nltk.tokenize import PunktSentenceTokenizer
vAR_CSLAB_train_text = state_union.raw("2005-GWBush.txt")
vAR_CSLAB_sample_text = state_union.raw("2006-GWBush.txt")
vAR_CSLAB_custom_sent_tokenizer = PunktSentenceTokenizer(vAR_CSLAB_train_text)
vAR_CSLAB_tokenized = vAR_CSLAB_custom_sent_tokenizer.tokenize(vAR_CSLAB_sample_text)
def vAR_CSLAB_process_content():
try:
for i in vAR_CSLAB_tokenized[5:]:
vAR_CSLAB_words = nltk.word_tokenize(i)
vAR_CSLAB_tagged = nltk.pos_tag(vAR_CSLAB_words)
vAR_CSLAB_chunkGram = r"""Chunk: {<.*>+}
}<VB.?|IN|DT|TO>+{"""
vAR_CSLAB_chunkParser = nltk.RegexpParser(vAR_CSLAB_chunkGram)
vAR_CSLAB_chunked = vAR_CSLAB_chunkParser.parse(vAR_CSLAB_tagged)
vAR_CSLAB_chunked.draw()
except Exception as vAR_CSLAB_e:
print(str(vAR_CSLAB_e))
vAR_CSLAB_process_content()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_CHUNKING_NLTK_V1
Purpose : A Program in Python using NLP for Chunking
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 12:58 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Chunking using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
from nltk.corpus import state_union
from nltk.tokenize import PunktSentenceTokenizer
vAR_CSLAB_train_text = state_union.raw("2005-GWBush.txt")
vAR_CSLAB_sample_text = state_union.raw("2006-GWBush.txt")
vAR_CSLAB_custom_sent_tokenizer = PunktSentenceTokenizer(vAR_CSLAB_train_text)
vAR_CSLAB_tokenized = vAR_CSLAB_custom_sent_tokenizer.tokenize(vAR_CSLAB_sample_text)
def vAR_CSLAB_process_content():
try:
for i in vAR_CSLAB_tokenized:
vAR_CSLAB_words = nltk.word_tokenize(i)
vAR_CSLAB_tagged = nltk.pos_tag(vAR_CSLAB_words)
vAR_CSLAB_chunkGram = r"""Chunk: {<RB.?>*<VB.?>*<NNP>+<NN>?}"""
vAR_CSLAB_chunkParser = nltk.RegexpParser(vAR_CSLAB_chunkGram)
vAR_CSLAB_chunked = vAR_CSLAB_chunkParser.parse(vAR_CSLAB_tagged)
vAR_CSLAB_chunked.draw()
except Exception as vAR_CSLAB_e:
print(str(vAR_CSLAB_e))
vAR_CSLAB_process_content()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_CORPORA_NLTK_V1
Purpose : A Program in Python using NLP for Corpora
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 14:17 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Corpora using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.tokenize import sent_tokenize, PunktSentenceTokenizer
from nltk.corpus import gutenberg
# sample text
vAR_CSLAB_sample = gutenberg.raw("bible-kjv.txt")
vAR_CSLAB_tok = sent_tokenize(vAR_CSLAB_sample)
for x in range(5):
print(vAR_CSLAB_tok[x])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_NAMED_ENTITY_RECOGNITION_NLTK_V1
Purpose : A Program in Python using NLP for Named Entity Recognition
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 14:00 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Named Entity Recognition using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
from nltk.corpus import state_union
from nltk.tokenize import PunktSentenceTokenizer
vAR_CSLAB_train_text = state_union.raw("2005-GWBush.txt")
vAR_CSLAB_sample_text = state_union.raw("2006-GWBush.txt")
vAR_CSLAB_custom_sent_tokenizer = PunktSentenceTokenizer(vAR_CSLAB_train_text)
vAR_CSLAB_tokenized = vAR_CSLAB_custom_sent_tokenizer.tokenize(vAR_CSLAB_sample_text)
def vAR_CSLAB_process_content():
try:
for i in vAR_CSLAB_tokenized[5:]:
vAR_CSLAB_words = nltk.word_tokenize(i)
vAR_CSLAB_tagged = nltk.pos_tag(vAR_CSLAB_words)
vAR_CSLAB_namedEnt = nltk.ne_chunk(vAR_CSLAB_tagged, binary=True)
vAR_CSLAB_namedEnt.draw()
except Exception as vAR_CSLAB_e:
print(str(vAR_CSLAB_e))
vAR_CSLAB_process_content()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_TEXT_CLASSIFICATION_NLTK_V1
Purpose : A Program in Python using NLP for Text Classification
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 15:07 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Text Classification using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
import random
from nltk.corpus import movie_reviews
vAR_CSLAB_documents = [(list(movie_reviews.words(fileid)), category)
for category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]
random.shuffle(vAR_CSLAB_documents)
print(vAR_CSLAB_documents[1])
vAR_CSLAB_all_words = []
for w in movie_reviews.words():
vAR_CSLAB_all_words.append(w.lower())
vAR_CSLAB_all_words = nltk.FreqDist(vAR_CSLAB_all_words)
#print(vAR_CSLAB_all_words.most_common(15))
#print(vAR_CSLAB_all_words["stupid"])
vAR_CSLAB_documents = [(list(movie_reviews.words(fileid)), category)
for category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]
print(vAR_CSLAB_all_words.most_common(15))
print(vAR_CSLAB_all_words["stupid"])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_CONVERTING_WORDS_TO_FEATURES_NLTK_V1
Purpose : A Program in Python using NLP for Converting Words to Features
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 15:38 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Converting Words to Features using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
import random
from nltk.corpus import movie_reviews
vAR_CSLAB_documents = [(list(movie_reviews.words(fileid)), category)
for category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]
random.shuffle(vAR_CSLAB_documents)
vAR_CSLAB_all_words = []
for w in movie_reviews.words():
vAR_CSLAB_all_words.append(w.lower())
vAR_CSLAB_all_words = nltk.FreqDist(vAR_CSLAB_all_words)
vAR_CSLAB_word_features = list(vAR_CSLAB_all_words.keys())[:3000]
def vAR_CSLAB_find_features(vAR_CSLAB_document):
vAR_CSLAB_words = set(vAR_CSLAB_document)
vAR_CSLAB_features = {}
for w in vAR_CSLAB_word_features:
vAR_CSLAB_features[w] = (w in vAR_CSLAB_words)
return vAR_CSLAB_features
print((vAR_CSLAB_find_features(movie_reviews.words('neg/cv000_29416.txt'))))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_NAIVE_BAYES_CLASSIFIER_NLTK_V1
Purpose : A Program in Python using NLP for Naive Bayes Classifier
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 16:13 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Naive Bayes Classifier using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
nltk.usage(nltk.classify.ClassifierI)
vAR_CSLAB_train = [(dict(a=1,b=1,c=1), 'y'),(dict(a=1,b=1,c=1), 'x'),(dict(a=1,b=1,c=0), 'y'),(dict(a=0,b=1,c=1), 'x'),(dict(a=0,b=1,c=1), 'y'),(dict(a=0,b=0,c=1), 'y'),(dict(a=0,b=1,c=0), 'x'),(dict(a=0,b=0,c=0), 'x'),(dict(a=0,b=1,c=1), 'y')]
vAR_CSLAB_test = [(dict(a=1,b=0,c=1)), (dict(a=1,b=0,c=0)), (dict(a=0,b=1,c=1)), (dict(a=0,b=1,c=0))]
vAR_CSLAB_classifier = nltk.classify.NaiveBayesClassifier.train(vAR_CSLAB_train)
sorted(vAR_CSLAB_classifier.labels())
vAR_CSLAB_classifier.classify_many(vAR_CSLAB_test)
for pdist in vAR_CSLAB_classifier.prob_classify_many(vAR_CSLAB_test):
print('%.4f %.4f' % (pdist.prob('x'), pdist.prob('y')))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_SAVE_CLASSIFIER_NLTK_V1
Purpose : A Program in Python using NLP for Saving Classifier
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 16:34 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Saving Classifier using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
import pickle
nltk.usage(nltk.classify.ClassifierI)
vAR_CSLAB_train = [(dict(a=1,b=1,c=1), 'y'),(dict(a=1,b=1,c=1), 'x'),(dict(a=1,b=1,c=0), 'y'),(dict(a=0,b=1,c=1), 'x'),(dict(a=0,b=1,c=1), 'y'),(dict(a=0,b=0,c=1), 'y'),(dict(a=0,b=1,c=0), 'x'),(dict(a=0,b=0,c=0), 'x'),(dict(a=0,b=1,c=1), 'y')]
vAR_CSLAB_test = [(dict(a=1,b=0,c=1)), (dict(a=1,b=0,c=0)), (dict(a=0,b=1,c=1)), (dict(a=0,b=1,c=0))]
vAR_CSLAB_classifier = nltk.classify.NaiveBayesClassifier.train(vAR_CSLAB_train)
sorted(vAR_CSLAB_classifier.labels())
vAR_CSLAB_classifier.classify_many(vAR_CSLAB_test)
for pdist in vAR_CSLAB_classifier.prob_classify_many(vAR_CSLAB_test):
print('%.4f %.4f' % (pdist.prob('x'), pdist.prob('y')))
vAR_CSLAB_save_classifier = open("naivebayes.pickle","wb")
pickle.dump(vAR_CSLAB_classifier, vAR_CSLAB_save_classifier)
vAR_CSLAB_save_classifier.close()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_SCIKIT-LEARN_ALGORITHMS_NLTK_V1
Purpose : A Program in Python using NLP for Scikit Learn Algorithms
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 17:02 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Scikit Learn Algorithms using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.classify.scikitlearn import SklearnClassifier
from sklearn.naive_bayes import MultinomialNB,BernoulliNB
vAR_CSLAB_MNB_classifier = SklearnClassifier(MultinomialNB())
vAR_CSLAB_MNB_classifier.train(vAR_CSLAB_train)
vAR_CSLAB_BNB_classifier = SklearnClassifier(BernoulliNB())
vAR_CSLAB_BNB_classifier.train(vAR_CSLAB_train)
from sklearn.linear_model import LogisticRegression,SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
vAR_CSLAB_classifier.show_most_informative_features(15)
vAR_CSLAB_MNB_classifier = SklearnClassifier(MultinomialNB())
vAR_CSLAB_MNB_classifier.train(vAR_CSLAB_train)
vAR_CSLAB_BernoulliNB_classifier = SklearnClassifier(BernoulliNB())
vAR_CSLAB_BernoulliNB_classifier.train(vAR_CSLAB_train)
vAR_CSLAB_LogisticRegression_classifier = SklearnClassifier(LogisticRegression())
vAR_CSLAB_LogisticRegression_classifier.train(vAR_CSLAB_train)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_COMBINING_ALGORITHMS_NLTK_V1
Purpose : A Program in Python using NLP for Combining Algorithms
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 17:47 hrs
Version : 1.0
## Program Description : Program for Combining Algorithms using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import nltk
import random
from nltk.corpus import movie_reviews
from nltk.classify.scikitlearn import SklearnClassifier
import pickle
from sklearn.naive_bayes import MultinomialNB, BernoulliNB
from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from nltk.classify import ClassifierI
from statistics import mode
class vAR_CSLAB_VoteClassifier(ClassifierI):
def __init__(self, *classifiers):
self._classifiers = classifiers
def classify(self, features):
vAR_CSLAB_votes = []
for c in self._classifiers:
vAR_CSLAB_v = c.classify(vAR_CSLAB_features)
vAR_CSLAB_votes.append(vAR_CSLAB_v)
return mode(vAR_CSLAB_votes)
class vAR_CSLAB_VoteClassifier(ClassifierI):
def __init__(self, *classifiers):
self._classifiers = classifiers
def vAR_CSLAB_classify(self, features):
vAR_CSLAB_votes = []
for c in self._classifiers:
vAR_CSLAB_v = c.classify(features)
vAR_CSLAB_votes.append(vAR_CSLAB_v)
return mode(vAR_CSLAB_votes)
def vAR_CSLAB_confidence(self, features):
vAR_CSLAB_votes = []
for c in self._classifiers:
vAR_CSLAB_v = c.classify(features)
vAR_CSLAB_votes.append(vAR_CSLAB_v)
vAR_CSLAB_choice_votes = vAR_CSLAB_votes.count(mode(vAR_CSLAB_votes))
vAR_CSLAB_conf = vAR_CSLAB_choice_votes / len(vAR_CSLAB_votes)
return vAR_CSLAB_conf
vAR_CSLAB_documents = [(list(movie_reviews.words(fileid)), category)
for category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]
random.shuffle(vAR_CSLAB_documents)
vAR_CSLAB_all_words = []
for w in movie_reviews.words():
vAR_CSLAB_all_words.append(w.lower())
vAR_CSLAB_all_words = nltk.FreqDist(vAR_CSLAB_all_words)
vAR_CSLAB_word_features = list(vAR_CSLAB_all_words.keys())[:3000]
def vAR_CSLAB_find_features(vAR_CSLAB_document):
vAR_CSLAB_words = set(vAR_CSLAB_document)
vAR_CSLAB_features = {}
for w in vAR_CSLAB_word_features:
vAR_CSLAB_features[w] = (w in vAR_CSLAB_words)
return vAR_CSLAB_features
#print((find_features(movie_reviews.words('neg/cv000_29416.txt'))))
vAR_CSLAB_featuresets = [(vAR_CSLAB_find_features(rev), category) for (rev, category) in vAR_CSLAB_documents]
vAR_CSLAB_training_set = vAR_CSLAB_featuresets[:1900]
vAR_CSLAB_testing_set = vAR_CSLAB_featuresets[1900:]
#classifier = nltk.NaiveBayesClassifier.train(training_set)
vAR_CSLAB_classifier_f = open("naivebayes.pickle","rb")
vAR_CSLAB_classifier = pickle.load(vAR_CSLAB_classifier_f)
vAR_CSLAB_classifier_f.close()
vAR_CSLAB_MNB_classifier = SklearnClassifier(MultinomialNB())
vAR_CSLAB_MNB_classifier.train(vAR_CSLAB_training_set)
vAR_CSLAB_BNB_classifier = SklearnClassifier(BernoulliNB())
vAR_CSLAB_BNB_classifier.train(vAR_CSLAB_training_set)
from sklearn.linear_model import LogisticRegression,SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
vAR_CSLAB_classifier.show_most_informative_features(15)
vAR_CSLAB_MNB_classifier = SklearnClassifier(MultinomialNB())
vAR_CSLAB_MNB_classifier.train(vAR_CSLAB_training_set)
vAR_CSLAB_BernoulliNB_classifier = SklearnClassifier(BernoulliNB())
vAR_CSLAB_BernoulliNB_classifier.train(vAR_CSLAB_training_set)
vAR_CSLAB_LogisticRegression_classifier = SklearnClassifier(LogisticRegression())
vAR_CSLAB_LogisticRegression_classifier.train(vAR_CSLAB_training_set)
vAR_CSLAB_voted_classifier = vAR_CSLAB_VoteClassifier(vAR_CSLAB_MNB_classifier,
vAR_CSLAB_BernoulliNB_classifier,
vAR_CSLAB_LogisticRegression_classifier)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_NOISE_REMOVAL_NLTK_V1
Purpose : A Program in Python using NLP for Noise Removal
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 18:14 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Noise Removal using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_noise_list = ["is", "a", "this", "..."]
def vAR_CSLAB_remove_noise(input_text):
vAR_CSLAB_words = input_text.split()
vAR_CSLAB_noise_free_words = [word for word in vAR_CSLAB_words if word not in vAR_CSLAB_noise_list]
vAR_CSLAB_noise_free_text = " ".join(vAR_CSLAB_noise_free_words)
return vAR_CSLAB_noise_free_text
vAR_CSLAB_remove_noise("this is a sample text")
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_NOISE_REMOVAL_REGULAR_EXPRESSIONS_NLTK_V1
Purpose : A Program in Python using NLP for Noise Removal by Regular Expressions
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 18:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Noise Removal by Regular Expressions using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import re
def vAR_CSLAB_remove_regex(input_text, regex_pattern):
vAR_CSLAB_urls = re.finditer(regex_pattern, input_text)
for i in vAR_CSLAB_urls:
vAR_CSLAB_input_text = re.sub(i.group().strip(), '', input_text)
return input_text
vAR_CSLAB_regex_pattern = "#[\w]*"
vAR_CSLAB_remove_regex("remove this #hashtag from my text", vAR_CSLAB_regex_pattern)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_OBJECT_STANDARDIZATION_NLTK_V1
Purpose : A Program in Python using NLP for Object Stanardization
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 18:59 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Object Stanardization using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_lookup_dict = {'rt':'Retweet', 'dm':'direct message', "awsm" : "awesome", "luv" :"love"}
def vAR_CSLAB_lookup_words(input_text):
vAR_CSLAB_words = input_text.split()
vAR_CSLAB_new_words = []
for word in vAR_CSLAB_words:
if word.lower() in vAR_CSLAB_lookup_dict:
vAR_CSLAB_word = vAR_CSLAB_lookup_dict[word.lower()]
vAR_CSLAB_new_words.append(word)
vAR_CSLAB_new_text = " ".join(vAR_CSLAB_new_words)
return vAR_CSLAB_new_text
vAR_CSLAB_lookup_words("Retweet this is a retweeted tweet by DP")
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_TOPIC_MODELLING_NLTK_V1
Purpose : A Program in Python using NLP for Topic Modelling
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 19:18 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Topic Modelling using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
vAR_CSLAB_doc1 = "Sugar is bad to consume. My sister likes to have sugar, but not my father."
vAR_CSLAB_doc2 = "My father spends a lot of time driving my sister around to dance practice."
vAR_CSLAB_doc3 = "Doctors suggest that driving may cause increased stress and blood pressure."
vAR_CSLAB_doc_complete = [vAR_CSLAB_doc1, vAR_CSLAB_doc2, vAR_CSLAB_doc3]
vAR_CSLAB_doc_clean = [doc.split() for doc in vAR_CSLAB_doc_complete]
import gensim
# Creating the object for LDA model using gensim library
vAR_CSLAB_Lda = gensim.models.ldamodel.LdaModel
vAR_CSLAB_Lda
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_NGRAMS_NLTK_V1
Purpose : A Program in Python using NLP for N-Grams
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 19:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for N-Grams using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.tokenize import RegexpTokenizer
vAR_CSLAB_tokenizer = RegexpTokenizer("[a-zA-Z'`éèî]+")
vAR_CSLAB_tokenizer.tokenize("Le temps est un grand maître, dit-on, le malheur est qu'il tue ses élèves.")
from nltk.util import ngrams
vAR_CSLAB_generated_ngrams = ngrams(vAR_CSLAB_tokenizer,4)
vAR_CSLAB_generated_ngrams/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_TFIDF_VECTORIZER_NLTK_V1
Purpose : A Program in Python using NLP for Tfidf Vectorizer
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 19:53 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Tfidf Vectorizer using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from sklearn.feature_extraction.text import TfidfVectorizer
vAR_CSLAB_obj = TfidfVectorizer()
vAR_CSLAB_corpus = ['This is sample document.', 'another random document.', 'third sample document text']
vAR_CSLAB_X = vAR_CSLAB_obj.fit_transform(vAR_CSLAB_corpus)
print (vAR_CSLAB_X)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_WORD_EMBEDDING_NLTK_V1
Purpose : A Program in Python using NLP for Word Embedding
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 20:14 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Word Embedding using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from gensim.models import Word2Vec
vAR_CSLAB_sentences = [['data', 'science'], ['vidhya', 'science', 'data', 'analytics'],['machine', 'learning'], ['deep', 'learning']]
# train the model on your corpus
vAR_CSLAB_model = Word2Vec(vAR_CSLAB_sentences, min_count = 1)
print(vAR_CSLAB_model.similarity('data', 'science'))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_TEXT_MATCHING_LEVENSHTEIN_DISTANCE_NLTK_V1
Purpose : A Program in Python using NLP for Levenshtein Distance
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 20:31 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Levenshtein Distance using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
def vAR_CSLAB_levenshtein(vAR_CSLAB_s1,vAR_CSLAB_s2):
if len(vAR_CSLAB_s1) > len(vAR_CSLAB_s2):
vAR_CSLAB_s1,vAR_CSLAB_s2 = vAR_CSLAB_s2,vAR_CSLAB_s1
vAR_CSLAB_distances = range(len(vAR_CSLAB_s1) + 1)
for vAR_CSLAB_index2,vAR_CSLAB_char2 in enumerate(vAR_CSLAB_s2):
vAR_CSLAB_newDistances = [vAR_CSLAB_index2+1]
for vAR_CSLAB_index1,vAR_CSLAB_char1 in enumerate(vAR_CSLAB_s1):
if vAR_CSLAB_char1 == vAR_CSLAB_char2:
vAR_CSLAB_newDistances.append(vAR_CSLAB_distances[vAR_CSLAB_index1])
else:
vAR_CSLAB_newDistances.append(1 + min((vAR_CSLAB_distances[vAR_CSLAB_index1], vAR_CSLAB_distances[vAR_CSLAB_index1+1], vAR_CSLAB_newDistances[-1])))
vAR_CSLAB_distances = vAR_CSLAB_newDistances
return vAR_CSLAB_distances[-1]
print(vAR_CSLAB_levenshtein("analyze","analyse"))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_COSINE_SIMILARITY_NLTK_V1
Purpose : A Program in Python using NLP for Cosine Similarity
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 20:49 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Cosine Similarity using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
import math
from collections import Counter
def vAR_CSLAB_get_cosine(vec1, vec2):
vAR_CSLAB_common = set(vec1.keys()) & set(vec2.keys())
vAR_CSLAB_numerator = sum([vec1[x] * vec2[x] for x in vAR_CSLAB_common])
vAR_CSLAB_sum1 = sum([vec1[x]**2 for x in vec1.keys()])
vAR_CSLAB_sum2 = sum([vec2[x]**2 for x in vec2.keys()])
vAR_CSLAB_denominator = math.sqrt(vAR_CSLAB_sum1) * math.sqrt(vAR_CSLAB_sum2)
if not vAR_CSLAB_denominator:
return 0.0
else:
return float(vAR_CSLAB_numerator) / vAR_CSLAB_denominator
def vAR_CSLAB_text_to_vector(text):
vAR_CSLAB_words = text.split()
return Counter(vAR_CSLAB_words)
vAR_CSLAB_text1 = 'This is an article on analytics vidhya'
vAR_CSLAB_text2 = 'article on analytics vidhya is about natural language processing'
vAR_CSLAB_vector1 = vAR_CSLAB_text_to_vector(vAR_CSLAB_text1)
vAR_CSLAB_vector2 = vAR_CSLAB_text_to_vector(vAR_CSLAB_text2)
vAR_CSLAB_cosine = vAR_CSLAB_get_cosine(vAR_CSLAB_vector1, vAR_CSLAB_vector2)
vAR_CSLAB_cosine
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_NLP_WORDNET_NLTK_V1
Purpose : A Program in Python using NLP for Wordnet
Author : DeepSphere.AI, Inc.
Date and Time : 27/12/2018 14:32 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Wordnet using NLP in Python
## Python Development Environment & Runtime - Python, Anaconda
from nltk.corpus import wordnet
vAR_CSLAB_syns = wordnet.synsets("program")
vAR_CSLAB_synonyms = []
vAR_CSLAB_antonyms = []
for syn in wordnet.synsets("good"):
for vAR_CSLAB_l in syn.lemmas():
vAR_CSLAB_synonyms.append(vAR_CSLAB_l.name())
if vAR_CSLAB_l.antonyms():
vAR_CSLAB_antonyms.append(vAR_CSLAB_l.antonyms()[0].name())
print(set(vAR_CSLAB_synonyms))
print(set(vAR_CSLAB_antonyms))
vAR_CSLAB_w1 = wordnet.synset('ship.n.01')
vAR_CSLAB_w2 = wordnet.synset('boat.n.01')
print(vAR_CSLAB_w1.wup_similarity(vAR_CSLAB_w2))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_INSTALL_OPENCV
Purpose : A Program in Python using Computer Vision for Installing Opencv
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 9:41 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Installing Opencv using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
print (cv2. __version__)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_READING_IMAGES_OPENCV
Purpose : A Program in Python using Computer Vision for Reading Images
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 9:53 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Reading Images using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_Birds_Image = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
vAR_CSLAB_Birds_Image = cv2.imread(vAR_CSLAB_Birds_Image)
cv2.imshow('Birds',vAR_CSLAB_Birds_Image)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_DISPLAYING_IMAGES_OPENCV
Purpose : A Program in Python using Computer Vision for Displaying Images
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 10:01 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Displaying Images using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_Birds_Image = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_Birds_Image)
cv2.imshow('Birds',vAR_CSLAB_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_WRITING_IMAGES_OPENCV
Purpose : A Program in Python using Computer Vision for Writing Images
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 10:17 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Writing Images using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_Birds_Image_Read = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_288_BIRDS_IMAGE_READ']
vAR_CSLAB_Birds_Image_Read = cv2.imread(vAR_CSLAB_Birds_Image_Read)
cv2.waitKey(0)
cv2.destroyAllWindows()
vAR_CSLAB_Birds_Image_Write = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_288_BIRDS_IMAGE_WRITE']
vAR_CSLAB_Birds_Image_Write = cv2.imread(vAR_CSLAB_Birds_Image_Write)
cv2.imwrite(vAR_CSLAB_Birds_Image_Write,vAR_CSLAB_img)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_COLOR_SPACE_OPENCV
Purpose : A Program in Python using Computer Vision for Color Space
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 10:32 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Color Space using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
vAR_CSLAB_cam = cv2.VideoCapture(0)
vAR_CSLAB_ret, vAR_CSLAB_image = vAR_CSLAB_cam.read()
vAR_CSLAB_image = cv2.cvtColor(vAR_CSLAB_image, cv2.COLOR_BGR2GRAY)
cv2.imshow("My Image ", vAR_CSLAB_image)
cv2.waitKey(0)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_THRESHOLDING_OPENCV
Purpose : A Program in Python using Computer Vision for Thresholding
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 10:57 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Thresholding using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
vAR_CSLAB_vAR_CSLAB_cam = cv2.VideoCapture(0)
vAR_CSLAB_x, vAR_CSLAB_y, vAR_CSLAB_w, vAR_CSLAB_h = 400, 400, 100, 100
while vAR_CSLAB_cam.isOpened():
vAR_CSLAB_ret, vAR_CSLAB_frame = vAR_CSLAB_cam.read()
vAR_CSLAB_frame = cv2.cvtColor(vAR_CSLAB_frame, cv2.COLOR_BGR2HSV)
cv2.rectangle(vAR_CSLAB_frame, (vAR_CSLAB_x, vAR_CSLAB_y), (vAR_CSLAB_x+vAR_CSLAB_w, vAR_CSLAB_y+vAR_CSLAB_h), (255, 255, 255), thickness=1)
cv2.putText(vAR_CSLAB_frame, "HSV: {0}".format(vAR_CSLAB_frame[vAR_CSLAB_y+1, vAR_CSLAB_x+1]), (vAR_CSLAB_x, 600),cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), thickness=2)
cv2.imshow("frame", vAR_CSLAB_frame)
vAR_CSLAB_key = cv2.waitKey(1) & 0xff
if vAR_CSLAB_key == 27:
break
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_FINDING_CONTOURS_OPENCV
Purpose : A Program in Python using Computer Vision for Finding Contours
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 11:22 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Finding Contours using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
vAR_CSLAB_cam = cv2.VideoCapture(0)
vAR_CSLAB_lower_yellow = (18, 100, 210)
vAR_CSLAB_upper_yellow = (40, 160, 245)
while vAR_CSLAB_cam.isOpened():
vAR_CSLAB_ret, vAR_CSLAB_frame = vAR_CSLAB_cam.read()
vAR_CSLAB_frame = cv2.cvtColor(vAR_CSLAB_frame, cv2.COLOR_BGR2HSV)
vAR_CSLAB_mask = cv2.inRange(vAR_CSLAB_frame, vAR_CSLAB_lower_yellow, vAR_CSLAB_upper_yellow)
_, contours, _ = cv2.findContours(vAR_CSLAB_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
if len(contours) > 0:
vAR_CSLAB_tennis_ball = max(contours, key=cv2.contourArea)
vAR_CSLAB_x, vAR_CSLAB_y, vAR_CSLAB_w, vAR_CSLAB_h = cv2.boundingRect(vAR_CSLAB_tennis_ball)
cv2.rectangle(vAR_CSLAB_frame, (vAR_CSLAB_x, vAR_CSLAB_y), (vAR_CSLAB_x+vAR_CSLAB_w, vAR_CSLAB_y+vAR_CSLAB_h), (0, 255, 0), thickness=3)
cv2.imshow("frame", vAR_CSLAB_frame)
vAR_CSLAB_key = cv2.waitKey(1) & 0xff
if vAR_CSLAB_key == 27:
break
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_SCALING_OPENCV
Purpose : A Program in Python using Computer Vision for Image Scaling
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 11:41 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Finding Contours using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
#vAR_CSLAB_FILE_NAME = 'C:/Python_Programs/Birds.jpg'
try:
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
(vAR_CSLAB_height, vAR_CSLAB_width) = vAR_CSLAB_img.shape[:2]
vAR_CSLAB_res = cv2.resize(vAR_CSLAB_img, (int(vAR_CSLAB_width / 2), int(vAR_CSLAB_height / 2)), interpolation = cv2.INTER_CUBIC)
cv2.imwrite('result.jpg', vAR_CSLAB_res)
except IOError:
print ('Error while reading files !!!')
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_ROTATION_OPENCV
Purpose : A Program in Python using Computer Vision for Image Rotation
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 12:05 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Rotation using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
try:
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
(vAR_CSLAB_rows, vAR_CSLAB_cols) = vAR_CSLAB_img.shape[:2]
vAR_CSLAB_M = cv2.getRotationMatrix2D((vAR_CSLAB_cols / 2, vAR_CSLAB_rows / 2), 45, 1)
vAR_CSLAB_res = cv2.warpAffine(vAR_CSLAB_img, vAR_CSLAB_M, (vAR_CSLAB_cols, vAR_CSLAB_rows))
cv2.imwrite('result1.jpg', vAR_CSLAB_res)
except IOError:
print ('Error while reading files !!!')
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_TRANSLATION_OPENCV
Purpose : A Program in Python using Computer Vision for Image Translation
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 12:23 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Translation using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
try:
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
(vAR_CSLAB_rows, vAR_CSLAB_cols) = vAR_CSLAB_img.shape[:2]
vAR_CSLAB_M = cv2.getRotationMatrix2D((vAR_CSLAB_cols / 2, vAR_CSLAB_rows / 2), 45, 1)
vAR_CSLAB_res = cv2.warpAffine(vAR_CSLAB_img, vAR_CSLAB_M, (vAR_CSLAB_cols, vAR_CSLAB_rows))
cv2.imwrite('result1.jpg', vAR_CSLAB_res)
except IOError:
print ('Error while reading files !!!')
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_EDGE_DETECTION_OPENCV
Purpose : A Program in Python using Computer Vision for Edge Detection in an Image
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 12:41 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Edge Detection in an Image using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
try:
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
vAR_CSLAB_edges = cv2.Canny(vAR_CSLAB_img, 100, 200)
cv2.imwrite('result3.jpg', vAR_CSLAB_edges)
except IOError:
print ('Error while reading files !!!')
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_FILTERING_OPENCV
Purpose : A Program in Python using Computer Vision for Image Filtering (2D Convolution)
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 13:07 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Filtering using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
vAR_CSLAB_kernel = vAR_np.ones((5,5),vAR_np.float32)/25
vAR_CSLAB_dst = cv2.filter2D(vAR_CSLAB_img,-1,vAR_CSLAB_kernel)
vAR_plt.subplot(121)
vAR_plt.imshow(vAR_CSLAB_img)
vAR_plt.title('Original')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.subplot(122)
vAR_plt.imshow(vAR_CSLAB_dst)
vAR_plt.title('Averaging')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_FILTERING_BLURRING_OPENCV
Purpose : A Program in Python using Computer Vision for Image Blurring
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 13:47 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Blurring using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
vAR_CSLAB_blur = cv2.blur(vAR_CSLAB_img,(5,5))
vAR_plt.subplot(121)
vAR_plt.imshow(vAR_CSLAB_img)
vAR_plt.title('Original')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.subplot(122)
vAR_plt.imshow(vAR_CSLAB_blur)
vAR_plt.title('Blurred')
vAR_plt.xticks([])
vAR_plt.yticks([])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_FILTERING_BLURRING_GAUSSIAN_BLUR_OPENCV
Purpose : A Program in Python using Computer Vision for Image Blurring (Guassian Blur)
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 14:09 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Blurring (Guassian Blur) using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
vAR_CSLAB_blur = cv2.GaussianBlur(vAR_CSLAB_img,(5,5),0)
vAR_plt.subplot(121)
vAR_plt.imshow(vAR_CSLAB_img)
vAR_plt.title('Original')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.subplot(122)
vAR_plt.imshow(vAR_CSLAB_blur)
vAR_plt.title('Blurred')
vAR_plt.xticks([])
vAR_plt.yticks([])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_FILTERING_BLURRING_MEDIAN_BLUR_OPENCV
Purpose : A Program in Python using Computer Vision for Image Blurring (Median Blur)
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 14:27 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Blurring (Median Blur) using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
vAR_CSLAB_blur = cv2.GaussianBlur(vAR_CSLAB_img,(5,5),0)
vAR_plt.subplot(121)
vAR_plt.imshow(vAR_CSLAB_img)
vAR_plt.title('Original')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.subplot(122)
vAR_plt.imshow(vAR_CSLAB_blur)
vAR_plt.title('Median')
vAR_plt.xticks([])
vAR_plt.yticks([])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_FILTERING_BILATERAL_OPENCV
Purpose : A Program in Python using Computer Vision for Image Filtering (Bilateral Filtering)
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 14:49 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Filtering (Bilateral Filtering) using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
vAR_CSLAB_blur = cv2.bilateralFilter(vAR_CSLAB_img,9,75,75)
vAR_plt.subplot(121)
vAR_plt.imshow(vAR_CSLAB_img)
vAR_plt.title('Original')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.subplot(122)
vAR_plt.imshow(vAR_CSLAB_blur)
vAR_plt.title('Bilateral')
vAR_plt.xticks([])
vAR_plt.yticks([])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_MORPHOLOGICAL_OPERATIONS_EROSION_OPENCV
Purpose : A Program in Python using Computer Vision for Image Processing Operations - Erosion
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 15:06 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Processing Operations - Erosion using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_301_LETTERJ_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_kernel = vAR_np.ones((5,5),vAR_np.uint8)
vAR_CSLAB_erosion = cv2.erode(vAR_CSLAB_img,vAR_CSLAB_kernel,iterations = 1)
vAR_CSLAB_erosion
vAR_plt.imshow(vAR_CSLAB_erosion)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_MORPHOLOGICAL_OPERATIONS_DILATION_OPENCV
Purpose : A Program in Python using Computer Vision for Image Processing Operations - Dilation
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 15:23 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Processing Operations - Dilation using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_301_LETTERJ_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_kernel = vAR_np.ones((5,5),vAR_np.uint8)
vAR_CSLAB_dilation = cv2.dilate(vAR_CSLAB_img,vAR_CSLAB_kernel,iterations = 1)
vAR_CSLAB_dilation
vAR_plt.imshow(vAR_CSLAB_dilation)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_MORPHOLOGICAL_OPERATIONS_OPENING_OPENCV
Purpose : A Program in Python using Computer Vision for Image Processing Operations - Opening
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 15:38 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Processing Operations - Opening using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_301_LETTERJ_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_kernel = vAR_np.ones((5,5),vAR_np.uint8)
vAR_CSLAB_Opening = cv2.morphologyEx(vAR_CSLAB_img,cv2.MORPH_OPEN,vAR_CSLAB_kernel)
vAR_CSLAB_Opening
vAR_plt.imshow(vAR_CSLAB_Opening)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_MORPHOLOGICAL_OPERATIONS_CLOSING_OPENCV
Purpose : A Program in Python using Computer Vision for Image Processing Operations - Closing
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 15:54 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Processing Operations - Closing using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_301_LETTERJ_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_kernel = vAR_np.ones((5,5),vAR_np.uint8)
vAR_CSLAB_Closing = cv2.morphologyEx(vAR_CSLAB_img,cv2.MORPH_CLOSE,vAR_CSLAB_kernel)
vAR_CSLAB_Closing
vAR_plt.imshow(vAR_CSLAB_Closing)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_MORPHOLOGICAL_OPERATIONS_GRADIENT_OPENCV
Purpose : A Program in Python using Computer Vision for Image Processing Operations - Gradient
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 16:12 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Processing Operations - Gradient using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_301_LETTERJ_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_kernel = vAR_np.ones((5,5),vAR_np.uint8)
vAR_CSLAB_Gradient = cv2.morphologyEx(vAR_CSLAB_img,cv2.MORPH_GRADIENT,vAR_CSLAB_kernel)
vAR_CSLAB_Gradient
vAR_plt.imshow(vAR_CSLAB_Gradient)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_MORPHOLOGICAL_OPERATIONS_TOPHAT_OPENCV
Purpose : A Program in Python using Computer Vision for Image Processing Operations - Top Hat Transform
Date and Time : 28/12/2018 16:21 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Processing Operations - Top Hat Transform using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_301_LETTERJ_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_kernel = vAR_np.ones((5,5),vAR_np.uint8)
vAR_CSLAB_Top_Hat = cv2.morphologyEx(vAR_CSLAB_img,cv2.MORPH_TOPHAT,vAR_CSLAB_kernel)
vAR_CSLAB_Top_Hat
vAR_plt.imshow(vAR_CSLAB_Top_Hat)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_MORPHOLOGICAL_OPERATIONS_BLACKHAT_OPENCV
Purpose : A Program in Python using Computer Vision for Image Processing Operations - Black Hat Transform
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 16:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Processing Operations - Black Hat Transform using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_301_LETTERJ_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_kernel = vAR_np.ones((5,5),vAR_np.uint8)
vAR_CSLAB_Black_Hat = cv2.morphologyEx(vAR_CSLAB_img,cv2.MORPH_BLACKHAT,vAR_CSLAB_kernel)
vAR_CSLAB_Black_Hat
vAR_plt.imshow(vAR_CSLAB_Black_Hat)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_GRADIENTS_SOBEL_OPENCV
Purpose : A Program in Python using Computer Vision for Edge Detection by Sobel Operator
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 16:53 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Edge Detection by Sobel Operator using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_Sobel = cv2.Sobel(vAR_CSLAB_img,cv2.CV_64F,1,0,ksize=5)
vAR_plt.subplot(2,2,2)
vAR_plt.imshow(vAR_CSLAB_Sobel,cmap = 'gray')
vAR_plt.title('Sobel')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_GRADIENTS_SCHARR_OPENCV
Purpose : A Program in Python using Computer Vision for Edge Detection by Scharr Operator
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 17:05 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Edge Detection by Scharr Operator using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_Scharr = cv2.Scharr(vAR_CSLAB_img,cv2.CV_64F,1,0)
vAR_plt.subplot(2,2,2)
vAR_plt.imshow(vAR_CSLAB_Scharr ,cmap = 'gray')
vAR_plt.title('Scharr')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_IMAGE_GRADIENTS_LAPLACIAN_OPENCV
Purpose : A Program in Python using Computer Vision for Edge Detection by Laplacian Operator
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 17:19 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Edge Detection by Laplacian Operator using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
VAR_CSLAB_laplacian = cv2.Laplacian(vAR_CSLAB_img,cv2.CV_64F)
vAR_plt.subplot(2,2,2)
vAR_plt.imshow(VAR_CSLAB_laplacian,cmap = 'gray')
vAR_plt.title('Laplacian')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_CANNY_EDGE_DETECTION_OPENCV
Purpose : A Program in Python using Computer Vision for Canny Edge Detection
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 17:38 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Canny Edge Detection using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_CSLAB_edges = cv2.Canny(vAR_CSLAB_img,100,200)
vAR_plt.subplot(121),
vAR_plt.imshow(vAR_CSLAB_img,cmap = 'gray')
vAR_plt.title('Original Image')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.subplot(122)
vAR_plt.imshow(vAR_CSLAB_edges,cmap = 'gray')
vAR_plt.title('Edge Image')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_GAUSSIAN_PYRAMID_OPENCV
Purpose : A Program in Python using Computer Vision for Image Resolution by Gaussian Pyramid
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 17:57 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Resolution by Gaussian Pyramid using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_312_APPLE_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
# Gaussian Pyramid
vAR_CSLAB_layer = vAR_CSLAB_img.copy()
vAR_CSLAB_gaussian_pyramid = [vAR_CSLAB_layer]
for i in range(4):
vAR_CSLAB_layer = cv2.pyrDown(vAR_CSLAB_layer)
vAR_CSLAB_gaussian_pyramid.append(vAR_CSLAB_layer)
cv2.imshow("Original image", vAR_CSLAB_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_CONTOURS_OPENCV
Purpose : A Program in Python using Computer Vision for Image Shape Analysis/Object Detection & Recognition by Contours
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 18:13 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Image Shape Analysis/Object Detection & Recognition by Contours using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_312_APPLE_IMAGE']
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
vAR_CSLAB_imgray = cv2.cvtColor(vAR_CSLAB_img,cv2.COLOR_BGR2GRAY)
vAR_CSLAB_ret,vAR_CSLAB_thresh = cv2.threshold(vAR_CSLAB_imgray,127,255,0)
vAR_CSLAB_image, vAR_CSLAB_contours, vAR_CSLAB_hierarchy = cv2.findContours(vAR_CSLAB_thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
vAR_CSLAB_img = cv2.drawContours(vAR_CSLAB_img, vAR_CSLAB_contours, -1, (0,255,0), 3)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_HISTOGRAMS_OPENCV
Purpose : A Program in Python using Computer Vision for Histograms
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 18:31 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Histograms using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
from matplotlib import pyplot as vAR_plt
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME,0)
vAR_plt.hist(vAR_CSLAB_img.ravel(),256,[0,256])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_HISTOGRAMS_WITH_MASK_OPENCV
Purpose : A Program in Python using Computer Vision for Histogram with Mask
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 18:49 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Histogram with Mask using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
# create a mask
vAR_CSLAB_mask = vAR_np.zeros(vAR_CSLAB_img.shape[:2], vAR_np.uint8)
vAR_CSLAB_mask[100:300, 100:400] = 255
vAR_CSLAB_masked_img = cv2.bitwise_and(vAR_CSLAB_img,vAR_CSLAB_img,mask = vAR_CSLAB_mask)
# Calculate histogram with mask and without mask
# Check third argument for mask
vAR_CSLAB_hist_full = cv2.calcHist([vAR_CSLAB_img],[0],None,[256],[0,256])
vAR_CSLAB_hist_mask = cv2.calcHist([vAR_CSLAB_img],[0],vAR_CSLAB_mask,[256],[0,256])
vAR_plt.subplot(221)
vAR_plt.imshow(vAR_CSLAB_img, 'gray')
vAR_plt.subplot(222)
vAR_plt.imshow(vAR_CSLAB_mask,'gray')
vAR_plt.subplot(223)
vAR_plt.imshow(vAR_CSLAB_masked_img, 'gray')
vAR_plt.subplot(224)
vAR_plt.plot(vAR_CSLAB_hist_full)
vAR_plt.plot(vAR_CSLAB_hist_mask)
vAR_plt.xlim([0,256])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_FOURIER_TRANSFORM_OPENCV
Purpose : A Program in Python using Computer Vision for Fourier Transform
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 19:17 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Fourier Transform using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
vAR_CSLAB_dft = cv2.dft(vAR_np.float32(vAR_CSLAB_img),flags = cv2.DFT_COMPLEX_OUTPUT)
vAR_CSLAB_dft_shift = vAR_np.fft.fftshift(vAR_CSLAB_dft)
vAR_CSLAB_magnitude_spectrum = 20*vAR_np.log(cv2.magnitude(vAR_CSLAB_dft_shift[:,:,0],vAR_CSLAB_dft_shift[:,:,1]))
vAR_plt.subplot(121)
vAR_plt.imshow(vAR_CSLAB_img, cmap = 'gray')
vAR_plt.title('Input Image')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.subplot(122)
vAR_plt.imshow(vAR_CSLAB_magnitude_spectrum, cmap = 'gray')
vAR_plt.title('Magnitude Spectrum')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_COMPUTER_VISION_TEMPLATE_MATCHING_OPENCV
Purpose : A Program in Python using Computer Vision for Templete Matching
Author : DeepSphere.AI, Inc.
Date and Time : 28/12/2018 19:57 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Templete Matching using Opencv in Python
## Python Development Environment & Runtime - Python, Anaconda
import cv2
import numpy as vAR_np
from matplotlib import pyplot as vAR_plt
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_FILE_NAME = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
##vAR_CSLAB_Birds_Image = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_286_BIRDS_IMAGE']
vAR_CSLAB_img = cv2.imread(vAR_CSLAB_FILE_NAME)
vAR_CSLAB_img2 = vAR_CSLAB_img.copy()
vAR_CSLAB_template = cv2.imread(vAR_CSLAB_FILE_NAME)
#vAR_CSLAB_w, vAR_CSLAB_h = vAR_CSLAB_template.shape[::-1]
# All the 6 methods for comparison in a list
vAR_CSLAB_methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',
'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']
for meth in vAR_CSLAB_methods:
vAR_CSLAB_img = vAR_CSLAB_img2.copy()
vAR_CSLAB_method = eval(meth)
# Apply template Matching
vAR_CSLAB_res = cv2.matchTemplate(vAR_CSLAB_img,vAR_CSLAB_template,vAR_CSLAB_method)
vAR_CSLAB_min_val, vAR_CSLAB_max_val, vAR_CSLAB_min_loc, vAR_CSLAB_max_loc = cv2.minMaxLoc(vAR_CSLAB_res)
# If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
if vAR_CSLAB_method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
vAR_CSLAB_top_left = vAR_CSLAB_min_loc
else:
vAR_CSLAB_top_left = vAR_CSLAB_max_loc
vAR_CSLAB_bottom_right = (vAR_CSLAB_top_left[0] + vAR_CSLAB_w, vAR_CSLAB_top_left[1] + vAR_CSLAB_h)
cv2.rectangle(vAR_CSLAB_img,vAR_CSLAB_top_left, vAR_CSLAB_bottom_right, 255, 2)
vAR_plt.subplot(121)
vAR_plt.imshow(vAR_CSLAB_res,cmap = 'gray')
vAR_plt.title('Matching Result')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.subplot(122),
vAR_plt.imshow(vAR_CSLAB_img,cmap = 'gray')
vAR_plt.title('Detected Point')
vAR_plt.xticks([])
vAR_plt.yticks([])
vAR_plt.suptitle(meth)
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_INSTALL_AUTOMAGICA
Purpose : A Program in Python using RPA for Installing Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 9:53 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Installing Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
pip install https://github.com/OakwoodAI/automagica/tarball/master
from automagica import *
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_OPEN_NOTEPAD_TYPE_HELLO_WORLD_AUTOMAGICA
Purpose : A Program in Python for Typing Hello World Automatically using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 10:13 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Typing Hello World Automatically using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
PressHotkey('win','r')
Wait(seconds=1)
Type(text='notepad', interval_seconds=0)
PressKey('enter')
Wait(seconds=2)
Type(text='Hello world!', interval_seconds=0.15)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_OPEN_CHROME_BROWSER_AUTOMAGICA
Purpose : A Program in Python for Opening Chrome Browser & getting google.com Homepage using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 10:25 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Opening Chrome Browser using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
vAR_CSLAB_browser = ChromeBrowser()
vAR_CSLAB_browser.get('https://google.com')
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_AUTOMATE_MOUSE_MOVEMENTS_AUTOMAGICA
Purpose : A Program in Python for Automating Mouse Movements using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 10:42 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Automating Mouse Movements using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
GetMouseCoordinates()
#ClickOnPosition(x, y)
#DoubleClickOnPosition(x, y)
#DragToPosition(x, y, button="left")
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_FUNCTION_TO_OPEN_DROPBOX_AUTOMAGICA
Purpose : A Program in Python for Opening Dropbox using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 10:58 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Opening Dropbox using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import cv2
import numpy as vAR_np
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_LAUNCH_PROCESS = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_322_LAUNCH_PROCESS']
LaunchProcess(vAR_CSLAB_LAUNCH_PROCESS)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_LIST_RUNNING_PROCESSES_AUTOMAGICA
Purpose : A Program in Python for Listing Running Process using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 11:09 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Listing Running Process using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
ListRunningProcesses()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_RETURN_ELEMENTS_AUTOMAGICA
Purpose : A Program in Python for Returning Row Data as a List from Excel using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 11:29 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Returning Row Data as a List from Excel using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_TEST_DATA = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_324_TEST_DATA']
ExcelPutRowInList(path=vAR_CSLAB_TEST_DATA, start_cell="F7", end_cell="J8", sheet=None)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_EXTRACT_TEXT_FROM_PDF_AUTOMAGICA
Purpose : A Program in Python for Extracting Text from PDF using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 11:48 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Extracting Text from PDF using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_PRODUCTION_DECLINE = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_325_PRODUCTION_DECLINE']
ExtractTextFromPDFPage(path=vAR_CSLAB_PRODUCTION_DECLINE, page=1)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_MERGE_PDF_AUTOMAGICA
Purpose : A Program in Python for Merging PDF's using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 12:03 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Merging PDF's using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_ELEVATOR_A = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_326_ELEVATOR_A']
vAR_CSLAB_ELEVATOR_B = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_326_ELEVATOR_B']
vAR_CSLAB_ELEVATOR_Merged = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_326_ELEVATOR_Merged']
MergePDF(pdf1=vAR_CSLAB_ELEVATOR_B, pdf2=vAR_CSLAB_ELEVATOR_A, merged_path=vAR_CSLAB_ELEVATOR_Merged)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_FILE_MANIPULATION_RENAME_FILE_AUTOMAGICA
Purpose : A Program in Python for Renaming File using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 12:23 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Renaming File using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_A = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_327_A']
vAR_CSLAB_B = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_327_B']
vAR_CSLAB_C = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_327_C']
RenameFile(vAR_CSLAB_A, "New_A.pdf")
RenameFile(vAR_CSLAB_A, "New_B.pdf")
RenameFile(vAR_CSLAB_A, "New_C.pdf")
print("Renamed Files Sucessfully")
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_FILE_MANIPULATION_MOVING_FILE_AUTOMAGICA
Purpose : A Program in Python for Moving Files to a New Location using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 12:42 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Moving Files to a New Location using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_A_OLD_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_328_A_OLD_PATH']
vAR_CSLAB_B_OLD_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_328_B_OLD_PATH']
vAR_CSLAB_C_OLD_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_328_C_OLD_PATH']
vAR_CSLAB_A_NEW_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_328_A_NEW_PATH']
vAR_CSLAB_B_NEW_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_328_B_NEW_PATH']
vAR_CSLAB_C_NEW_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_328_C_NEW_PATH']
MoveFile(old_path= "vAR_CSLAB_A_OLD_PATH", new_location="vAR_CSLAB_A_NEW_PATH")
MoveFile(old_path= "vAR_CSLAB_B_OLD_PATH", new_location="vAR_CSLAB_B_NEW_PATH")
MoveFile(old_path= "vAR_CSLAB_C_OLD_PATH", new_location="vAR_CSLAB_C_NEW_PATH")
print("Moved File Sucessfully")
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_FILE_MANIPULATION_COPYING_FILE_AUTOMAGICA
Purpose : A Program in Python for Copying Files to a New Location using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 12:57 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Copying Files to a New Location using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_A_OLD_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_329_A_OLD_PATH']
vAR_CSLAB_B_OLD_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_329_B_OLD_PATH']
vAR_CSLAB_C_OLD_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_329_C_OLD_PATH']
vAR_CSLAB_A_NEW_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_329_A_NEW_PATH']
vAR_CSLAB_B_NEW_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_329_B_NEW_PATH']
vAR_CSLAB_C_NEW_PATH = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_329_C_NEW_PATH']
MoveFile(old_path= "vAR_CSLAB_A_OLD_PATH",new_location="vAR_CSLAB_A_NEW_PATH")
MoveFile(old_path= "vAR_CSLAB_B_OLD_PATH",new_location="vAR_CSLAB_B_NEW_PATH")
MoveFile(old_path= "vAR_CSLAB_C_OLD_PATH", new_location="vAR_CSLAB_C_NEW_PATH")
print("Copied File Sucessfully")
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_IMAGE_OPERATION_OPEN_IMAGE_AUTOMAGICA
Purpose : A Program in Python for Opening an Image using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 13:43 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Opening an Image using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_OPEN_IMAGE = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_330_OPEN_IMAGE']
OpenImage(path=vAR_CSLAB_OPEN_IMAGE)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_IMAGE_OPERATION_ROTATING_IMAGE_AUTOMAGICA
Purpose : A Program in Python for Rotating an Image using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 14:03 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Rotating an Image using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_OPEN_IMAGE = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_330_OPEN_IMAGE']
OpenImage(path=vAR_CSLAB_OPEN_IMAGE)
RotateImage(path=vAR_CSLAB_OPEN_IMAGE,angle=90)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_IMAGE_OPERATION_RESIZING_IMAGE_AUTOMAGICA
Purpose : A Program in Python for Resizing an Image using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 14:21 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Resizing an Image using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_OPEN_IMAGE = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_330_OPEN_IMAGE']
OpenImage(path=vAR_CSLAB_OPEN_IMAGE)
RotateImage(path=vAR_CSLAB_OPEN_IMAGE,angle=90)
ResizeImage(path=vAR_CSLAB_OPEN_IMAGE,size=(1024, 768))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_STRINGS_AUTOMAGICA
Purpose : A Program in Python for Strings using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 14:38 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Strings using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
vAR_CSLAB_automagica_string = "Hi Iam Python"
DisplayMessageBox(vAR_CSLAB_automagica_string)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_RPA_STRING_MANIPULATION_AUTOMAGICA
Purpose : A Program in Python for String Manipulation using Automagica
Author : DeepSphere.AI, Inc.
Date and Time : 02/01/2019 14:55 hrs
Version : 1.0
/***********************************************
## Program Description : Program for String Manipulation using Automagica in Python
## Python Development Environment & Runtime - Python, Anaconda
from automagica import *
vAR_CSLAB_automagica_string = "robot number"
vAR_CSLAB_automagica_integer = 100
vAR_CSLAB_automagica_string2 = vAR_CSLAB_automagica_string + str( vAR_CSLAB_automagica_integer)
DisplayMessageBox(vAR_CSLAB_automagica_string2)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_INTRODUCTION
Purpose : A Program in Python for Introduction to Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 03/01/2019 9:55 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Introduction to Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda
import tensorflow as vAR_tf # deep learning library. Tensors are just multi-dimensional arrays
vAR_CSLAB_mnist = vAR_tf.keras.datasets.mnist # mnist is a dataset of 28x28 images of handwritten digits and their labels
(vAR_CSLAB_x_train, vAR_CSLAB_y_train),(vAR_CSLAB_x_test, vAR_CSLAB_y_test) = vAR_CSLAB_mnist.load_data() # unpacks images to x_train/x_test and labels to y_train/y_test
vAR_CSLAB_x_train = vAR_tf.keras.utils.normalize(vAR_CSLAB_x_train, axis=1) # scales data between 0 and 1
vAR_CSLAB_x_test = vAR_tf.keras.utils.normalize(vAR_CSLAB_x_test, axis=1) # scales data between 0 and 1
vAR_CSLAB_model = vAR_tf.keras.models.Sequential() # a basic feed-forward model
vAR_CSLAB_model.add(vAR_tf.keras.layers.Flatten()) # takes our 28x28 and makes it 1x784
vAR_CSLAB_model.add(vAR_tf.keras.layers.Dense(128, activation=vAR_tf.nn.relu)) # a simple fully-connected layer, 128 units, relu activation
vAR_CSLAB_model.add(vAR_tf.keras.layers.Dense(128, activation=vAR_tf.nn.relu)) # a simple fully-connected layer, 128 units, relu activation
vAR_CSLAB_model.add(vAR_tf.keras.layers.Dense(10, activation=vAR_tf.nn.softmax)) # our output layer. 10 units for 10 classes. Softmax for probability distribution
vAR_CSLAB_model.compile(optimizer='adam', # Good default optimizer to start with
loss='sparse_categorical_crossentropy', # how will we calculate our "error." Neural network aims to minimize loss.
metrics=['accuracy']) # what to track
vAR_CSLAB_model.fit(vAR_CSLAB_x_train, vAR_CSLAB_y_train, epochs=3) # train the model
vAR_CSLAB_val_loss, vAR_CSLAB_val_acc = vAR_CSLAB_model.evaluate(vAR_CSLAB_x_test, vAR_CSLAB_y_test) # evaluate the out of sample data with model
print(vAR_CSLAB_val_loss) # model's loss (error)
print(vAR_CSLAB_val_acc) # model's accuracy
vAR_CSLAB_model.save('epic_num_reader.model')
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_LOADING_OUR_OWN_TRAINING_DATA
Purpose : A Program in Python for Our Own Training Data using Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 03/01/2019 10:31 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Our Own Training Data to Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
import matplotlib.pyplot as vAR_plt
import cv2
from tqdm import tqdm
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_PET_IMAGES = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_336_PET_IMAGES']
vAR_CSLAB_DATADIR = vAR_CSLAB_PET_IMAGES
vAR_CSLAB_CATEGORIES = ["Dog", "Cat"]
for vAR_CSLAB_category in vAR_CSLAB_CATEGORIES: # do dogs and cats
vAR_CSLAB_path = os.path.join(vAR_CSLAB_DATADIR,vAR_CSLAB_category) # create path to dogs and cats
for vAR_CSLAB_img in os.listdir(vAR_CSLAB_path): # iterate over each image per dogs and cats
vAR_CSLAB_img_array = cv2.imread(os.path.join(vAR_CSLAB_path,vAR_CSLAB_img) ,cv2.IMREAD_GRAYSCALE) # convert to array
vAR_plt.imshow(vAR_CSLAB_img_array, cmap='gray') # graph it
vAR_plt.show() # display!
break # we just want one for now so break
break #...and one more!
vAR_CSLAB_IMG_SIZE = 50
vAR_CSLAB_new_array = cv2.resize(vAR_CSLAB_img_array, (vAR_CSLAB_IMG_SIZE, vAR_CSLAB_IMG_SIZE))
vAR_plt.imshow(vAR_CSLAB_new_array, cmap='gray')
vAR_plt.show()
vAR_CSLAB_training_data = []
def vAR_CSLAB_create_training_data():
for vAR_CSLAB_category in vAR_CSLAB_CATEGORIES: # do dogs and cats
vAR_CSLAB_path = os.path.join(vAR_CSLAB_DATADIR,vAR_CSLAB_category) # create path to dogs and cats
vAR_CSLAB_class_num = vAR_CSLAB_CATEGORIES.index(vAR_CSLAB_category) # get the classification (0 or a 1). 0=dog 1=cat
for vAR_CSLAB_img in tqdm(os.listdir(vAR_CSLAB_path)): # iterate over each image per dogs and cats
try:
vAR_CSLAB_img_array = cv2.imread(os.path.join(vAR_CSLAB_path,vAR_CSLAB_img) ,cv2.IMREAD_GRAYSCALE) # convert to array
vAR_CSLAB_new_array = cv2.resize(vAR_CSLAB_img_array, (vAR_CSLAB_IMG_SIZE, vAR_CSLAB_IMG_SIZE)) # resize to normalize data size
vAR_CSLAB_training_data.append([vAR_CSLAB_new_array, vAR_CSLAB_class_num]) # add this to our training_data
except vAR_CSLAB_Exception as vAR_CSLAB_e: # in the interest in keeping the output clean...
pass
#except OSError as e:
# print("OSErrroBad img most likely", e, os.path.join(path,img))
#except Exception as e:
# print("general exception", e, os.path.join(path,img))
vAR_CSLAB_create_training_data()
print(len(vAR_CSLAB_training_data))
import random
random.shuffle(vAR_CSLAB_training_data)
for vAR_CSLAB_sample in vAR_CSLAB_training_data[:10]:
print(vAR_CSLAB_sample[1])
vAR_CSLAB_X = []
vAR_CSLAB_y = []
for vAR_CSLAB_features,vAR_CSLAB_label in vAR_CSLAB_training_data:
vAR_CSLAB_X.append(vAR_CSLAB_features)
vAR_CSLAB_y.append(vAR_CSLAB_label)
#print(vAR_CSLAB_X[0].reshape(-1, vAR_CSLAB_IMG_SIZE, vAR_CSLAB_IMG_SIZE, 1))
vAR_CSLAB_X = vAR_np.array(vAR_CSLAB_X).reshape(-1, vAR_CSLAB_IMG_SIZE, vAR_CSLAB_IMG_SIZE, 1)
import pickle
vAR_CSLAB_pickle_out = open("vAR_CSLAB_X.pickle","wb")
pickle.dump(vAR_CSLAB_X, vAR_CSLAB_pickle_out)
vAR_CSLAB_pickle_out.close()
vAR_CSLAB_pickle_out = open("vAR_CSLAB_y.pickle","wb")
pickle.dump(vAR_CSLAB_y, vAR_CSLAB_pickle_out)
vAR_CSLAB_pickle_out.close()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_CONVOLUTIONAL_NEURAL_NETWORKS
Purpose : A Program in Python for Convlutional Neural Networks using Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 03/01/2019 11:18 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Convlutional Neural Networks using Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda
import tensorflow as vAR_tf
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
import pickle
vAR_CSLAB_pickle_in = open("vAR_CSLAB_X.pickle","rb")
vAR_CSLAB_X = pickle.load(vAR_CSLAB_pickle_in)
vAR_CSLAB_pickle_in = open("vAR_CSLAB_y.pickle","rb")
vAR_CSLAB_y = pickle.load(vAR_CSLAB_pickle_in)
vAR_CSLAB_X = vAR_CSLAB_X/255.0
vAR_CSLAB_model = Sequential()
vAR_CSLAB_model.add(Conv2D(256, (3, 3), input_shape=vAR_CSLAB_X.shape[1:]))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Conv2D(256, (3, 3)))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors
vAR_CSLAB_model.add(Dense(64))
vAR_CSLAB_model.add(Dense(1))
vAR_CSLAB_model.add(Activation('sigmoid'))
vAR_CSLAB_model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
vAR_CSLAB_model.fit(vAR_CSLAB_X, vAR_CSLAB_y, batch_size=32, epochs=3, validation_split=0.3)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_ANALYZING_MODELS_WITH_TENSORBOARD
Purpose : A Program in Python for Analyzing Models with Tensorboard using Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 03/01/2019 12:06 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Analyzing Models with Tensorboard using Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda
import tensorflow as vAR_tf
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.callbacks import TensorBoard
import pickle
vAR_CSLAB_pickle_in = open("vAR_CSLAB_X.pickle","rb")
vAR_CSLAB_X = pickle.load(vAR_CSLAB_pickle_in)
vAR_CSLAB_pickle_in = open("vAR_CSLAB_y.pickle","rb")
vAR_CSLAB_y = pickle.load(vAR_CSLAB_pickle_in)
vAR_CSLAB_X = vAR_CSLAB_X/255.0
vAR_CSLAB_model = Sequential()
vAR_CSLAB_model.add(Conv2D(64, (3, 3), input_shape=vAR_CSLAB_X.shape[1:]))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Conv2D(64, (3, 3)))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors
vAR_CSLAB_model.add(Dense(64))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(Dense(1))
vAR_CSLAB_model.add(Activation('sigmoid'))
vAR_CSLAB_NAME = "Cats-vs-dogs-64x2-CNN"
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_TENSORBOARD = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_338_TENSORBOARD_LOG']
vAR_CSLAB_tensorboard = TensorBoard(log_dir=vAR_CSLAB_TENSORBOARD.format(vAR_CSLAB_NAME))
vAR_CSLAB_model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])
vAR_CSLAB_model.fit(vAR_CSLAB_X, vAR_CSLAB_y,batch_size=32,epochs=30,validation_split=0.3,callbacks=[vAR_CSLAB_tensorboard])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_OPTIMIZING_MODELS_WITH_TENSORBOARD
Purpose : A Program in Python for Optimizing Models with Tensorboard using Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 03/01/2019 13:12 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Optimizing Models with Tensorboard using Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.callbacks import TensorBoard
import pickle
import time
vAR_CSLAB_pickle_in = open("vAR_CSLAB_X.pickle","rb")
vAR_CSLAB_X = pickle.load(vAR_CSLAB_pickle_in)
vAR_CSLAB_pickle_in = open("vAR_CSLAB_y.pickle","rb")
vAR_CSLAB_y = pickle.load(vAR_CSLAB_pickle_in)
vAR_CSLAB_X = vAR_CSLAB_X/255.0
vAR_CSLAB_dense_layers = [0, 1, 2]
vAR_CSLAB_layer_sizes = [32, 64, 128]
vAR_CSLAB_conv_layers = [1, 2, 3]
for dense_layer in vAR_CSLAB_dense_layers:
for layer_size in vAR_CSLAB_layer_sizes:
for conv_layer in vAR_CSLAB_conv_layers:
vAR_CSLAB_NAME = "{}-conv-{}-nodes-{}-dense-{}".format(conv_layer, layer_size, dense_layer, int(time.time()))
vAR_CSLAB_model = Sequential()
vAR_CSLAB_model.add(Conv2D(layer_size, (3, 3), input_shape=vAR_CSLAB_X.shape[1:]))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
for l in range(conv_layer-1):
vAR_CSLAB_model.add(Conv2D(layer_size, (3, 3)))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors
for _ in range(dense_layer):
vAR_CSLAB_model.add(Dense(layer_size))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(Dense(1))
vAR_CSLAB_model.add(Activation('sigmoid'))
vAR_CSLAB_NAME = "Cats-vs-dogs-64x2-CNN"
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_TENSORBOARD = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_338_TENSORBOARD_LOG']
vAR_CSLAB_tensorboard = TensorBoard(log_dir=vAR_CSLAB_TENSORBOARD.format(vAR_CSLAB_NAME))
vAR_CSLAB_model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])
vAR_CSLAB_model.fit(vAR_CSLAB_X, vAR_CSLAB_y,batch_size=32,epochs=30,validation_split=0.3,callbacks=[vAR_CSLAB_tensorboard])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_USE_TRAINED_MODEL
Purpose : A Program in Python for Using a Trained Model using Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 03/01/2019 14:21 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Using a Trained Model using Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.callbacks import TensorBoard
import pickle
import time
vAR_CSLAB_pickle_in = open("vAR_CSLAB_X.pickle","rb")
vAR_CSLAB_X = pickle.load(vAR_CSLAB_pickle_in)
vAR_CSLAB_pickle_in = open("vAR_CSLAB_y.pickle","rb")
vAR_CSLAB_y = pickle.load(vAR_CSLAB_pickle_in)
vAR_CSLAB_X = vAR_CSLAB_X/255.0
vAR_CSLAB_dense_layers = [0, 1, 2]
vAR_CSLAB_layer_sizes = [32, 64, 128]
vAR_CSLAB_conv_layers = [1, 2, 3]
for dense_layer in vAR_CSLAB_dense_layers:
for layer_size in vAR_CSLAB_layer_sizes:
for conv_layer in vAR_CSLAB_conv_layers:
vAR_CSLAB_NAME = "{}-conv-{}-nodes-{}-dense-{}".format(conv_layer, layer_size, dense_layer, int(time.time()))
vAR_CSLAB_model = Sequential()
vAR_CSLAB_model.add(Conv2D(layer_size, (3, 3), input_shape=vAR_CSLAB_X.shape[1:]))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
for l in range(conv_layer-1):
vAR_CSLAB_model.add(Conv2D(layer_size, (3, 3)))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors
for _ in range(dense_layer):
vAR_CSLAB_model.add(Dense(layer_size))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(Dense(1))
vAR_CSLAB_model.add(Activation('sigmoid'))
vAR_CSLAB_NAME = "Cats-vs-dogs-64x2-CNN"
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_TENSORBOARD = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_338_TENSORBOARD_LOG']
vAR_CSLAB_tensorboard = TensorBoard(log_dir=vAR_CSLAB_TENSORBOARD.format(vAR_CSLAB_NAME))
vAR_CSLAB_model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])
vAR_CSLAB_model.fit(vAR_CSLAB_X, vAR_CSLAB_y,batch_size=32,epochs=10,validation_split=0.3,callbacks=[vAR_CSLAB_tensorboard])
vAR_model.save('64x3-CNN.model')
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_RECURRENT_NEURAL_NETWORKS
Purpose : A Program in Python for Recurrent Neural Networks using Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 03/01/2019 15:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Recurrent Neural Networks using Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda
import tensorflow as vAR_tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, LSTM#, CuDNNLSTM
vAR_CSLAB_mnist = vAR_tf.keras.datasets.mnist # mnist is a dataset of 28x28 images of handwritten digits and their labels
(vAR_CSLAB_x_train, vAR_CSLAB_y_train),(vAR_CSLAB_x_test, vAR_CSLAB_y_test) = vAR_CSLAB_mnist.load_data() # unpacks images to x_train/x_test and labels to y_train/y_test
vAR_CSLAB_x_train = vAR_CSLAB_x_train/255.0
vAR_CSLAB_x_test = vAR_CSLAB_x_test/255.0
print(vAR_CSLAB_x_train.shape)
print(vAR_CSLAB_x_train[0].shape)
vAR_CSLAB_model = Sequential()
# IF you are running with a GPU, try out the CuDNNLSTM layer type instead (don't pass an activation, tanh is required)
vAR_CSLAB_model.add(LSTM(128, input_shape=(vAR_CSLAB_x_train.shape[1:]), activation='relu', return_sequences=True))
vAR_CSLAB_model.add(Dropout(0.2))
vAR_CSLAB_model.add(LSTM(128, activation='relu'))
vAR_CSLAB_model.add(Dropout(0.1))
vAR_CSLAB_model.add(Dense(32, activation='relu'))
vAR_CSLAB_model.add(Dropout(0.2))
vAR_CSLAB_model.add(Dense(10, activation='softmax'))
vAR_CSLAB_opt = vAR_tf.keras.optimizers.Adam(lr=0.001, decay=1e-6)
# Compile model
vAR_CSLAB_model.compile(loss='sparse_categorical_crossentropy',optimizer=vAR_CSLAB_opt,metrics=['accuracy'])
vAR_CSLAB_model.fit(vAR_CSLAB_x_train,vAR_CSLAB_y_train,epochs=3,validation_data=(vAR_CSLAB_x_test, vAR_CSLAB_y_test))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_NORMALIZING_CREATING_SEQUENCES
Purpose : A Program in Python for Normalizing & Creating Sequences using Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 04/01/2019 16:24 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Normalizing & Creating Sequences using Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda
import pandas as vAR_pd
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_CREATE_SEQUENCES = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_342_CREATE_SEQUENCES']
vAR_CSLAB_df = vAR_pd.read_csv(vAR_CSLAB_CREATE_SEQUENCES, names=['time', 'low', 'high', 'open', 'close', 'volume'])
print(vAR_CSLAB_df.head())
vAR_CSLAB_main_df = vAR_pd.DataFrame() # begin empty
ratios = ["BTC-USD", "LTC-USD", "BCH-USD", "ETH-USD"] # the 4 ratios we want to consider
for ratio in ratios: # begin iteration
print(ratio)
vAR_CSLAB_dataset = "C:/Python_Programs/crypto_data/BTC-USD.csv" # get the full path to the file.
vAR_CSLAB_df = vAR_pd.read_csv(vAR_CSLAB_dataset, names=['time', 'low', 'high', 'open', 'close', 'volume']) # read in specific file
# rename volume and close to include the ticker so we can still which close/volume is which:
vAR_CSLAB_df.rename(columns={"close": f"{ratio}_close", "volume": f"{ratio}_volume"}, inplace=True)
vAR_CSLAB_df.set_index("time", inplace=True) # set time as index so we can join them on this shared time
vAR_CSLAB_df = vAR_CSLAB_df[[f"{ratio}_close", f"{ratio}_volume"]] # ignore the other columns besides price and volume
if len(vAR_CSLAB_main_df)==0: # if the dataframe is empty
vAR_CSLAB_main_df = vAR_CSLAB_df # then it's just the current df
else: # otherwise, join this data to the main one
vAR_CSLAB_main_df = vAR_CSLAB_main_df.join(vAR_CSLAB_df)
vAR_CSLAB_main_df.fillna(method="ffill", inplace=True) # if there are gaps in data, use previously known values
vAR_CSLAB_main_df.dropna(inplace=True)
print(vAR_CSLAB_main_df.head()) # how did we do??
vAR_CSLAB_SEQ_LEN = 60 # how long of a preceeding sequence to collect for RNN
vAR_CSLAB_FUTURE_PERIOD_PREDICT = 3 # how far into the future are we trying to predict?
vAR_CSLAB_RATIO_TO_PREDICT = "LTC-USD"
def classify(current, future):
if float(future) > float(current):
return 1
else:
return 0
vAR_CSLAB_main_df['future'] = vAR_CSLAB_main_df[f'{vAR_CSLAB_RATIO_TO_PREDICT}_close'].shift(-vAR_CSLAB_FUTURE_PERIOD_PREDICT)
vAR_CSLAB_main_df['target'] = list(map(classify, vAR_CSLAB_main_df[f'{vAR_CSLAB_RATIO_TO_PREDICT}_close'], vAR_CSLAB_main_df['future']))
print(vAR_CSLAB_main_df.head())
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_KERAS_MNIST_CLASSIFICATION
Purpose : A Program in Python for MNIST Number Classification using Keras Library in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 10:04 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for MNIST Number Classification using Keras Library in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
vAR_CSLAB_batch_size = 128
vAR_CSLAB_num_classes = 10
vAR_CSLAB_epochs = 1
# input image dimensions
vAR_CSLAB_img_rows, vAR_CSLAB_img_cols = 28, 28
# the data, split between train and test sets
(vAR_CSLAB_x_train, vAR_CSLAB_y_train), (vAR_CSLAB_x_test, vAR_CSLAB_y_test) = mnist.load_data()
if K.image_data_format() == 'channels_first':
vAR_CSLAB_x_train = vAR_CSLAB_x_train.reshape(vAR_CSLAB_x_train.shape[0], 1, vAR_CSLAB_img_rows, vAR_CSLAB_img_cols)
vAR_CSLAB_x_test = vAR_CSLAB_x_test.reshape(vAR_CSLAB_x_test.shape[0], 1, vAR_CSLAB_img_rows, vAR_CSLAB_img_cols)
vAR_CSLAB_input_shape = (1, vAR_CSLAB_img_rows, vAR_CSLAB_img_cols)
else:
vAR_CSLAB_x_train = vAR_CSLAB_x_train.reshape(vAR_CSLAB_x_train.shape[0], vAR_CSLAB_img_rows, vAR_CSLAB_img_cols, 1)
vAR_CSLAB_x_test = vAR_CSLAB_x_test.reshape(vAR_CSLAB_x_test.shape[0], vAR_CSLAB_img_rows, vAR_CSLAB_img_cols, 1)
vAR_CSLAB_input_shape = (vAR_CSLAB_img_rows, vAR_CSLAB_img_cols, 1)
vAR_CSLAB_x_train = vAR_CSLAB_x_train.astype('float32')
vAR_CSLAB_x_test = vAR_CSLAB_x_test.astype('float32')
vAR_CSLAB_x_train /= 255
vAR_CSLAB_x_test /= 255
print('vAR_CSLAB_x_train shape:', vAR_CSLAB_x_train.shape)
print(vAR_CSLAB_x_train.shape[0], 'train samples')
print(vAR_CSLAB_x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
vAR_CSLAB_y_train = keras.utils.to_categorical(vAR_CSLAB_y_train, vAR_CSLAB_num_classes)
vAR_CSLAB_y_test = keras.utils.to_categorical(vAR_CSLAB_y_test, vAR_CSLAB_num_classes)
vAR_CSLAB_model = Sequential()
vAR_CSLAB_model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=vAR_CSLAB_input_shape))
vAR_CSLAB_model.add(Conv2D(64, (3, 3), activation='relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Dropout(0.25))
vAR_CSLAB_model.add(Flatten())
vAR_CSLAB_model.add(Dense(128, activation='relu'))
vAR_CSLAB_model.add(Dropout(0.5))
vAR_CSLAB_model.add(Dense(vAR_CSLAB_num_classes, activation='softmax'))
vAR_CSLAB_model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
vAR_CSLAB_model.fit(vAR_CSLAB_x_train, vAR_CSLAB_y_train,
batch_size=vAR_CSLAB_batch_size,
epochs=vAR_CSLAB_epochs,
verbose=1,
validation_data=(vAR_CSLAB_x_test, vAR_CSLAB_y_test))
vAR_CSLAB_score = vAR_CSLAB_model.evaluate(vAR_CSLAB_x_test, vAR_CSLAB_y_test, verbose=0)
print('Test loss:', vAR_CSLAB_score[0])
print('Test accuracy:', vAR_CSLAB_score[1])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_LINEAR_REGRESSION_V1
Purpose : A Program in Python for Linear Regression - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 10:52 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Linear Regression - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import numpy as vAR_np
import tensorflow as vAR_tf
import matplotlib.pyplot as vAR_plt
vAR_np.random.seed(101)
vAR_tf.set_random_seed(101)
# Genrating random linear data
# There will be 50 data points ranging from 0 to 50
vAR_CSLAB_x = vAR_np.linspace(0, 50, 50)
vAR_CSLAB_y = vAR_np.linspace(0, 50, 50)
# Adding noise to the random linear data
vAR_CSLAB_x += vAR_np.random.uniform(-4, 4, 50)
vAR_CSLAB_y += vAR_np.random.uniform(-4, 4, 50)
vAR_CSLAB_n = len(vAR_CSLAB_x) # Number of data points
vAR_CSLAB_X = vAR_tf.placeholder("float")
vAR_CSLAB_Y = vAR_tf.placeholder("float")
vAR_CSLAB_W = vAR_tf.Variable(vAR_np.random.randn(), name = "W")
vAR_CSLAB_b = vAR_tf.Variable(vAR_np.random.randn(), name = "b")
vAR_CSLAB_learning_rate = 0.01
vAR_CSLAB_training_epochs = 1000
# Hypothesis
vAR_CSLAB_y_pred = vAR_tf.add(vAR_tf.multiply(vAR_CSLAB_X, vAR_CSLAB_W), vAR_CSLAB_b)
# MeanvAR_ Squared Error Cost Function
vAR_CSLAB_cost = vAR_tf.reduce_sum(vAR_tf.pow(vAR_CSLAB_y_pred-vAR_CSLAB_Y, 2)) / (2 * vAR_CSLAB_n)
# Gradient Descent Optimizer
vAR_CSLAB_optimizer = vAR_tf.train.GradientDescentOptimizer(vAR_CSLAB_learning_rate).minimize(vAR_CSLAB_cost)
# Global Variables Initializer
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
# Starting the Tensorflow Session
with vAR_tf.Session() as sess:
# Initializing the Variables
sess.run(vAR_CSLAB_init)
# Iterating through all the epochs
for epoch in range(vAR_CSLAB_training_epochs):
# Feeding each data point into the optimizer using Feed Dictionary
for (_x, _y) in zip(vAR_CSLAB_x, vAR_CSLAB_y):
sess.run(vAR_CSLAB_optimizer, feed_dict = {vAR_CSLAB_X : _x, vAR_CSLAB_Y : _y})
# Displaying the result after every 50 epochs
if (epoch + 1) % 50 == 0:
# Calculating the cost a every epoch
vAR_CSLAB_c = sess.run(vAR_CSLAB_cost, feed_dict = {vAR_CSLAB_X : vAR_CSLAB_x, vAR_CSLAB_Y : vAR_CSLAB_y})
print("Epoch", (epoch + 1), ": vAR_CSLAB_cost =", vAR_CSLAB_c, "W =", sess.run(vAR_CSLAB_W), "b =", sess.run(vAR_CSLAB_b))
# Storing necessary values to be used outside the Session
vAR_CSLAB_training_cost = sess.run(vAR_CSLAB_cost, feed_dict ={vAR_CSLAB_X: vAR_CSLAB_x, vAR_CSLAB_Y: vAR_CSLAB_y})
vAR_CSLAB_weight = sess.run(vAR_CSLAB_W)
vAR_CSLAB_bias = sess.run(vAR_CSLAB_b)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_LOGISTIC_REGRESSION_V1
Purpose : A Program in Python for Logistic Regression - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 11:27 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Logistic Regression - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
import numpy as vAR_np
import tensorflow as vAR_tf
import requests
from sklearn import datasets
from sklearn.preprocessing import normalize
from tensorflow.python.framework import ops
ops.reset_default_graph()
vAR_sess = vAR_tf.Session()
vAR_CSLAB_bc = datasets.load_breast_cancer()
vAR_CSLAB_bc.data.shape
vAR_CSLAB_x_vals = vAR_CSLAB_bc.data
vAR_CSLAB_y_vals = vAR_CSLAB_bc.target
vAR_CSLAB_train_indices = vAR_np.random.choice(len(vAR_CSLAB_x_vals), round(len(vAR_CSLAB_x_vals)*0.8), replace=False)
vAR_CSLAB_test_indices = vAR_np.array(list(set(range(len(vAR_CSLAB_x_vals))) - set(vAR_CSLAB_train_indices)))
vAR_CSLAB_x_vals_train = vAR_CSLAB_x_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_x_vals_test = vAR_CSLAB_x_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_y_vals_train = vAR_CSLAB_y_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_y_vals_test = vAR_CSLAB_y_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_batch_size = 25
vAR_CSLAB_x_data = vAR_tf.placeholder(shape=[None, 30], dtype=vAR_tf.float32)
vAR_CSLAB_y_target = vAR_tf.placeholder(shape=[None, 1], dtype=vAR_tf.float32)
vAR_CSLAB_A = vAR_tf.Variable(vAR_tf.random_normal(shape=[30,1]))
vAR_CSLAB_b = vAR_tf.Variable(vAR_tf.random_normal(shape=[1,1]))
vAR_CSLAB_model_output = vAR_tf.add(vAR_tf.matmul(vAR_CSLAB_x_data, vAR_CSLAB_A), vAR_CSLAB_b)
vAR_CSLAB_loss = vAR_tf.reduce_mean(vAR_tf.nn.sigmoid_cross_entropy_with_logits(logits=vAR_CSLAB_model_output, labels=vAR_CSLAB_y_target))
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
vAR_sess.run(vAR_CSLAB_init)
vAR_CSLAB_my_opt = vAR_tf.train.GradientDescentOptimizer(0.01)
vAR_CSLAB_train_step = vAR_CSLAB_my_opt.minimize(vAR_CSLAB_loss)
vAR_CSLAB_prediction = vAR_tf.round(vAR_tf.sigmoid(vAR_CSLAB_model_output))
vAR_CSLAB_predictions_correct = vAR_tf.cast(vAR_tf.equal(vAR_CSLAB_prediction, vAR_CSLAB_y_target), vAR_tf.float32)
vAR_CSLAB_accuracy = vAR_tf.reduce_mean(vAR_CSLAB_predictions_correct)
vAR_CSLAB_loss_vec = []
vAR_CSLAB_train_acc = []
vAR_CSLAB_test_acc = []
vAR_CSLAB_loss_vec = []
vAR_CSLAB_train_acc = []
vAR_CSLAB_test_acc = []
for i in range(2000):
vAR_CSLAB_rand_index = vAR_np.random.choice(len(vAR_CSLAB_x_vals_train), size=vAR_CSLAB_batch_size)
vAR_CSLAB_rand_x = vAR_CSLAB_x_vals_train[vAR_CSLAB_rand_index]
vAR_CSLAB_rand_y = vAR_np.transpose([vAR_CSLAB_y_vals_train[vAR_CSLAB_rand_index]])
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_temp_loss = vAR_sess.run(vAR_CSLAB_loss, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_loss_vec.append(vAR_CSLAB_temp_loss)
vAR_CSLAB_temp_acc_train = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_vals_train, vAR_CSLAB_y_target: vAR_np.transpose([vAR_CSLAB_y_vals_train])})
vAR_CSLAB_train_acc.append(vAR_CSLAB_temp_acc_train)
vAR_CSLAB_temp_acc_test = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_vals_test, vAR_CSLAB_y_target: vAR_np.transpose([vAR_CSLAB_y_vals_test])})
vAR_CSLAB_test_acc.append(int(vAR_CSLAB_temp_acc_test))
print((vAR_CSLAB_temp_acc_test))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNNG_RANDOM_FOREST_V1
Purpose : A Program in Python for Random Forest - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 11:59 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Random Forest - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
from __future__ import print_function
import numpy as vAR_np
import sklearn
from sklearn import datasets
import pandas as vAR_pd
import tensorflow as vAR_tf
#from tensorflow.contrib.tensor_forest.python import tensor_forest
from tensorflow.python.ops import resources
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_DATA = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_245_TENSORFLOW_RF']
vAR_CSLAB_data = vAR_pd.read_csv(vAR_CSLAB_DATA)
vAR_CSLAB_input_x = vAR_CSLAB_data.iloc[:, 0:-1].values
vAR_CSLAB_input_y = vAR_CSLAB_data.iloc[:,4].values
from sklearn.model_selection import train_test_split
vAR_CSLAB_X_train, vAR_CSLAB_X_test, vAR_CSLAB_y_train, vAR_CSLAB_y_test = train_test_split(vAR_CSLAB_input_x, vAR_CSLAB_input_y, test_size = 0.25, random_state = 0)
vAR_CSLAB_data1 = vAR_CSLAB_data.iloc[:,:].values
# Parameters
vAR_CSLAB_num_steps = 100 # Total steps to train
vAR_CSLAB_num_classes = 2
vAR_CSLAB_num_features = 108
vAR_CSLAB_num_trees = 10
vAR_CSLAB_max_nodes = 1000
# Input and Target placeholders
vAR_CSLAB_X = vAR_tf.placeholder(vAR_tf.float32, shape=[None, vAR_CSLAB_num_features])
vAR_CSLAB_Y = vAR_tf.placeholder(vAR_tf.int64, shape=[None])
print(vAR_CSLAB_X)
print(vAR_CSLAB_Y)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNNG_KMEANS_CLUSTERING_V1
Purpose : A Program in Python for Kmeans Clustering - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 12:23 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Kmeans Clustering - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
import numpy as vAR_np
vAR_CSLAB_seed = 700
def vAR_CSLAB_create_samples(vAR_CSLAB_n_clusters, vAR_CSLAB_n_samples_per_cluster, vAR_CSLAB_n_features, vAR_CSLAB_embiggen_factor, vAR_CSLAB_seed):
vAR_np.random.seed(vAR_CSLAB_seed)
vAR_CSLAB_slices = []
vAR_CSLAB_centroids = []
# Create samples for each cluster
for i in range(vAR_CSLAB_n_clusters):
vAR_CSLAB_samples = vAR_tf.random_normal((vAR_CSLAB_n_samples_per_cluster, vAR_CSLAB_n_features),
mean=0.0, stddev=5.0, dtype=vAR_tf.float32, seed=vAR_CSLAB_seed, name="cluster_{}".format(i))
vAR_CSLAB_current_centroid = (vAR_np.random.random((1, vAR_CSLAB_n_features)) * vAR_CSLAB_embiggen_factor) - (vAR_CSLAB_embiggen_factor/2)
vAR_CSLAB_centroids.append(vAR_CSLAB_current_centroid)
vAR_CSLAB_samples += vAR_CSLAB_current_centroid
vAR_CSLAB_slices.append(vAR_CSLAB_samples)
# Create a big "samples" dataset
vAR_CSLAB_samples = vAR_tf.concat(vAR_CSLAB_slices, 0, name='samples')
vAR_CSLAB_centroids = vAR_tf.concat(vAR_CSLAB_centroids, 0, name='centroids')
return vAR_CSLAB_centroids, vAR_CSLAB_samples
import matplotlib.pyplot as vAR_plt
%matplotlib inline
def vAR_CSLAB_plot_clusters(vAR_CSLAB_all_samples, vAR_CSLAB_centroids, vAR_CSLAB_n_samples_per_cluster):
#Plot out the different clusters
#Choose a different colour for each cluster
vAR_CSLAB_colour = vAR_plt.cm.rainbow(vAR_np.linspace(0,1,len(vAR_CSLAB_centroids)))
for i, vAR_CSLAB_centroid in enumerate(vAR_CSLAB_centroids):
vAR_CSLAB_samples = vAR_CSLAB_all_samples[i*vAR_CSLAB_n_samples_per_cluster:(i+1)*vAR_CSLAB_n_samples_per_cluster]
vAR_plt.scatter(vAR_CSLAB_samples[:,0], vAR_CSLAB_samples[:,1], c=vAR_CSLAB_colour[i])
#Grab just the samples fpr the given cluster and plot them out with a new colour
#Also plot centroid
vAR_plt.plot(vAR_CSLAB_centroid[0], vAR_CSLAB_centroid[1], markersize=35, marker="x", color='k', mew=10)
vAR_plt.plot(vAR_CSLAB_centroid[0], vAR_CSLAB_centroid[1], markersize=30, marker="x", color='m', mew=5)
vAR_plt.show()
vAR_CSLAB_n_features = 2
vAR_CSLAB_n_clusters = 3
vAR_CSLAB_n_samples_per_cluster = 500
vAR_CSLAB_vAR_CSLAB_seed = 700
vAR_CSLAB_embiggen_factor = 70
vAR_CSLAB_centroids, vAR_CSLAB_samples = vAR_CSLAB_create_samples(vAR_CSLAB_n_clusters, vAR_CSLAB_n_samples_per_cluster, vAR_CSLAB_n_features, vAR_CSLAB_embiggen_factor, vAR_CSLAB_seed)
vAR_CSLAB_model = vAR_tf.global_variables_initializer()
with vAR_tf.Session() as session:
vAR_CSLAB_sample_values = session.run(vAR_CSLAB_samples)
vAR_CSLAB_centroid_values = session.run(vAR_CSLAB_centroids)
vAR_CSLAB_plot_clusters(vAR_CSLAB_sample_values, vAR_CSLAB_centroid_values, vAR_CSLAB_n_samples_per_cluster)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNNG_LINEAR_SUPPORT_VECTOR_MACHINE_V1
Purpose : A Program in Python for Linear Support Vector Machine - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 13:12 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Linear Support Vector Machine - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
%matplotlib inline
import numpy as vAR_np
import tensorflow as vAR_tf
from sklearn import datasets
vAR_sess = vAR_tf.Session()
vAR_CSLAB_iris = datasets.load_iris()
vAR_CSLAB_x_vals = vAR_np.array([[x[0], x[3]] for x in vAR_CSLAB_iris.data])
vAR_CSLAB_y_vals = vAR_np.array([1 if y==0 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_train_indices = vAR_np.random.choice(len(vAR_CSLAB_x_vals), round(len(vAR_CSLAB_x_vals)*0.8), replace=False)
vAR_CSLAB_test_indices = vAR_np.array(list(set(range(len(vAR_CSLAB_x_vals))) - set(vAR_CSLAB_train_indices)))
vAR_CSLAB_x_vals_train = vAR_CSLAB_x_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_x_vals_test = vAR_CSLAB_x_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_y_vals_train = vAR_CSLAB_y_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_y_vals_test = vAR_CSLAB_y_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_batch_size = 100
vAR_CSLAB_x_data = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_y_target = vAR_tf.placeholder(shape=[None, 1], dtype=vAR_tf.float32)
vAR_CSLAB_A = vAR_tf.Variable(vAR_tf.random_normal(shape=[2,1]))
vAR_CSLAB_b = vAR_tf.Variable(vAR_tf.random_normal(shape=[1,1]))
vAR_CSLAB_model_output = vAR_tf.subtract(vAR_tf.matmul(vAR_CSLAB_x_data, vAR_CSLAB_A), vAR_CSLAB_b)
vAR_CSLAB_l2_norm = vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_A))
vAR_CSLAB_alpha = vAR_tf.constant([0.1])
vAR_CSLAB_classification_term = vAR_tf.reduce_mean(vAR_tf.maximum(0., vAR_tf.subtract(1., vAR_tf.multiply(vAR_CSLAB_model_output, vAR_CSLAB_y_target))))
vAR_CSLAB_loss = vAR_tf.add(vAR_CSLAB_classification_term, vAR_tf.multiply(vAR_CSLAB_alpha, vAR_CSLAB_l2_norm))
vAR_CSLAB_prediction = vAR_tf.sign(vAR_CSLAB_model_output)
vAR_CSLAB_accuracy = vAR_tf.reduce_mean(vAR_tf.cast(vAR_tf.equal(vAR_CSLAB_prediction, vAR_CSLAB_y_target), vAR_tf.float32))
vAR_CSLAB_my_opt = vAR_tf.train.GradientDescentOptimizer(0.01)
vAR_CSLAB_train_step = vAR_CSLAB_my_opt.minimize(vAR_CSLAB_loss)
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
vAR_sess.run(vAR_CSLAB_init)
vAR_CSLAB_loss_vec = []
vAR_CSLAB_train_accuracy = []
vAR_CSLAB_test_accuracy = []
vAR_CSLAB_batch_size=25
for i in range(5000):
vAR_CSLAB_rand_index = vAR_np.random.choice(len(vAR_CSLAB_x_vals_train), size=vAR_CSLAB_batch_size)
vAR_CSLAB_rand_x = vAR_CSLAB_x_vals_train[vAR_CSLAB_rand_index]
vAR_CSLAB_rand_y = vAR_np.transpose([vAR_CSLAB_y_vals_train[vAR_CSLAB_rand_index]])
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_temp_loss = vAR_sess.run(vAR_CSLAB_loss, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_loss_vec.append(vAR_CSLAB_temp_loss)
vAR_CSLAB_train_acc_temp = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_vals_train, vAR_CSLAB_y_target: vAR_np.transpose([vAR_CSLAB_y_vals_train])})
vAR_CSLAB_train_accuracy.append(vAR_CSLAB_train_acc_temp)
vAR_CSLAB_test_acc_temp = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_vals_test, vAR_CSLAB_y_target: vAR_np.transpose([vAR_CSLAB_y_vals_test])})
vAR_CSLAB_test_accuracy.append(vAR_CSLAB_test_acc_temp)
if (i+1)%100==0:
print('Step #' + str(i+1) + ' A = ' + str(vAR_sess.run(vAR_CSLAB_A)) + ' b = ' + str(vAR_sess.run(vAR_CSLAB_b)))
print('Loss = ' + str(vAR_CSLAB_temp_loss))
[[vAR_CSLAB_a1], [vAR_CSLAB_a2]] = vAR_sess.run(vAR_CSLAB_A)
[[vAR_CSLAB_b]] = vAR_sess.run(vAR_CSLAB_b)
vAR_CSLAB_slope = -vAR_CSLAB_a2/vAR_CSLAB_a1
vAR_CSLAB_y_intercept = vAR_CSLAB_b/vAR_CSLAB_a1
vAR_CSLAB_x1_vals = [d[1] for d in vAR_CSLAB_x_vals]
vAR_CSLAB_best_fit = []
for i in vAR_CSLAB_x1_vals:
vAR_CSLAB_best_fit.append(vAR_CSLAB_slope*i+vAR_CSLAB_y_intercept)
vAR_CSLAB_setosa_x = [d[1] for i,d in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==1]
vAR_CSLAB_setosa_y = [d[0] for i,d in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==1]
vAR_CSLAB_not_setosa_x = [d[1] for i,d in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==-1]
vAR_CSLAB_not_setosa_y = [d[0] for i,d in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==-1]
vAR_plt.plot(vAR_CSLAB_setosa_x, vAR_CSLAB_setosa_y, 'o', label='I. setosa')
vAR_plt.plot(vAR_CSLAB_not_setosa_x, vAR_CSLAB_not_setosa_y, 'x', label='Non-setosa')
vAR_plt.plot(vAR_CSLAB_x1_vals, vAR_CSLAB_best_fit, 'r-', label='Linear Separator', linewidth=3)
vAR_plt.ylim([0, 10])
vAR_plt.legend(loc='lower right')
vAR_plt.title('Sepal Length vs Pedal Width')
vAR_plt.xlabel('Pedal Width')
vAR_plt.ylabel('Sepal Length')
vAR_plt.show()
vAR_plt.plot(vAR_CSLAB_train_accuracy, 'k-', label='Training Accuracy')
vAR_plt.plot(vAR_CSLAB_test_accuracy, 'r--', label='Test Accuracy')
vAR_plt.title('Train and Test Set Accuracies')
vAR_plt.xlabel('Generation')
vAR_plt.ylabel('Accuracy')
vAR_plt.legend(loc='lower right')
vAR_plt.show()
vAR_plt.plot(vAR_CSLAB_loss_vec, 'k-')
vAR_plt.title('Loss per Generation')
vAR_plt.xlabel('Generation')
vAR_plt.ylabel('Loss')
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_NON_LINEAR_SUPPORT_VECTOR_MACHINE_V1
Purpose : A Program in Python for Linear Support Vector Machine - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 13:47 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Linear Support Vector Machine - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import matplotlib.pyplot as vAR_plt
%matplotlib inline
import numpy as vAR_np
import tensorflow as vAR_tf
from sklearn import datasets
vAR_sess = vAR_tf.Session()
vAR_CSLAB_iris = datasets.load_iris()
vAR_CSLAB_x_vals = vAR_np.array([[x[0], x[3]] for x in vAR_CSLAB_iris.data])
vAR_CSLAB_y_vals = vAR_np.array([1 if y==0 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_train_indices = vAR_np.random.choice(len(vAR_CSLAB_x_vals), round(len(vAR_CSLAB_x_vals)*0.8), replace=False)
vAR_CSLAB_test_indices = vAR_np.array(list(set(range(len(vAR_CSLAB_x_vals))) - set(vAR_CSLAB_train_indices)))
vAR_CSLAB_x_vals_train = vAR_CSLAB_x_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_x_vals_test = vAR_CSLAB_x_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_y_vals_train = vAR_CSLAB_y_vals[vAR_CSLAB_train_indices]
vAR_CSLAB_y_vals_test = vAR_CSLAB_y_vals[vAR_CSLAB_test_indices]
vAR_CSLAB_batch_size = 101
vAR_CSLAB_x_data = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_y_target = vAR_tf.placeholder(shape=[None, 1], dtype=vAR_tf.float32)
vAR_CSLAB_prediction_grid = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_b = vAR_tf.Variable(vAR_tf.random_normal(shape=[1,vAR_CSLAB_batch_size]))
#Gaussian kernel
vAR_CSLAB_gamma = vAR_tf.constant(-50.0)
vAR_CSLAB_dist = vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_x_data), 1)
vAR_CSLAB_dist = vAR_tf.reshape(vAR_CSLAB_dist, [-1,1])
vAR_CSLAB_sq_dists = vAR_tf.add(vAR_tf.subtract(vAR_CSLAB_dist, vAR_tf.multiply(2., vAR_tf.matmul(vAR_CSLAB_x_data, vAR_tf.transpose(vAR_CSLAB_x_data)))), vAR_tf.transpose(vAR_CSLAB_dist))
vAR_CSLAB_my_kernel = vAR_tf.exp(vAR_tf.multiply(vAR_CSLAB_gamma, vAR_tf.abs(vAR_CSLAB_sq_dists)))
vAR_CSLAB_model_output = vAR_tf.matmul(vAR_CSLAB_b, vAR_CSLAB_my_kernel)
vAR_CSLAB_first_term = vAR_tf.reduce_sum(vAR_CSLAB_b)
vAR_CSLAB_b_vec_cross = vAR_tf.matmul(vAR_tf.transpose(vAR_CSLAB_b), vAR_CSLAB_b)
vAR_CSLAB_y_target_cross = vAR_tf.matmul(vAR_CSLAB_y_target, vAR_tf.transpose(vAR_CSLAB_y_target))
vAR_CSLAB_second_term = vAR_tf.reduce_sum(vAR_tf.multiply(vAR_CSLAB_my_kernel, vAR_tf.multiply(vAR_CSLAB_b_vec_cross, vAR_CSLAB_y_target_cross)))
vAR_CSLAB_loss = vAR_tf.negative(vAR_tf.subtract(vAR_CSLAB_first_term, vAR_CSLAB_second_term))
vAR_CSLAB_rA = vAR_tf.reshape(vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_x_data), 1),[-1,1])
vAR_CSLAB_rB = vAR_tf.reshape(vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_prediction_grid), 1),[-1,1])
vAR_CSLAB_pred_sq_dist = vAR_tf.add(vAR_tf.subtract(vAR_CSLAB_rA, vAR_tf.multiply(2., vAR_tf.matmul(vAR_CSLAB_x_data, vAR_tf.transpose(vAR_CSLAB_prediction_grid)))), vAR_tf.transpose(vAR_CSLAB_rB))
vAR_CSLAB_pred_kernel = vAR_tf.exp(vAR_tf.multiply(vAR_CSLAB_gamma, vAR_tf.abs(vAR_CSLAB_pred_sq_dist)))
vAR_CSLAB_prediction_output = vAR_tf.matmul(vAR_tf.multiply(vAR_tf.transpose(vAR_CSLAB_y_target),vAR_CSLAB_b), vAR_CSLAB_pred_kernel)
vAR_CSLAB_prediction = vAR_tf.sign(vAR_CSLAB_prediction_output-vAR_tf.reduce_mean(vAR_CSLAB_prediction_output))
vAR_CSLAB_accuracy = vAR_tf.reduce_mean(vAR_tf.cast(vAR_tf.equal(vAR_tf.squeeze(vAR_CSLAB_prediction), vAR_tf.squeeze(vAR_CSLAB_y_target)), vAR_tf.float32))
vAR_CSLAB_my_opt = vAR_tf.train.GradientDescentOptimizer(0.001)
vAR_CSLAB_train_step = vAR_CSLAB_my_opt.minimize(vAR_CSLAB_loss)
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
vAR_sess.run(vAR_CSLAB_init)
vAR_CSLAB_loss_vec = []
vAR_CSLAB_batch_accuracy = []
for i in range(500):
vAR_CSLAB_rand_index = vAR_np.random.choice(len(vAR_CSLAB_x_vals_train), size=vAR_CSLAB_batch_size)
vAR_CSLAB_rand_x = vAR_CSLAB_x_vals_train[vAR_CSLAB_rand_index]
vAR_CSLAB_rand_y = vAR_np.transpose([vAR_CSLAB_y_vals_train[vAR_CSLAB_rand_index]])
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_temp_loss = vAR_sess.run(vAR_CSLAB_loss, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y})
vAR_CSLAB_loss_vec.append(vAR_CSLAB_temp_loss)
vAR_CSLAB_acc_temp = vAR_sess.run(vAR_CSLAB_accuracy, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x,vAR_CSLAB_y_target: vAR_CSLAB_rand_y,vAR_CSLAB_prediction_grid:vAR_CSLAB_rand_x})
vAR_CSLAB_batch_accuracy.append(vAR_CSLAB_acc_temp)
if (i+1)%100==0:
print('Step #' + str(i+1))
print('Loss = ' + str(vAR_CSLAB_temp_loss))
vAR_CSLAB_x_min, vAR_CSLAB_x_max = vAR_CSLAB_x_vals[:, 0].min() - 1, vAR_CSLAB_x_vals[:, 0].max() + 1
vAR_CSLAB_y_min, vAR_CSLAB_y_max = vAR_CSLAB_x_vals[:, 1].min() - 1, vAR_CSLAB_x_vals[:, 1].max() + 1
vAR_CSLAB_xx, vAR_CSLAB_yy = vAR_np.meshgrid(vAR_np.arange(vAR_CSLAB_x_min, vAR_CSLAB_x_max, 0.02),vAR_np.arange(vAR_CSLAB_y_min, vAR_CSLAB_y_max, 0.02))
vAR_CSLAB_grid_points = vAR_np.c_[vAR_CSLAB_xx.ravel(), vAR_CSLAB_yy.ravel()]
[vAR_CSLAB_grid_predictions] = vAR_sess.run(vAR_CSLAB_prediction, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_rand_x, vAR_CSLAB_y_target: vAR_CSLAB_rand_y,vAR_CSLAB_prediction_grid: vAR_CSLAB_grid_points})
vAR_CSLAB_grid_predictions = vAR_CSLAB_grid_predictions.reshape(vAR_CSLAB_xx.shape)
(vAR_CSLAB_x_vals, vAR_CSLAB_y_vals) = datasets.make_circles(n_samples=1500, factor=.5, noise=.1)
vAR_CSLAB_y_vals = vAR_np.array([1 if y==1 else -1 for y in vAR_CSLAB_y_vals])
vAR_CSLAB_class1_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==1]
vAR_CSLAB_class1_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==1]
vAR_CSLAB_class2_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==-1]
vAR_CSLAB_class2_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_y_vals[i]==-1]
vAR_plt.contourf(vAR_CSLAB_xx, vAR_CSLAB_yy, vAR_CSLAB_grid_predictions, cmap=vAR_plt.cm.Paired, alpha=0.8)
vAR_plt.plot(vAR_CSLAB_class1_x, vAR_CSLAB_class1_y, 'ro', label='Class 1')
vAR_plt.plot(vAR_CSLAB_class2_x, vAR_CSLAB_class1_y, 'kx', label='Class -1')
vAR_plt.legend(loc='lower right')
vAR_plt.ylim([-1.5, 1.5])
vAR_plt.xlim([-1.5, 1.5])
vAR_plt.show()
vAR_plt.plot(vAR_CSLAB_batch_accuracy, 'k-', label='Accuracy')
vAR_plt.title('Batch Accuracy')
vAR_plt.xlabel('Generation')
vAR_plt.ylabel('Accuracy')
vAR_plt.legend(loc='lower right')
vAR_plt.show()
vAR_plt.plot(vAR_CSLAB_loss_vec, 'k-')
vAR_plt.title('Loss per Generation')
vAR_plt.xlabel('Generation')
vAR_plt.ylabel('Loss')
vAR_plt.show()
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_MULTI_CLASS_SUPPORT_VECTOR_MACHINE_V1
Purpose : A Program in Python for Multiclass Support Vector Machine - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 14:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Multiclass Support Vector Machine - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
vAR_CSLAB_iris = datasets.load_iris()
vAR_CSLAB_x_vals = vAR_np.array([[x[0], x[3]] for x in vAR_CSLAB_iris.data])
vAR_CSLAB_y_vals1 = vAR_np.array([1 if y==0 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_y_vals2 = vAR_np.array([1 if y==1 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_y_vals3 = vAR_np.array([1 if y==2 else -1 for y in vAR_CSLAB_iris.target])
vAR_CSLAB_y_vals = vAR_np.array([vAR_CSLAB_y_vals1, vAR_CSLAB_y_vals2, vAR_CSLAB_y_vals3])
vAR_CSLAB_class1_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==0]
vAR_CSLAB_class1_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==0]
vAR_CSLAB_class2_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==1]
vAR_CSLAB_class2_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==1]
vAR_CSLAB_class3_x = [x[0] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==2]
vAR_CSLAB_class3_y = [x[1] for i,x in enumerate(vAR_CSLAB_x_vals) if vAR_CSLAB_iris.target[i]==2]
vAR_CSLAB_vAR_CSLAB_batch_size = 50
vAR_CSLAB_x_data = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_y_target = vAR_tf.placeholder(shape=[3, None], dtype=vAR_tf.float32)
vAR_CSLAB_prediction_grid = vAR_tf.placeholder(shape=[None, 2], dtype=vAR_tf.float32)
vAR_CSLAB_b = vAR_tf.Variable(vAR_tf.random_normal(shape=[3,vAR_CSLAB_batch_size]))
vAR_CSLAB_gamma = vAR_tf.constant(-10.0)
vAR_CSLAB_dist = vAR_tf.reduce_sum(vAR_tf.square(vAR_CSLAB_x_data), 1)
vAR_CSLAB_dist = vAR_tf.reshape(vAR_CSLAB_dist, [-1,1])
vAR_CSLAB_sq_dists = vAR_tf.add(vAR_tf.subtract(vAR_CSLAB_dist, vAR_tf.multiply(2., vAR_tf.matmul(vAR_CSLAB_x_data, vAR_tf.transpose(vAR_CSLAB_x_data)))), vAR_tf.transpose(vAR_CSLAB_dist))
vAR_CSLAB_my_kernel = vAR_tf.exp(vAR_tf.multiply(vAR_CSLAB_gamma, vAR_tf.abs(vAR_CSLAB_sq_dists)))
def vAR_CSLAB_reshape_matmul(mat):
vAR_CSLAB_v1 = vAR_tf.expand_dims(mat, 1)
vAR_CSLAB_v2 = vAR_tf.reshape(vAR_CSLAB_v1, [3, vAR_CSLAB_batch_size, 1])
return(vAR_tf.batch_matmul(vAR_CSLAB_v2, vAR_CSLAB_v1))
vAR_CSLAB_model_output = vAR_tf.matmul(vAR_CSLAB_b, vAR_CSLAB_my_kernel)
vAR_CSLAB_first_term = vAR_tf.reduce_sum(vAR_CSLAB_b)
vAR_CSLAB_b_vec_cross = vAR_tf.matmul(vAR_tf.transpose(vAR_CSLAB_b), vAR_CSLAB_b)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_NEAREST_NEIGHBOURS_V1
Purpose : A Program in Python for Nearest Neighbours - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 15:18 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Nearest Neighbours - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import numpy as vAR_np
import tensorflow as vAR_tf
from tensorflow.examples.tutorials.mnist import input_data
vAR_CSLAB_mnist = input_data.read_data_sets("mnist", one_hot=True)
vAR_CSLAB_mnist.train.images.shape
vAR_CSLAB_Xtr, vAR_CSLAB_Ytr = vAR_CSLAB_mnist.train.next_batch(5000) #5000 for training (nn candidates)
vAR_CSLAB_Xte, vAR_CSLAB_Yte = vAR_CSLAB_mnist.test.next_batch(200) #200 for testing
vAR_CSLAB_xtr = vAR_tf.placeholder("float", [None, 784])
vAR_CSLAB_xte = vAR_tf.placeholder("float", [784])
vAR_CSLAB_distance = vAR_tf.reduce_sum(vAR_tf.abs(vAR_tf.add(vAR_CSLAB_xtr, vAR_tf.negative(vAR_CSLAB_xte))), reduction_indices=1)
vAR_CSLAB_pred = vAR_tf.arg_min(vAR_CSLAB_distance, 0)
vAR_CSLAB_accuracy = 0.
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
with vAR_tf.Session() as vAR_sess:
vAR_sess.run(vAR_CSLAB_init)
for i in range(len(vAR_CSLAB_Xte)):
#Get nearest neighbor
vAR_CSLAB_nn_index = vAR_sess.run(vAR_CSLAB_pred, feed_dict={vAR_CSLAB_xtr: vAR_CSLAB_Xtr, vAR_CSLAB_xte:vAR_CSLAB_Xte[i ,:]})
print ("Test", i, "Prediction:", vAR_np.argmax(vAR_CSLAB_Ytr[vAR_CSLAB_nn_index]), "True Class:", vAR_np.argmax(vAR_CSLAB_Yte[i]))
if vAR_np.argmax(vAR_CSLAB_Ytr[vAR_CSLAB_nn_index]) == vAR_np.argmax(vAR_CSLAB_Yte[i]):
vAR_CSLAB_accuracy += 1./len(vAR_CSLAB_Xte)
print ('Done')
print ("Accuracy : ", vAR_CSLAB_accuracy)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_NEURAL_NETWORKS_V1
Purpose : A Program in Python for Neural Networks - Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 15:51 hrs
Version : 1.0
/***********************************************
## Program Description : Program for Neural Networks - Deep Learning in Python
## Python Development Environment & Runtime - Python, Anaconda, Tensorflow, Tensorboard
import tensorflow as vAR_tf
vAR_sess = vAR_tf.Session()
vAR_CSLAB_a = vAR_tf.Variable(vAR_tf.constant(4.))
vAR_CSLAB_x_val = 5.
vAR_CSLAB_x_data = vAR_tf.placeholder(dtype=vAR_tf.float32)
vAR_CSLAB_multiplication = vAR_tf.multiply(vAR_CSLAB_a, vAR_CSLAB_x_data)
vAR_CSLAB_loss = vAR_tf.square(vAR_tf.subtract(vAR_CSLAB_multiplication, 50.))
vAR_CSLAB_init = vAR_tf.global_variables_initializer()
vAR_sess.run(vAR_CSLAB_init)
vAR_CSLAB_my_opt = vAR_tf.train.GradientDescentOptimizer(0.01)
vAR_CSLAB_train_step = vAR_CSLAB_my_opt.minimize(vAR_CSLAB_loss)
print('Optimizing a Multiplication Gate Output to 50.')
for i in range(10):
vAR_CSLAB_a_val_old = vAR_sess.run(vAR_CSLAB_a)
print(vAR_CSLAB_a_val_old)
vAR_sess.run(vAR_CSLAB_train_step, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_val})
vAR_CSLAB_a_val = vAR_sess.run(vAR_CSLAB_a)
vAR_CSLAB_mult_output = vAR_sess.run(vAR_CSLAB_multiplication, feed_dict={vAR_CSLAB_x_data: vAR_CSLAB_x_val})
print(str(vAR_CSLAB_a_val) + ' * ' + str(vAR_CSLAB_x_val) + ' = ' + str(vAR_CSLAB_mult_output))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_KERAS_IMDB_CLASSIFICATION
Purpose : A Program in Python for IMDB Movie Classification using Keras Library in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 16:49 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for IMDB Movie Classification using Keras Library in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
from __future__ import print_function
from keras.preprocessing import sequence
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.layers import Embedding
from keras.layers import Conv1D, GlobalMaxPooling1D
from keras.datasets import imdb
# set parameters:
vAR_CSLAB_max_features = 5000
vAR_CSLAB_maxlen = 400
vAR_CSLAB_batch_size = 32
vAR_CSLAB_embedding_dims = 50
vAR_CSLAB_filters = 250
vAR_CSLAB_kernel_size = 3
vAR_CSLAB_hidden_dims = 250
vAR_CSLAB_epochs = 1
print('Loading data...')
(vAR_CSLAB_x_train, vAR_CSLAB_y_train), (vAR_CSLAB_x_test, vAR_CSLAB_y_test) = imdb.load_data(num_words=vAR_CSLAB_max_features)
print(len(vAR_CSLAB_x_train), 'train sequences')
print(len(vAR_CSLAB_x_test), 'test sequences')
print('Pad sequences (samples x time)')
vAR_CSLAB_x_train = sequence.pad_sequences(vAR_CSLAB_x_train, maxlen=vAR_CSLAB_maxlen)
vAR_CSLAB_x_test = sequence.pad_sequences(vAR_CSLAB_x_test, maxlen=vAR_CSLAB_maxlen)
print('x_train shape:', vAR_CSLAB_x_train.shape)
print('x_test shape:', vAR_CSLAB_x_test.shape)
print('Build model...')
vAR_CSLAB_model = Sequential()
# we start off with an efficient embedding layer which maps
# our vocab indices into embedding_dims dimensions
vAR_CSLAB_model.add(Embedding(vAR_CSLAB_max_features,
vAR_CSLAB_embedding_dims,
input_length=vAR_CSLAB_maxlen))
vAR_CSLAB_model.add(Dropout(0.2))
# we add a Convolution1D, which will learn filters
# word group filters of size filter_length:
vAR_CSLAB_model.add(Conv1D(vAR_CSLAB_filters,
vAR_CSLAB_kernel_size,
padding='valid',
activation='relu',
strides=1))
# we use max pooling:
vAR_CSLAB_model.add(GlobalMaxPooling1D())
# We add a vanilla hidden layer:
vAR_CSLAB_model.add(Dense(vAR_CSLAB_hidden_dims))
vAR_CSLAB_model.add(Dropout(0.2))
vAR_CSLAB_model.add(Activation('relu'))
# We project onto a single unit output layer, and squash it with a sigmoid:
vAR_CSLAB_model.add(Dense(1))
vAR_CSLAB_model.add(Activation('sigmoid'))
vAR_CSLAB_model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
vAR_CSLAB_model.fit(vAR_CSLAB_x_train, vAR_CSLAB_y_train,
batch_size=vAR_CSLAB_batch_size,
epochs=vAR_CSLAB_epochs,
validation_data=(vAR_CSLAB_x_test, vAR_CSLAB_y_test))
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_KERAS_CIFAR10_CNN_CLASSIFICATION
Purpose : A Program in Python for Cifar10 Image Classification using Keras Library in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 17:33 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Cifar10 Image Classification using Keras Library in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
from __future__ import print_function
import keras
from keras.datasets import cifar10
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D
import os
vAR_CSLAB_batch_size = 32
vAR_CSLAB_num_classes = 10
vAR_CSLAB_epochs = 100
vAR_CSLAB_data_augmentation = True
vAR_CSLAB_num_predictions = 20
vAR_CSLAB_save_dir = os.path.join(os.getcwd(), 'saved_models')
vAR_CSLAB_model_name = 'keras_cifar10_trained_model.h5'
# The data, split between train and test sets:
(vAR_CSLAB_x_train, vAR_CSLAB_y_train), (vAR_CSLAB_x_test, vAR_CSLAB_y_test) = cifar10.load_data()
print('x_train shape:', vAR_CSLAB_x_train.shape)
print(vAR_CSLAB_x_train.shape[0], 'train samples')
print(vAR_CSLAB_x_test.shape[0], 'test samples')
# Convert class vectors to binary class matrices.
vAR_CSLAB_y_train = keras.utils.to_categorical(vAR_CSLAB_y_train, vAR_CSLAB_num_classes)
vAR_CSLAB_y_test = keras.utils.to_categorical(vAR_CSLAB_y_test, vAR_CSLAB_num_classes)
vAR_CSLAB_model = Sequential()
vAR_CSLAB_model.add(Conv2D(32, (3, 3), padding='same',
input_shape=vAR_CSLAB_x_train.shape[1:]))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(Conv2D(32, (3, 3)))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Dropout(0.25))
vAR_CSLAB_model.add(Conv2D(64, (3, 3), padding='same'))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(Conv2D(64, (3, 3)))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(MaxPooling2D(pool_size=(2, 2)))
vAR_CSLAB_model.add(Dropout(0.25))
vAR_CSLAB_model.add(Flatten())
vAR_CSLAB_model.add(Dense(512))
vAR_CSLAB_model.add(Activation('relu'))
vAR_CSLAB_model.add(Dropout(0.5))
vAR_CSLAB_model.add(Dense(vAR_CSLAB_num_classes))
vAR_CSLAB_model.add(Activation('softmax'))
# initiate RMSprop optimizer
vAR_CSLAB_opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
# Let's train the model using RMSprop
vAR_CSLAB_model.compile(loss='categorical_crossentropy',
optimizer=vAR_CSLAB_opt,
metrics=['accuracy'])
vAR_CSLAB_x_train = vAR_CSLAB_x_train.astype('float32')
vAR_CSLAB_x_test = vAR_CSLAB_x_test.astype('float32')
vAR_CSLAB_x_train /= 255
vAR_CSLAB_x_test /= 255
if not vAR_CSLAB_data_augmentation:
print('Not using data augmentation.')
vAR_CSLAB_model.fit(vAR_CSLAB_x_train, vAR_CSLAB_y_train,
batch_size=vAR_CSLAB_batch_size,
epochs=vAR_CSLAB_epochs,
validation_data=(vAR_CSLAB_x_test, vAR_CSLAB_y_test),
shuffle=True)
else:
print('Using real-time data augmentation.')
# This will do preprocessing and realtime data augmentation:
vAR_CSLAB_datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
zca_epsilon=1e-06,
rotation_range=0,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.,
zoom_range=0.,
channel_shift_range=0.,
fill_mode='nearest',
cval=0.,
horizontal_flip=True,
vertical_flip=False,
rescale=None,
preprocessing_function=None,
data_format=None,
validation_split=0.0)
vAR_CSLAB_datagen.fit(vAR_CSLAB_x_train)
vAR_CSLAB_model.fit_generator(vAR_CSLAB_datagen.flow(vAR_CSLAB_x_train, vAR_CSLAB_y_train,
batch_size=vAR_CSLAB_batch_size),
epochs=vAR_CSLAB_epochs,
validation_data=(vAR_CSLAB_x_test, vAR_CSLAB_y_test),
workers=4)
# Save model and weights
if not os.path.isdir(vAR_CSLAB_save_dir):
os.makedirs(vAR_CSLAB_save_dir)
vAR_CSLAB_model_path = os.path.join(vAR_CSLAB_save_dir, vAR_CSLAB_model_name)
vAR_CSLAB_model.save(vAR_CSLAB_model_path)
print('Saved trained model at %s ' % vAR_CSLAB_model_path)
# Score trained model.
vAR_CSLAB_scores = vAR_CSLAB_model.evaluate(vAR_CSLAB_x_test, vAR_CSLAB_y_test, verbose=1)
print('Test loss:', vAR_CSLAB_scores[0])
print('Test accuracy:', vAR_CSLAB_scores[1])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_KERAS_MNIST_MLP_CLASSIFICATION
Purpose : A Program in Python for Multi layer Perceptron using Keras Library in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 07/01/2019 18:27 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Multi layer Perceptron using Keras Library in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
from __future__ import print_function
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
vAR_CSLAB_batch_size = 128
vAR_CSLAB_num_classes = 10
vAR_CSLAB_epochs = 1
# the data, split between train and test sets
(vAR_CSLAB_x_train, vAR_CSLAB_y_train), (vAR_CSLAB_x_test, vAR_CSLAB_y_test) = mnist.load_data()
vAR_CSLAB_x_train = vAR_CSLAB_x_train.reshape(60000, 784)
vAR_CSLAB_x_test = vAR_CSLAB_x_test.reshape(10000, 784)
vAR_CSLAB_x_train = vAR_CSLAB_x_train.astype('float32')
vAR_CSLAB_x_test = vAR_CSLAB_x_test.astype('float32')
vAR_CSLAB_x_train /= 255
vAR_CSLAB_x_test /= 255
print(vAR_CSLAB_x_train.shape[0], 'train samples')
print(vAR_CSLAB_x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
vAR_CSLAB_y_train = keras.utils.to_categorical(vAR_CSLAB_y_train, vAR_CSLAB_num_classes)
vAR_CSLAB_y_test = keras.utils.to_categorical(vAR_CSLAB_y_test, vAR_CSLAB_num_classes)
vAR_CSLAB_model = Sequential()
vAR_CSLAB_model.add(Dense(512, activation='relu', input_shape=(784,)))
vAR_CSLAB_model.add(Dropout(0.2))
vAR_CSLAB_model.add(Dense(512, activation='relu'))
vAR_CSLAB_model.add(Dropout(0.2))
vAR_CSLAB_model.add(Dense(vAR_CSLAB_num_classes, activation='softmax'))
vAR_CSLAB_model.summary()
vAR_CSLAB_model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
vAR_CSLAB_history = vAR_CSLAB_model.fit(vAR_CSLAB_x_train, vAR_CSLAB_y_train,
batch_size=vAR_CSLAB_batch_size,
epochs=vAR_CSLAB_epochs,
verbose=1,
validation_data=(vAR_CSLAB_x_test, vAR_CSLAB_y_test))
vAR_CSLAB_score = vAR_CSLAB_model.evaluate(vAR_CSLAB_x_test, vAR_CSLAB_y_test, verbose=0)
print('Test loss:', vAR_CSLAB_score[0])
print('Test accuracy:', vAR_CSLAB_score[1])
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_INTERCOMPANY_TRANSACTION_CLASSIFICATION
Purpose : A Program in Python for Intercompany Transaction Classification in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 08/01/2019 9:56 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Intercompany Transaction Classification in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
# coding=utf-8
# Step 0 - Read Data from .INI File for Hardcoded Values
#import sys
#print('Arguments:', len(sys.argv))
#vAR_Fetched_Data_INI_File_Path = sys.argv[1]
#print(vAR_Fetched_Data_INI_File_Path)
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_INI_File = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_356_INI_FILE']
vAR_Config.read(vAR_CSLAB_INI_File)
vAR_Data = vAR_Config.sections()
vAR_Config.sections()
vAR_Fetched_Data_Source = vAR_Config['Data Source']['DATA_SOURCE1']
#print(vAR_Fetched_Data_Source)
vAR_Fetched_Data_Source_Connection_String = vAR_Config['Data Source Connection String']['SAP_CONNECTION_STRING']
#print(vAR_Fetched_Data_Source_Connection_String)
vAR_Fetched_Data_Source_Path_Input_Data = vAR_Config['Data Source Path']['INPUT_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Input_Data)
vAR_Fetched_Data_Source_Path_Train_Data = vAR_Config['Data Source Path']['TRAIN_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Train_Data)
vAR_Fetched_Data_Source_Path_Test_Data = vAR_Config['Data Source Path']['Test_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_Fetched_Data_Train_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Train_Features1)
vAR_Fetched_Data_Train_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Train_Features2)
vAR_Fetched_Data_Train_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Train_Features3)
vAR_Fetched_Data_Train_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Train_Features4)
vAR_Fetched_Data_Train_All_Features = vAR_Config['Train Features - Problem 1']['ALL_FEATURES_TRAIN']
#print(vAR_Fetched_Data_Train_All_Features)
vAR_Fetched_Data_Train_Label = vAR_Config['Train Label - Problem 1']['LABEL']
#print(vAR_Fetched_Data_Train_Label)
vAR_Fetched_Data_Test_Features1 = vAR_Config['Test Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Test_Features1)
vAR_Fetched_Data_Test_Features2 = vAR_Config['Test Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Test_Features2)
vAR_Fetched_Data_Test_Features3 = vAR_Config['Test Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Test_Features3)
vAR_Fetched_Data_Test_Features4 = vAR_Config['Test Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Test_Features4)
vAR_Fetched_Data_Test_All_Features = vAR_Config['Test Features - Problem 1']['ALL_FEATURES_TEST']
#print(vAR_Fetched_Data_Test_All_Features)
vAR_Fetched_Data_Model_Path = vAR_Config['Model Ouput Path']['MODEL_OUTPUT_PATH']
#print(vAR_Fetched_Data_Model_Path)
vAR_Fetched_Data_Best_Fit_File_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_File_Example_1)
vAR_Fetched_Data_Best_Fit_File_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_File_Example_2)
vAR_Fetched_Data_Best_Fit_File_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_File_Example_3)
vAR_Fetched_Data_Best_Fit_Image_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_1)
vAR_Fetched_Data_Best_Fit_Image_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_2)
vAR_Fetched_Data_Best_Fit_Image_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_3)
vAR_Fetched_Data_Under_Fit_File_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_File_Example_1)
vAR_Fetched_Data_Under_Fit_File_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_File_Example_2)
vAR_Fetched_Data_Under_Fit_File_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_File_Example_3)
vAR_Fetched_Data_Under_Fit_Image_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_1)
vAR_Fetched_Data_Under_Fit_Image_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_2)
vAR_Fetched_Data_Under_Fit_Image_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_3)
vAR_Fetched_Data_Over_Fit_File_Example_1 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_File_Example_1)
vAR_Fetched_Data_Over_Fit_File_Example_2 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_File_Example_2)
vAR_Fetched_Data_Over_Fit_File_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_File_Example_3)
vAR_Fetched_Data_Over_Fit_Image_Example_1 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_1)
vAR_Fetched_Data_Over_Fit_Image_Example_2 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_2)
vAR_Fetched_Data_Over_Fit_Image_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_3)
vAR_Fetched_Data_Cross_Validation_Image_Example_1 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_1)
vAR_Fetched_Data_Cross_Validation_Image_Example_2 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_2)
vAR_Fetched_Data_Cross_Validation_Image_Example_3 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_3)
vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['BEFORE_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_After_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['AFTER_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_After_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_Model_Fitting_Best_Fit_Test = vAR_Config['Model Fitting']['BEST_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Best_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Under_Fit_Test = vAR_Config['Model Fitting']['UNDER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Under_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Over_Fit_Test = vAR_Config['Model Fitting']['OVER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Over_Fit_Test)
vAR_Fetched_Data_Cross_Validation_Required = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_REQUIRED']
#print(vAR_Fetched_Data_Cross_Validation_Required)
vAR_Fetched_Data_Hyperparameter_Tuning_Required = vAR_Config['Model_Validation_Tuning']['HYPERPARAMETERS_TUNING_REQUIRED']
#print(vAR_Fetched_Data_Hyperparameter_Tuning_Required)
# coding=utf-8
# Step 1 - Import the Required Libraries
#Our Model Implementation needs the Following Libraries:
import pandas as vAR_pd
from sklearn.preprocessing import LabelEncoder
#import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import Adam
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 2 - Import Training Data
#Next step after importing all libraries is getting the Training data imported.
#We are importing the Clustering data stored in our local system with the use of Pandas library.
vAR_df = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Input_Data)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 3 – Convert Categorical Data into Numerical Values using Label Encoder
# Next Step of the Implementation is Convertion of Categorical Data into Numerical Values & Feature/Label Selection.
vAR_le = LabelEncoder()
vAR_Transaction_Type_Conversion = vAR_le.fit_transform(vAR_df.iloc[:,7])
vAR_Transaction_Type_Conversion_df = vAR_pd.DataFrame(vAR_Transaction_Type_Conversion,columns={'Transaction_Type_Converted'})
vAR_Data_Category_Conversion = vAR_le.fit_transform(vAR_df.iloc[:,9])
vAR_Data_Category_Conversion_df = vAR_pd.DataFrame(vAR_Data_Category_Conversion,columns={'Data_Category_Converted'})
# Attached the Converted Numerical Data to the main dataframe
vAR_df1 = vAR_df.merge(vAR_Transaction_Type_Conversion_df,left_index=True, right_index=True)
vAR_df2 = vAR_df1.merge(vAR_Data_Category_Conversion_df,left_index=True, right_index=True)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 4 – Train the Model
# Training the data means Making the model to Learn, understand & recognize the Pattern in the data.
vAR_Features_train = vAR_pd.read_excel(vAR_Fetched_Data_Train_All_Features)
vAR_Label_train = vAR_df.iloc[:,12]
vAR_model = Sequential()
vAR_model.add(Dense(4, input_shape=(4,), activation='relu',name='Input_Layer'))
vAR_model.add(Dense(10, activation='relu',name='Hidden_Layer'))
vAR_model.add(Dropout(0.5)) # Adding Dropout Prevents Overfitting
vAR_model.add(Dense(1, activation='softmax', name='Output_Layer'))
# Adam optimizer with learning rate of 0.005
vAR_optimizer = Adam(lr=0.005)
vAR_model.compile(vAR_optimizer, loss='binary_crossentropy', metrics=['accuracy'])
# Train the model
vAR_model.fit(vAR_Features_train, vAR_Label_train, verbose=1, batch_size=5, epochs=200)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 5 – Review Learning Algorithm
# We Review the Algorithm as to see how it has learned from the Features we Provided
vAR_model.predict(vAR_Features_train)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 6 - Import Test Data
# Importing the Test Data is to check how the data used on the Model Performs
vAR_df3 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_Transaction_Type_Conversion_test = vAR_le.fit_transform(vAR_df3.iloc[:,3])
vAR_Transaction_Type_Conversion_test_df = vAR_pd.DataFrame(vAR_Transaction_Type_Conversion_test,columns={'Transaction_Type_Converted'})
vAR_Data_Category_Conversion_test = vAR_le.fit_transform(vAR_df.iloc[:,4])
vAR_Data_Category_Conversion_test_df = vAR_pd.DataFrame(vAR_Data_Category_Conversion_test,columns={'Data_Category_Converted'})
vAR_df4 = vAR_df3.merge(vAR_Transaction_Type_Conversion_test_df,left_index=True, right_index=True)
vAR_df5 = vAR_df4.merge(vAR_Data_Category_Conversion_test_df,left_index=True, right_index=True)
vAR_Features_test = vAR_pd.read_excel(vAR_Fetched_Data_Test_All_Features)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 7 – Running Model on Test Data
# Running the Model on Test Data is to use the imported test data to Prodict our Outcome
vAR_Labels_Pred = vAR_model.predict(vAR_Features_test)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 8 – Review Model Outcome
# We check the Output of Model i.e the Prediction it has made on the test data
vAR_Labels_Pred = vAR_pd.DataFrame(vAR_Labels_Pred,columns={'Predicted_Inter_Transaction_Type'})
#vAR_Features_test = vAR_Features_test.sort()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 9 - Write Model Outcome to File
# Write the Model Output to an excel file for analysis.
vAR_df6 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_df7 = vAR_df6.merge(vAR_Labels_Pred,left_index=True, right_index=True)
vAR_df8 = vAR_df7.to_excel(vAR_Fetched_Data_Model_Path, engine='xlsxwriter')
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 10 - To open and view the file outcome
#Open the Written File & Check the Outcome as Shown. Execute to View the data
vAR_df9 = vAR_pd.read_excel(vAR_Fetched_Data_Model_Path)
vAR_df9
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_PAIR_INTERCOMPANY_TRANSACTION_AUTOENCODER_KMEANS
Purpose : A Program in Python for Pair Intercompany Transaction Using Autoencoder & Kmeans Clustering in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 08/01/2019 10:47 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Pair Intercompany Transaction Using Autoencoder & Kmeans Clustering in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
# coding=utf-8
# Step 0 - Read Data from .INI File for Hardcoded Values
import sys
#print('Arguments:', len(sys.argv))
#vAR_Fetched_Data_INI_File_Path = sys.argv[1]
#print(vAR_Fetched_Data_INI_File_Path)
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_INI_File = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_357_INI_FILE']
vAR_Config.read(vAR_CSLAB_INI_File)
vAR_Data = vAR_Config.sections()
vAR_Config.sections()
vAR_Fetched_Data_Source = vAR_Config['Data Source']['DATA_SOURCE1']
#print(vAR_Fetched_Data_Source)
vAR_Fetched_Data_Source_Connection_String = vAR_Config['Data Source Connection String']['SAP_CONNECTION_STRING']
#print(vAR_Fetched_Data_Source_Connection_String)
vAR_Fetched_Data_Source_Path_Input_Data = vAR_Config['Data Source Path']['INPUT_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Input_Data)
vAR_Fetched_Data_Source_Path_Train_Data = vAR_Config['Data Source Path']['TRAIN_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Train_Data)
vAR_Fetched_Data_Source_Path_Test_Data = vAR_Config['Data Source Path']['Test_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_Fetched_Data_Train_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Train_Features1)
vAR_Fetched_Data_Train_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Train_Features2)
vAR_Fetched_Data_Train_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Train_Features3)
vAR_Fetched_Data_Train_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Train_Features4)
vAR_Fetched_Data_Train_All_Features = vAR_Config['Train Features - Problem 1']['ALL_FEATURES_TRAIN']
#print(vAR_Fetched_Data_Train_All_Features)
vAR_Fetched_Data_Test_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Test_Features1)
vAR_Fetched_Data_Test_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Test_Features2)
vAR_Fetched_Data_Test_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Test_Features3)
vAR_Fetched_Data_Test_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Test_Features4)
vAR_Fetched_Data_Test_All_Features = vAR_Config['Test Features - Problem 1']['ALL_FEATURES_TEST']
#print(vAR_Fetched_Data_Test_All_Features)
vAR_Fetched_Data_Model_Path = vAR_Config['Model Ouput Path']['MODEL_OUTPUT_PATH']
#print(vAR_Fetched_Data_Model_Path)
vAR_Fetched_Data_Best_Fit_File_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_File_Example_1)
vAR_Fetched_Data_Best_Fit_File_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_File_Example_2)
vAR_Fetched_Data_Best_Fit_File_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_File_Example_3)
vAR_Fetched_Data_Best_Fit_Image_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_1)
vAR_Fetched_Data_Best_Fit_Image_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_2)
vAR_Fetched_Data_Best_Fit_Image_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_3)
vAR_Fetched_Data_Under_Fit_File_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_File_Example_1)
vAR_Fetched_Data_Under_Fit_File_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_File_Example_2)
vAR_Fetched_Data_Under_Fit_File_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_File_Example_3)
vAR_Fetched_Data_Under_Fit_Image_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_1)
vAR_Fetched_Data_Under_Fit_Image_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_2)
vAR_Fetched_Data_Under_Fit_Image_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_3)
vAR_Fetched_Data_Over_Fit_File_Example_1 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_File_Example_1)
vAR_Fetched_Data_Over_Fit_File_Example_2 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_File_Example_2)
vAR_Fetched_Data_Over_Fit_File_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_File_Example_3)
vAR_Fetched_Data_Over_Fit_Image_Example_1 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_1)
vAR_Fetched_Data_Over_Fit_Image_Example_2 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_2)
vAR_Fetched_Data_Over_Fit_Image_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_3)
vAR_Fetched_Data_Cross_Validation_Image_Example_1 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_1)
vAR_Fetched_Data_Cross_Validation_Image_Example_2 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_2)
vAR_Fetched_Data_Cross_Validation_Image_Example_3 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_3)
vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['BEFORE_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_After_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['AFTER_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_After_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_Model_Fitting_Best_Fit_Test = vAR_Config['Model Fitting']['BEST_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Best_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Under_Fit_Test = vAR_Config['Model Fitting']['UNDER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Under_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Over_Fit_Test = vAR_Config['Model Fitting']['OVER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Over_Fit_Test)
vAR_Fetched_Data_Cross_Validation_Required = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_REQUIRED']
#print(Fetched_Data_Cross_Validation_Required)
vAR_Fetched_Data_Hyperparameter_Tuning_Required = vAR_Config['Model_Validation_Tuning']['HYPERPARAMETERS_TUNING_REQUIRED']
#print(Fetched_Data_Hyperparameter_Tuning_Required)
# Step 1 - Import the Required Libraries
#Our Model Implementation needs the Following Libraries:
#Sklearn: Sklearn is the Machine Learning Library which is used for numerical & scientific computations.
#Pandas: Pandas is a library used for data manipulation and analysis.
#In Our Implementation. we are using it for Importing the Data file & Creating Dataframes (Stores the Data).
import pandas as vAR_pd
from sklearn.cluster import KMeans
from keras.layers import Input, Dense
from keras.models import Model
import numpy as np
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
#Step 2 - Import Clustering Data
#Next step after importing all libraries is getting the Training data imported.
#We are importing the Clustering data stored in our local system with the use of Pandas library.
vAR_df = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Train_Data)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 3 – Convert Categorical Data into Numerical Values using Label Encoder
# Next Step of the Implementation is Convertion of Categorical Data into Numerical Values & Feature Selection for Clustering.
vAR_le = LabelEncoder()
vAR_Transaction_Type_Conversion = vAR_le.fit_transform(vAR_df.iloc[:,7])
vAR_Transaction_Type_Conversion_df = vAR_pd.DataFrame(vAR_Transaction_Type_Conversion,columns={'Transaction_Type_Converted'})
vAR_Data_Category_Conversion = vAR_le.fit_transform(vAR_df.iloc[:,9])
vAR_Data_Category_Conversion_df = vAR_pd.DataFrame(vAR_Data_Category_Conversion,columns={'Data_Category_Converted'})
vAR_Doc_Date_Conversion = vAR_le.fit_transform(vAR_df.iloc[:,3])
vAR_Doc_Date_Conversion_df = vAR_pd.DataFrame(vAR_Doc_Date_Conversion,columns={'Doc_Date_Converted'})
# Attached the Converted Numerical Data to the main dataframe
vAR_df1 = vAR_df.merge(vAR_Transaction_Type_Conversion_df,left_index=True, right_index=True)
vAR_df2 = vAR_df1.merge(vAR_Data_Category_Conversion_df,left_index=True, right_index=True)
vAR_df3 = vAR_df2.merge(vAR_Doc_Date_Conversion_df,left_index=True, right_index=True)
vAR_df4 = vAR_pd.read_excel(vAR_Fetched_Data_Train_All_Features)
vAR_df4 = vAR_df4.values
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 4 – Clustering the Data
# Clustering the data meaning Making the model to group/cluster, understand & recognize the Pattern in the data..
vAR_df4 = vAR_df4.reshape(len(vAR_df4),np.prod(vAR_df4.shape[1:]))
#vAR_df4 = vAR_df4.reshape((vAR_df4.shape[0],vAR_df4.shape[1],1))
encoding_dim = 2
input_dim = Input(shape=(2,))
encoded = Dense(encoding_dim, activation='relu')(input_dim)
decoded = Dense(2, activation='sigmoid')(encoded)
autoencoder = Model(input_dim, decoded)
autoencoder.compile(optimizer='adadelta', loss='categorical_crossentropy')
autoencoder.fit(vAR_df4,vAR_df4)
Pred = autoencoder.predict(vAR_df4)
Pred.astype(int)
vAR_df4 = vAR_pd.read_excel(vAR_Fetched_Data_Train_All_Features)
vAR_model = KMeans(n_clusters=12,random_state=0)
vAR_model.fit(vAR_df4)
vAR_Class = vAR_model.labels_
vAR_Class_df = vAR_pd.DataFrame(vAR_Class,columns={'New_Group'})
vAR_Class_df
vAR_df4_Class_Merge = vAR_df4.merge(vAR_Class_df,left_index=True, right_index=True)
vAR_df4_Class_Merge
vAR_df5 = vAR_df4_Class_Merge.iloc[:,2]
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 5 – Review Learning Algorithm
# We Review the Algorithm as to see how it has learned from the Features we Provided
vAR_model.predict(vAR_df4)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 6 - Import Test Data
# Importing the Test Data is to check how the data used on the Model Performs
vAR_df6 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
#vAR_Data_Category_Conversion_test = vAR_le.fit_transform(vAR_df5.iloc[:,9])
#vAR_Data_Category_Conversion_test_df = vAR_pd.DataFrame(vAR_Data_Category_Conversion_test,columns={'Data_Category_Converted_test'})
vAR_df7 = vAR_pd.read_excel(vAR_Fetched_Data_Test_All_Features)
vAR_Features_test = vAR_df7
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 7 – Running Model on Test Data
# Running the Model on Test Data is to use the imported test data to Prodict our Outcome
vAR_Labels_Pred = vAR_model.predict(vAR_Features_test)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 8 – Review Model Outcome
# We check the Output of Model i.e the Prediction it has made on the test data
vAR_Labels_Pred = vAR_pd.DataFrame(vAR_Labels_Pred,columns={'Predicted_Inter_Transaction_Pair'})
#vAR_Features_test = vAR_Features_test.sort()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 9 - Write Model Outcome to File
# Write the Model Output to an excel file for analysis.
vAR_df8 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_df9 = vAR_df8.merge(vAR_Labels_Pred,left_index=True, right_index=True)
vAR_df10 = vAR_df9.to_excel(vAR_Fetched_Data_Model_Path)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 10 - To open and view the file outcome
# Open the Written File & Check the Outcome as Shown. Execute to View the data
vAR_df11 = vAR_pd.read_excel(vAR_Fetched_Data_Model_Path)
vAR_df11
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_PAIR_INTERCOMPANY_TRANSACTION_FOR_DIFFERENCE_IN_BOOKING_AE_KMEANS
Purpose : A Program in Python for Pairing Intercompany Transaction for Differnce in Booking Using Autoencoder & Kmeans Clustering in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 08/01/2019 11:39 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Pairing Intercompany Transaction for Differnce in Booking Using Autoencoder & Kmeans Clustering in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
# coding=utf-8
# Step 0 - Read Data from .INI File for Hardcoded Values
import sys
#print('Arguments:', len(sys.argv))
#vAR_Fetched_Data_INI_File_Path = sys.argv[1]
#print(vAR_Fetched_Data_INI_File_Path)
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_INI_File = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_358_INI_FILE']
vAR_Config.read(vAR_CSLAB_INI_File)
vAR_Data = vAR_Config.sections()
vAR_Config.sections()
vAR_Fetched_Data_Source = vAR_Config['Data Source']['DATA_SOURCE1']
#print(vAR_Fetched_Data_Source)
vAR_Fetched_Data_Source_Connection_String = vAR_Config['Data Source Connection String']['SAP_CONNECTION_STRING']
#print(vAR_Fetched_Data_Source_Connection_String)
vAR_Fetched_Data_Source_Path_Input_Data = vAR_Config['Data Source Path']['INPUT_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Input_Data)
vAR_Fetched_Data_Source_Path_Train_Data = vAR_Config['Data Source Path']['TRAIN_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Train_Data)
vAR_Fetched_Data_Source_Path_Test_Data = vAR_Config['Data Source Path']['Test_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_Fetched_Data_Train_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Train_Features1)
vAR_Fetched_Data_Train_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Train_Features2)
vAR_Fetched_Data_Train_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Train_Features3)
vAR_Fetched_Data_Train_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Train_Features4)
vAR_Fetched_Data_Train_All_Features = vAR_Config['Train Features - Problem 1']['ALL_FEATURES_TRAIN']
#print(vAR_Fetched_Data_Train_All_Features)
vAR_Fetched_Data_Test_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Test_Features1)
vAR_Fetched_Data_Test_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Test_Features2)
vAR_Fetched_Data_Test_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Test_Features3)
vAR_Fetched_Data_Test_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Test_Features4)
vAR_Fetched_Data_Test_All_Features = vAR_Config['Test Features - Problem 1']['ALL_FEATURES_TEST']
#print(vAR_Fetched_Data_Test_All_Features)
vAR_Fetched_Data_Model_Path = vAR_Config['Model Ouput Path']['MODEL_OUTPUT_PATH']
#print(vAR_Fetched_Data_Model_Path)
vAR_Fetched_Data_Best_Fit_File_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_File_Example_1)
vAR_Fetched_Data_Best_Fit_File_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_File_Example_2)
vAR_Fetched_Data_Best_Fit_File_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_File_Example_3)
vAR_Fetched_Data_Best_Fit_Image_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_1)
vAR_Fetched_Data_Best_Fit_Image_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_2)
vAR_Fetched_Data_Best_Fit_Image_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_3)
vAR_Fetched_Data_Under_Fit_File_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_File_Example_1)
vAR_Fetched_Data_Under_Fit_File_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_File_Example_2)
vAR_Fetched_Data_Under_Fit_File_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_File_Example_3)
vAR_Fetched_Data_Under_Fit_Image_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_1)
vAR_Fetched_Data_Under_Fit_Image_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_2)
vAR_Fetched_Data_Under_Fit_Image_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_3)
vAR_Fetched_Data_Over_Fit_File_Example_1 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_File_Example_1)
vAR_Fetched_Data_Over_Fit_File_Example_2 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_File_Example_2)
vAR_Fetched_Data_Over_Fit_File_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_File_Example_3)
vAR_Fetched_Data_Over_Fit_Image_Example_1 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_1)
vAR_Fetched_Data_Over_Fit_Image_Example_2 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_2)
vAR_Fetched_Data_Over_Fit_Image_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_3)
vAR_Fetched_Data_Cross_Validation_Image_Example_1 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_1)
vAR_Fetched_Data_Cross_Validation_Image_Example_2 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_2)
vAR_Fetched_Data_Cross_Validation_Image_Example_3 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_3)
vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['BEFORE_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_After_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['AFTER_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_After_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_Model_Fitting_Best_Fit_Test = vAR_Config['Model Fitting']['BEST_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Best_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Under_Fit_Test = vAR_Config['Model Fitting']['UNDER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Under_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Over_Fit_Test = vAR_Config['Model Fitting']['OVER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Over_Fit_Test)
vAR_Fetched_Data_Cross_Validation_Required = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_REQUIRED']
#print(Fetched_Data_Cross_Validation_Required)
vAR_Fetched_Data_Hyperparameter_Tuning_Required = vAR_Config['Model_Validation_Tuning']['HYPERPARAMETERS_TUNING_REQUIRED']
#print(Fetched_Data_Hyperparameter_Tuning_Required)
# Step 1 - Import the Required Libraries
#Our Model Implementation needs the Following Libraries:
#Sklearn: Sklearn is the Machine Learning Library which is used for numerical & scientific computations.
#Pandas: Pandas is a library used for data manipulation and analysis.
#In Our Implementation. we are using it for Importing the Data file & Creating Dataframes (Stores the Data).
import pandas as vAR_pd
from sklearn.preprocessing import LabelEncoder
from sklearn.cluster import KMeans
from keras.layers import Input, Dense
from keras.models import Model
import numpy as np
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
#Step 2 - Import Clustering Data
#Next step after importing all libraries is getting the Training data imported.
#We are importing the Clustering data stored in our local system with the use of Pandas library.
vAR_df = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Train_Data)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 3 – Convert Categorical Data into Numerical Values using Label Encoder
# Next Step of the Implementation is Convertion of Categorical Data into Numerical Values & Feature Selection for Clustering.
vAR_le = LabelEncoder()
vAR_Transaction_Type_Conversion = vAR_le.fit_transform(vAR_df.iloc[:,7])
vAR_Transaction_Type_Conversion_df = vAR_pd.DataFrame(vAR_Transaction_Type_Conversion,columns={'Transaction_Type_Converted'})
vAR_Data_Category_Conversion = vAR_le.fit_transform(vAR_df.iloc[:,9])
vAR_Data_Category_Conversion_df = vAR_pd.DataFrame(vAR_Data_Category_Conversion,columns={'Data_Category_Converted'})
vAR_Doc_Date_Conversion = vAR_le.fit_transform(vAR_df.iloc[:,3])
vAR_Doc_Date_Conversion_df = vAR_pd.DataFrame(vAR_Doc_Date_Conversion,columns={'Doc_Date_Converted'})
# Attached the Converted Numerical Data to the main dataframe
vAR_df1 = vAR_df.merge(vAR_Transaction_Type_Conversion_df,left_index=True, right_index=True)
vAR_df2 = vAR_df1.merge(vAR_Data_Category_Conversion_df,left_index=True, right_index=True)
vAR_df3 = vAR_df2.merge(vAR_Doc_Date_Conversion_df,left_index=True, right_index=True)
vAR_df4 = vAR_pd.read_excel(vAR_Fetched_Data_Train_All_Features)
vAR_df4 = vAR_df4.values
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 4 – Clustering the Data
# Clustering the data meaning Making the model to group/cluster, understand & recognize the Pattern in the data..
vAR_df4 = vAR_df4.reshape(len(vAR_df4),np.prod(vAR_df4.shape[1:]))
#vAR_df4 = vAR_df4.reshape((vAR_df4.shape[0],vAR_df4.shape[1],1))
encoding_dim = 2
input_dim = Input(shape=(5,))
encoded = Dense(encoding_dim, activation='relu')(input_dim)
decoded = Dense(5, activation='sigmoid')(encoded)
autoencoder = Model(input_dim, decoded)
autoencoder.compile(optimizer='adadelta', loss='categorical_crossentropy')
autoencoder.fit(vAR_df4,vAR_df4)
Pred = autoencoder.predict(vAR_df4)
Pred.astype(int)
vAR_df4 = vAR_pd.read_excel(vAR_Fetched_Data_Train_All_Features)
#vAR_df4
vAR_model = KMeans(n_clusters=7,random_state=0)
vAR_model.fit(vAR_df4)
vAR_Class = vAR_model.labels_
vAR_Class_df = vAR_pd.DataFrame(vAR_Class,columns={'New_Group'})
vAR_Class_df
vAR_df4_Class_Merge = vAR_df4.merge(vAR_Class_df,left_index=True, right_index=True)
vAR_df4_Class_Merge
vAR_df5 = vAR_df4_Class_Merge.iloc[:,4]
#vAR_df5.head()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 5 – Review Learning Algorithm
# We Review the Algorithm as to see how it has learned from the Features we Provided
vAR_model.predict(vAR_df4)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 6 - Import Test Data
# Importing the Test Data is to check how the data used on the Model Performs
vAR_df6 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
#vAR_Data_Category_Conversion_test = vAR_le.fit_transform(vAR_df5.iloc[:,9])
#vAR_Data_Category_Conversion_test_df = vAR_pd.DataFrame(vAR_Data_Category_Conversion_test,columns={'Data_Category_Converted_test'})
vAR_df7 = vAR_pd.read_excel(vAR_Fetched_Data_Test_All_Features)
vAR_Features_test = vAR_df7
vAR_model1 = KMeans(n_clusters=4,random_state=0)
vAR_model1.fit(vAR_Features_test)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 7 – Running Model on Test Data
# Running the Model on Test Data is to use the imported test data to Prodict our Outcome
vAR_Labels_Pred = vAR_model.predict(vAR_Features_test)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 8 – Review Model Outcome
# We check the Output of Model i.e the Prediction it has made on the test data
vAR_Labels_Pred = vAR_pd.DataFrame(vAR_Labels_Pred,columns={'Predicted_Inter_Transaction_Pair_Difference_Booking'})
#vAR_Features_test = vAR_Features_test.sort()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 9 - Write Model Outcome to File
# Write the Model Output to an excel file for analysis.
vAR_df8 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_df9 = vAR_df8.merge(vAR_Labels_Pred,left_index=True, right_index=True)
vAR_df10 = vAR_df9.to_excel(vAR_Fetched_Data_Model_Path)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 10 - To open and view the file outcome
# Open the Written File & Check the Outcome as Shown. Execute to View the data
vAR_df11 = vAR_pd.read_excel(vAR_Fetched_Data_Model_Path)
vAR_df11.head()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_PREDICT_WEIGHTED_ACCURACY_OF_INTERCOMPANY_TRANSACTION_ANN
Purpose : A Program in Python for Predicting Weighted Accuracy of IC Using ANN in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 08/01/2019 12:28 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Predicting Weighted Accuracy of IC Using ANN in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
# coding=utf-8
# Step 0 - Read Data from .INI File for Hardcoded Values
import sys
#print('Arguments:', len(sys.argv))
#vAR_Fetched_Data_INI_File_Path = sys.argv[1]
#print(vAR_Fetched_Data_INI_File_Path)
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_INI_File = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_359_INI_FILE']
vAR_Config.read(vAR_CSLAB_INI_File)
vAR_Data = vAR_Config.sections()
vAR_Config.sections()
vAR_Fetched_Data_Source = vAR_Config['Data Source']['DATA_SOURCE1']
#print(vAR_Fetched_Data_Source)
vAR_Fetched_Data_Source_Connection_String = vAR_Config['Data Source Connection String']['SAP_CONNECTION_STRING']
#print(vAR_Fetched_Data_Source_Connection_String)
vAR_Fetched_Data_Source_Path_Input_Data = vAR_Config['Data Source Path']['INPUT_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Input_Data)
vAR_Fetched_Data_Source_Path_Train_Data = vAR_Config['Data Source Path']['TRAIN_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Train_Data)
vAR_Fetched_Data_Source_Path_Test_Data = vAR_Config['Data Source Path']['Test_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_Fetched_Data_Train_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Train_Features1)
vAR_Fetched_Data_Train_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Train_Features2)
vAR_Fetched_Data_Train_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Train_Features3)
vAR_Fetched_Data_Train_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Train_Features4)
vAR_Fetched_Data_Train_All_Features = vAR_Config['Train Features - Problem 1']['ALL_FEATURES_TRAIN']
#print(vAR_Fetched_Data_Train_All_Features)
vAR_Fetched_Data_Test_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Test_Features1)
vAR_Fetched_Data_Test_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Test_Features2)
vAR_Fetched_Data_Test_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Test_Features3)
vAR_Fetched_Data_Test_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Test_Features4)
vAR_Fetched_Data_Test_All_Features = vAR_Config['Test Features - Problem 1']['ALL_FEATURES_TEST']
#print(vAR_Fetched_Data_Test_All_Features)
vAR_Fetched_Data_Model_Path = vAR_Config['Model Ouput Path']['MODEL_OUTPUT_PATH']
#print(vAR_Fetched_Data_Model_Path)
vAR_Fetched_Data_Best_Fit_File_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_File_Example_1)
vAR_Fetched_Data_Best_Fit_File_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_File_Example_2)
vAR_Fetched_Data_Best_Fit_File_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_File_Example_3)
vAR_Fetched_Data_Best_Fit_Image_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_1)
vAR_Fetched_Data_Best_Fit_Image_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_2)
vAR_Fetched_Data_Best_Fit_Image_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_3)
vAR_Fetched_Data_Under_Fit_File_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_File_Example_1)
vAR_Fetched_Data_Under_Fit_File_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_File_Example_2)
vAR_Fetched_Data_Under_Fit_File_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_File_Example_3)
vAR_Fetched_Data_Under_Fit_Image_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_1)
vAR_Fetched_Data_Under_Fit_Image_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_2)
vAR_Fetched_Data_Under_Fit_Image_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_3)
vAR_Fetched_Data_Over_Fit_File_Example_1 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_File_Example_1)
vAR_Fetched_Data_Over_Fit_File_Example_2 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_File_Example_2)
vAR_Fetched_Data_Over_Fit_File_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_File_Example_3)
vAR_Fetched_Data_Over_Fit_Image_Example_1 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_1)
vAR_Fetched_Data_Over_Fit_Image_Example_2 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_2)
vAR_Fetched_Data_Over_Fit_Image_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_3)
vAR_Fetched_Data_Cross_Validation_Image_Example_1 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_1)
vAR_Fetched_Data_Cross_Validation_Image_Example_2 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_2)
vAR_Fetched_Data_Cross_Validation_Image_Example_3 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_3)
vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['BEFORE_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_After_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['AFTER_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_After_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_Model_Fitting_Best_Fit_Test = vAR_Config['Model Fitting']['BEST_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Best_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Under_Fit_Test = vAR_Config['Model Fitting']['UNDER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Under_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Over_Fit_Test = vAR_Config['Model Fitting']['OVER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Over_Fit_Test)
vAR_Fetched_Data_Cross_Validation_Required = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_REQUIRED']
#print(Fetched_Data_Cross_Validation_Required)
vAR_Fetched_Data_Hyperparameter_Tuning_Required = vAR_Config['Model_Validation_Tuning']['HYPERPARAMETERS_TUNING_REQUIRED']
#print(Fetched_Data_Hyperparameter_Tuning_Required)
# Step 1 - Import the Required Libraries
#Our Model Implementation needs the Following Libraries:
#Sklearn: Sklearn is the Machine Learning Library which is used for numerical & scientific computations.
#Pandas: Pandas is a library used for data manipulation and analysis.
#In Our Implementation. we are using it for Importing the Data file & Creating Dataframes (Stores the Data).
import pandas as vAR_pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 2 - Import Training Data
#Next step after importing all libraries is getting the Training data imported.
#We are importing the Clustering data stored in our local system with the use of Pandas library.
vAR_df = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Train_Data)
vAR_df.head(3)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 3 – Select the Features & Lables
vAR_Features_Train = vAR_pd.read_excel(vAR_Fetched_Data_Train_All_Features)
vAR_Labels_Train = vAR_df.iloc[:,12]
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 4 – Train the Model
# Training the data means Making the model to Learn, understand & recognize the Pattern in the data.
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam
vAR_model = Sequential()
vAR_model.add(Dense(5, input_dim=5, kernel_initializer='normal', activation='relu'))
vAR_model.add(Dense(5, activation='relu'))
vAR_model.add(Dense(1, kernel_initializer='normal'))
# Adam optimizer with learning rate of 0.001
vAR_optimizer = Adam(lr=0.001)
vAR_model.compile(loss='mean_squared_error', optimizer='Adam')
# Train the model
vAR_model.fit(vAR_Features_Train, vAR_Labels_Train, verbose=0, batch_size=5, epochs=200)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 5 – Review Learning AlgorithmvAR_Labels_Train
# We Review the Algorithm as to see how it has learned from the Features we Provided
vAR_model.predict(vAR_Features_Train).astype(int)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 6 - Import Test Data
# Importing the Test Data is to check how the data used on the Model Performs
vAR_df6 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_df6.head(5)
vAR_Features_Test = vAR_pd.read_excel(vAR_Fetched_Data_Test_All_Features)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 7 – Running Model on Test Data
# Running the Model on Test Data is to use the imported test data to Prodict our Outcome
vAR_Labels_Pred = vAR_model.predict(vAR_Features_Test).astype(int)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 8 – Review Model Outcome
# We check the Output of Model i.e the Prediction it has made on the test data
vAR_Labels_Pred = vAR_pd.DataFrame(vAR_Labels_Pred,columns={'Predicted_Inter_Transaction_Weighted_Accuracy'})
#vAR_Features_test = vAR_Features_test.sort()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 9 - Write Model Outcome to File
# Write the Model Output to an excel file for analysis.
vAR_df7 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_df8 = vAR_df7.iloc[:,:-1]
vAR_df10 = vAR_df8.merge(vAR_Labels_Pred,left_index=True, right_index=True)
vAR_df11 = vAR_df10.to_excel(vAR_Fetched_Data_Model_Path)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 10 - To open and view the file outcome
# Open the Written File & Check the Outcome as Shown. Execute to View the data
vAR_df12 = vAR_pd.read_excel(vAR_Fetched_Data_Model_Path)
vAR_df12.head()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_PREDICT_WEIGHTED_ACCURACY_OF_INTERCOMPANY_TRANSACTION_RNN
Purpose : A Program in Python for Predicting Weighted Accuracy of IC Using RNN in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 08/01/2019 13:19 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Predicting Weighted Accuracy of IC Using RNN in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
# coding=utf-8
# Step 0 - Read Data from .INI File for Hardcoded Values
import sys
#print('Arguments:', len(sys.argv))
#vAR_Fetched_Data_INI_File_Path = sys.argv[1]
#print(vAR_Fetched_Data_INI_File_Path)
import configparser
vAR_Config = configparser.ConfigParser(allow_no_value=True)
import os
vAR_INI_File_Path = os.environ.get('PYTHON_TUTORIAL')
import pandas as vAR_pd
import configparser
import pandas as vAR_pd
vAR_Config = configparser.ConfigParser(allow_no_value=True)
vAR_Config.read(vAR_INI_File_Path)
vAR_CSLAB_INI_File = vAR_Config['Data File Path']['vAR_CSLAB_PROGRAM_359_INI_FILE']
vAR_Config.read(vAR_CSLAB_INI_File)
vAR_Data = vAR_Config.sections()
vAR_Config.sections()
vAR_Fetched_Data_Source = vAR_Config['Data Source']['DATA_SOURCE1']
#print(vAR_Fetched_Data_Source)
vAR_Fetched_Data_Source_Connection_String = vAR_Config['Data Source Connection String']['SAP_CONNECTION_STRING']
#print(vAR_Fetched_Data_Source_Connection_String)
vAR_Fetched_Data_Source_Path_Input_Data = vAR_Config['Data Source Path']['INPUT_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Input_Data)
vAR_Fetched_Data_Source_Path_Train_Data = vAR_Config['Data Source Path']['TRAIN_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Train_Data)
vAR_Fetched_Data_Source_Path_Test_Data = vAR_Config['Data Source Path']['Test_DATA_PATH']
#print(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_Fetched_Data_Train_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Train_Features1)
vAR_Fetched_Data_Train_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Train_Features2)
vAR_Fetched_Data_Train_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Train_Features3)
vAR_Fetched_Data_Train_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Train_Features4)
vAR_Fetched_Data_Train_All_Features = vAR_Config['Train Features - Problem 1']['ALL_FEATURES_TRAIN']
#print(vAR_Fetched_Data_Train_All_Features)
vAR_Fetched_Data_Test_Features1 = vAR_Config['Train Features - Problem 1']['FEATURE1']
#print(vAR_Fetched_Data_Test_Features1)
vAR_Fetched_Data_Test_Features2 = vAR_Config['Train Features - Problem 1']['FEATURE2']
#print(vAR_Fetched_Data_Test_Features2)
vAR_Fetched_Data_Test_Features3 = vAR_Config['Train Features - Problem 1']['FEATURE3']
#print(vAR_Fetched_Data_Test_Features3)
vAR_Fetched_Data_Test_Features4 = vAR_Config['Train Features - Problem 1']['FEATURE4']
#print(vAR_Fetched_Data_Test_Features4)
vAR_Fetched_Data_Test_All_Features = vAR_Config['Test Features - Problem 1']['ALL_FEATURES_TEST']
#print(vAR_Fetched_Data_Test_All_Features)
vAR_Fetched_Data_Model_Path = vAR_Config['Model Ouput Path']['MODEL_OUTPUT_PATH']
#print(vAR_Fetched_Data_Model_Path)
vAR_Fetched_Data_Best_Fit_File_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_File_Example_1)
vAR_Fetched_Data_Best_Fit_File_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_File_Example_2)
vAR_Fetched_Data_Best_Fit_File_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_File_Example_3)
vAR_Fetched_Data_Best_Fit_Image_Example_1 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_1)
vAR_Fetched_Data_Best_Fit_Image_Example_2 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_2)
vAR_Fetched_Data_Best_Fit_Image_Example_3 = vAR_Config['Model Fitting']['BEST_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Best_Fit_Image_Example_3)
vAR_Fetched_Data_Under_Fit_File_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_File_Example_1)
vAR_Fetched_Data_Under_Fit_File_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_File_Example_2)
vAR_Fetched_Data_Under_Fit_File_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_File_Example_3)
vAR_Fetched_Data_Under_Fit_Image_Example_1 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_1)
vAR_Fetched_Data_Under_Fit_Image_Example_2 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_2)
vAR_Fetched_Data_Under_Fit_Image_Example_3 = vAR_Config['Model Fitting']['UNDER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Under_Fit_Image_Example_3)
vAR_Fetched_Data_Over_Fit_File_Example_1 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_File_Example_1)
vAR_Fetched_Data_Over_Fit_File_Example_2 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_File_Example_2)
vAR_Fetched_Data_Over_Fit_File_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_FILE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_File_Example_3)
vAR_Fetched_Data_Over_Fit_Image_Example_1 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_1)
vAR_Fetched_Data_Over_Fit_Image_Example_2 = vAR_Config['Model Fitting']['OvER_FIT_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_2)
vAR_Fetched_Data_Over_Fit_Image_Example_3 = vAR_Config['Model Fitting']['OVER_FIT_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Over_Fit_Image_Example_3)
vAR_Fetched_Data_Cross_Validation_Image_Example_1 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_1']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_1)
vAR_Fetched_Data_Cross_Validation_Image_Example_2 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_2']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_2)
vAR_Fetched_Data_Cross_Validation_Image_Example_3 = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_IMAGE_EXAMPLE_3']
#print(vAR_Fetched_Data_Cross_Validation_Image_Example_3)
vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['BEFORE_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_Before_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_After_Hyperparameter_Tuning_Image = vAR_Config['Model_Validation_Tuning']['AFTER_HYPERPARAMETER_TUNING_IMAGE']
#print(vAR_Fetched_Data_After_Hyperparameter_Tuning_Image)
vAR_Fetched_Data_Model_Fitting_Best_Fit_Test = vAR_Config['Model Fitting']['BEST_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Best_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Under_Fit_Test = vAR_Config['Model Fitting']['UNDER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Under_Fit_Test)
vAR_Fetched_Data_Model_Fitting_Over_Fit_Test = vAR_Config['Model Fitting']['OVER_FIT_TEST_REQUIRED']
#print(vAR_Fetched_Data_Model_Fitting_Over_Fit_Test)
vAR_Fetched_Data_Cross_Validation_Required = vAR_Config['Model_Validation_Tuning']['CROSS_VALIDATION_REQUIRED']
#print(Fetched_Data_Cross_Validation_Required)
vAR_Fetched_Data_Hyperparameter_Tuning_Required = vAR_Config['Model_Validation_Tuning']['HYPERPARAMETERS_TUNING_REQUIRED']
#print(Fetched_Data_Hyperparameter_Tuning_Required)
# Step 1 - Import the Required Libraries
#Our Model Implementation needs the Following Libraries:
#Sklearn: Sklearn is the Machine Learning Library which is used for numerical & scientific computations.
#Pandas: Pandas is a library used for data manipulation and analysis.
#In Our Implementation. we are using it for Importing the Data file & Creating Dataframes (Stores the Data).
import pandas as vAR_pd
from sklearn.preprocessing import LabelEncoder
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import LSTM
from keras.optimizers import Adam
from keras.layers import Embedding
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 2 - Import Training Data
#Next step after importing all libraries is getting the Training data imported.
#We are importing the Clustering data stored in our local system with the use of Pandas library.
vAR_df = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Train_Data)
vAR_df.head(3)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 3 – Select the Features & Lables
vAR_Features_Train = vAR_pd.read_excel(vAR_Fetched_Data_Train_All_Features)
vAR_Features_Train = vAR_Features_Train.values
vAR_Features_Train = vAR_Features_Train.reshape((vAR_Features_Train.shape[0],vAR_Features_Train.shape[1],1))
vAR_Labels_Train = vAR_df.iloc[:,12]
vAR_Labels_Train = vAR_Labels_Train.values
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 4 – Train the Model
# Training the data means Making the model to Learn, understand & recognize the Pattern in the data.
vAR_model = Sequential()
vAR_model.add(LSTM(256,input_shape=(5,1)))
vAR_model.add(Dropout(0.5))
vAR_model.add(Dense(1, activation='sigmoid'))
# Adam optimizer with learning rate of 0.001
vAR_optimizer = Adam(lr=0.001)
vAR_model.compile(loss='mean_squared_error', optimizer='Adam')
# Train the model
vAR_model.fit(vAR_Features_Train, vAR_Labels_Train, verbose=0, batch_size=5, epochs=200)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 5 – Review Learning AlgorithmvAR_Labels_Train
# We Review the Algorithm as to see how it has learned from the Features we Provided
vAR_model.predict(vAR_Features_Train).astype(int)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 6 - Import Test Data
# Importing the Test Data is to check how the data used on the Model Performs
vAR_df6 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_df6.head(5)
vAR_Features_Test = vAR_pd.read_excel(vAR_Fetched_Data_Test_All_Features)
vAR_Features_Test = vAR_Features_Test.values
vAR_Features_Test = vAR_Features_Test.reshape((vAR_Features_Test.shape[0],vAR_Features_Test.shape[1],1))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 7 – Running Model on Test Data
# Running the Model on Test Data is to use the imported test data to Prodict our Outcome
vAR_Labels_Pred = vAR_model.predict(vAR_Features_Test).astype(int)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 8 – Review Model Outcome
# We check the Output of Model i.e the Prediction it has made on the test data
vAR_Labels_Pred = vAR_pd.DataFrame(vAR_Labels_Pred,columns={'Predicted_Inter_Transaction_Weighted_Accuracy'})
#vAR_Features_test = vAR_Features_test.sort()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 9 - Write Model Outcome to File
# Write the Model Output to an excel file for analysis.
vAR_df7 = vAR_pd.read_excel(vAR_Fetched_Data_Source_Path_Test_Data)
vAR_df8 = vAR_df7.iloc[:,:-1]
vAR_df10 = vAR_df8.merge(vAR_Labels_Pred,left_index=True, right_index=True)
vAR_df11 = vAR_df10.to_excel(vAR_Fetched_Data_Model_Path)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
# Step 10 - To open and view the file outcome
# Open the Written File & Check the Outcome as Shown. Execute to View the data
vAR_df12 = vAR_pd.read_excel(vAR_Fetched_Data_Model_Path)
vAR_df12.head()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>#
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_PARTITIONED_EMBEDDINGS
Purpose : A Program in Python for Partitioned Embeddings in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 08/01/2019 14:37 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Partitioned Embeddings in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
# Explores a partitioned embedding.
from __future__ import print_function
import numpy as vAR_np
import tensorflow as vAR_tf
vAR_CSLAB_vocab_size = 20
vAR_CSLAB_npartitions = 4
vAR_CSLAB_vocab_per_partition = vAR_CSLAB_vocab_size // vAR_CSLAB_npartitions
vAR_CSLAB_embedding_dim = 3
vAR_CSLAB_batch_size = 16
vAR_CSLAB_dataset = vAR_tf.placeholder(vAR_tf.int32, shape=[vAR_CSLAB_batch_size])
vAR_CSLAB_embeddings = []
for _ in range(vAR_CSLAB_npartitions):
vAR_CSLAB_embeddings.append(vAR_tf.Variable(vAR_tf.random_uniform(
[vAR_CSLAB_vocab_per_partition, vAR_CSLAB_embedding_dim], -1.0, 1.0)))
vAR_CSLAB_embed_out = vAR_tf.nn.embedding_lookup(vAR_CSLAB_embeddings,
vAR_CSLAB_dataset,
partition_strategy='div',
validate_indices=True)
with vAR_tf.Session() as vAR_CSLAB_sess:
vAR_tf.initialize_all_variables().run()
print('dataset shape:', vAR_CSLAB_dataset.get_shape())
print('embeddings shapes:',
["{0}: {1}".format(i, vAR_CSLAB_embeddings[i].get_shape())
for i in range(vAR_CSLAB_npartitions)])
print('embed_out shape:', vAR_CSLAB_embed_out.get_shape())
vAR_CSLAB_indata = vAR_np.random.randint(0, vAR_CSLAB_vocab_size, size=(vAR_CSLAB_batch_size,))
print('indata:', vAR_CSLAB_indata)
vAR_CSLAB_emb = [0] * vAR_CSLAB_npartitions
vAR_CSLAB_emb[0], vAR_CSLAB_emb[1], vAR_CSLAB_emb[2], vAR_CSLAB_emb[3], vAR_CSLAB_embed_out = vAR_CSLAB_sess.run(
fetches=[vAR_CSLAB_embeddings[0], vAR_CSLAB_embeddings[1], vAR_CSLAB_embeddings[2], vAR_CSLAB_embeddings[3],
vAR_CSLAB_embed_out],
feed_dict={vAR_CSLAB_dataset: vAR_CSLAB_indata})
for i in range(vAR_CSLAB_npartitions):
print('embeddings[{0}]\n'.format(i), vAR_CSLAB_emb[i])
print('embed_out:\n', vAR_CSLAB_embed_out)
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_SHAPE_EMBEDDINGS
Purpose : A Program in Python for Shape Embeddings in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 08/01/2019 15:15 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Shape Embeddings in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
from __future__ import print_function
import numpy as vAR_np
import tensorflow as vAR_tf
vAR_CSLAB_vocab_size = 10
vAR_CSLAB_embedding_dim = 5
vAR_CSLAB_batch_size = 16
# The data set is an array of integer values, each being an ID in the range
# [0, vocab_size)
vAR_CSLAB_dataset = vAR_tf.placeholder(vAR_tf.int32, shape=[vAR_CSLAB_batch_size])
# embedding is a lookup table for IDs, mapping them into
# embedding_dim-dimensional vectors.
vAR_CSLAB_embedding = vAR_tf.Variable(vAR_tf.random_uniform(
[vAR_CSLAB_vocab_size, vAR_CSLAB_embedding_dim], -1.0, 1.0))
vAR_CSLAB_embed_out = vAR_tf.nn.embedding_lookup(vAR_CSLAB_embedding, vAR_CSLAB_dataset)
with vAR_tf.Session() as vAR_sess:
vAR_tf.initialize_all_variables().run()
print('dataset shape:', vAR_CSLAB_dataset.get_shape())
print('embedding shape:', vAR_CSLAB_embedding.get_shape())
print('embed_out shape:', vAR_CSLAB_embed_out.get_shape())
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
/**************************************
File Name : CSLAB_DEEP_LEARNING_GRADIENT_NUMGRAD_FUNCTION
Purpose : A Program in Python for Numgrad Function in Deep Learning
Author : DeepSphere.AI, Inc.
Date and Time : 08/01/2019 15:42 hrs
Version : 1.0
/***********************************************
## Program Description : Program in Python for Numgrad Function in Deep Learning
## Python Development Environment & Runtime - Python, Anaconda
import numpy as vAR_np
def vAR_CSLAB_eval_numerical_gradient(f, vAR_CSLAB_x, verbose=False, h=1e-5):
vAR_CSLAB_grad = vAR_np.zeros_like(vAR_CSLAB_x)
vAR_CSLAB_it = vAR_np.nditer(vAR_CSLAB_x, flags=['multi_index'], op_flags=['readwrite'])
while not vAR_CSLAB_it.finished:
vAR_CSLAB_ix = vAR_CSLAB_it.multi_index
vAR_CSLAB_oldval = vAR_CSLAB_x[vAR_CSLAB_ix]
vAR_CSLAB_x[vAR_CSLAB_ix] = vAR_CSLAB_oldval + h
vAR_CSLAB_fxph = f(vAR_CSLAB_x) # evalute f(x + h)
vAR_CSLAB_x[vAR_CSLAB_ix] = vAR_CSLAB_oldval - h
vAR_CSLAB_fxmh = f(vAR_CSLAB_x) # evaluate f(x - h)
vAR_CSLAB_x[vAR_CSLAB_ix] = vAR_CSLAB_oldval # restore
# compute the partial derivative with centered formula
vAR_CSLAB_grad[vAR_CSLAB_ix] = (vAR_CSLAB_fxph - vAR_CSLAB_fxmh) / (2 * h)
if verbose:
print(vAR_CSLAB_ix, vAR_CSLAB_grad[vAR_CSLAB_ix])
vAR_CSLAB_it.iternext()
return vAR_CSLAB_grad
/*********************************************
Disclaimer:
We are providing this code block strictly for learning and researching. This is not a production-ready code. We assume no liability for this code under any circumstance. By using this code, users assume full risk. All software, hardware, and other products that are referenced in these materials, belong to the respective vendor who developed or who owns this product.
/*********************************************
