Inheritance diagram for QNLP.proc.DisCoCat.qdb_mixin:

Collaboration diagram for QNLP.proc.DisCoCat.qdb_mixin:

Public Member Functions
def	create_table_discocat (self, table_name="qnlp")

def	db_insert_discocat (self, values, dataset="basis", data_type="noun", table_name="qnlp")

def	create_table (self, table_name="qnlp")

def	drop_table (self, table_name="qnlp")

def	connect_db (self)

def	close_db (self)

def	db_insert (self, Dict values, data_type="noun", table_name="qnlp")

def	db_load (self, data_type="noun", table_name="qnlp", direction="forward")

def	db_print (self, table_name="qnlp")

Data Fields
	db_name

	db_path

	db_full_path

	db_conn

Detailed Description

Definition at line 13 of file DisCoCat.py.

Member Function Documentation

◆ close_db()

def QNLP.io.qnlp_db.qnlp_db.close_db ( self )

inherited

If there is an active connection, close it.

Definition at line 85 of file qnlp_db.py.

     def close_db(self):
         """If there is an active connection, close it."""
         if self.db_conn:
             self.db_conn.close()
             self.db_conn = None
         print("Database %s closed" % self.db_full_path)
         

References QNLP.io.qnlp_db.qnlp_db.db_conn, and QNLP.io.qnlp_db.qnlp_db.db_full_path.

◆ connect_db()

def QNLP.io.qnlp_db.qnlp_db.connect_db ( self )

inherited

If there is an active DB connection, return it. If not, create one.

Definition at line 71 of file qnlp_db.py.

     def connect_db(self):
         """If there is an active DB connection, return it. If not, create one."""
         if self.db_conn is not None:
             return self.db_conn
         try:
             self.db_conn = sqlite3.connect(self.db_full_path+".sqlite")
 
             return self.db_conn
         except Exception as e:
             print("DB access error: {0}".format(e))
         return None
 

References QNLP.io.qnlp_db.qnlp_db.db_conn, and QNLP.io.qnlp_db.qnlp_db.db_full_path.

Referenced by QNLP.io.qnlp_db.qnlp_db.create_table(), QNLP.proc.DisCoCat.qdb_mixin.create_table_discocat(), QNLP.io.qnlp_db.qnlp_db.db_insert(), QNLP.proc.DisCoCat.qdb_mixin.db_insert_discocat(), QNLP.io.qnlp_db.qnlp_db.db_load(), QNLP.io.qnlp_db.qnlp_db.db_print(), and QNLP.io.qnlp_db.qnlp_db.drop_table().

Here is the caller graph for this function:

◆ create_table()

def QNLP.io.qnlp_db.qnlp_db.create_table	(	self,
		table_name = `"qnlp"`
	)

inherited

Create the database table for tagging the required data. The DB has columns
for type (noun, verb, etc.), bin_id (binary string representing the type),
weight (calculable from frequency of occurrence relative to other terms),
and mapping_dir (1 indicates string to bin_id, or -1 bin_id to string mapping).

Definition at line 22 of file qnlp_db.py.

     def create_table(self, table_name="qnlp"):
         """
         Create the database table for tagging the required data. The DB has columns
         for type (noun, verb, etc.), bin_id (binary string representing the type),
         weight (calculable from frequency of occurrence relative to other terms),
         and mapping_dir (1 indicates string to bin_id, or -1 bin_id to string mapping).
         """
         cr_tbl = """CREATE TABLE {}(
                     id INTEGER PRIMARY KEY, type TEXT, 
                     name TEXT,     bin_id INTEGER, 
                     weight REAL,   mapping_dir INTEGER
                     );""".format(table_name)
 
         conn = self.connect_db()
         c = conn.cursor()
 
         try:
             c.execute(cr_tbl)
 
         except sqlite3.OperationalError as oe:
             remove_db = input("Table '{}' already exists. Remove? y/n: ".format(table_name))
             if remove_db is "y":
                 self.drop_table(table_name)
                 self.create_table(table_name)
 
         except Exception as e:
             print("SQLITE exception thrown: {0}".format(e), "Exiting program.")
             exit()
 
         finally:
             conn.commit()
 
 

References QNLP.io.qnlp_db.qnlp_db.connect_db(), QNLP.io.qnlp_db.qnlp_db.create_table(), and QNLP.io.qnlp_db.qnlp_db.drop_table().

Referenced by QNLP.io.qnlp_db.qnlp_db.create_table(), and QNLP.io.qnlp_db.qnlp_db.db_insert().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_table_discocat()

def QNLP.proc.DisCoCat.qdb_mixin.create_table_discocat	(	self,
		table_name = `"qnlp"`
	)

Create the database table for tagging the required data. The DB has columns
for dataset ('basis' or 'corpus'), data_type ('verb', 'noun', etc.), token (the string value), mapping_idx (the index of the mapped binary value; for superpos states, this index labels the number of values in the superposition), map_bin_id (the binary value representing the quantum state in the register), map_coeff_r/i (real and imaginary coefficients of the map_bin_id state), mapping_dir (indicates the direction of the mapping; may not be used).

Definition at line 14 of file DisCoCat.py.

     def create_table_discocat(self, table_name="qnlp"):
         """
         Create the database table for tagging the required data. The DB has columns
         for dataset ('basis' or 'corpus'), data_type ('verb', 'noun', etc.), token (the string value), mapping_idx (the index of the mapped binary value; for superpos states, this index labels the number of values in the superposition), map_bin_id (the binary value representing the quantum state in the register), map_coeff_r/i (real and imaginary coefficients of the map_bin_id state), mapping_dir (indicates the direction of the mapping; may not be used).
         """
         cr_tbl = """CREATE TABLE {}(
                     id INTEGER PRIMARY KEY, 
                     dataset TEXT,
                     data_type TEXT,
                     token TEXT,
                     mapping_idx INTEGER,
                     map_bin_id INTEGER,
                     map_coeff_r REAL,
                     map_coeff_i REAL,
                     mapping_dir INTEGER
                     );""".format(table_name)
         conn = super(qdb_mixin, self).connect_db()
         c = conn.cursor()
 
         try:
             c.execute(cr_tbl)
 
         except sqlite3.OperationalError as oe:
             remove_db = input("Table '{}' already exists. Remove? y/n: ".format(table_name))
             if remove_db is "y":
                 self.drop_table(table_name)
                 self.create_table_discocat(table_name)
 
         except Exception as e:
             print("SQLITE exception thrown: {0}".format(e), "Exiting program.")
             exit()
 
         finally:
             conn.commit()
 

References QNLP.io.qnlp_db.qnlp_db.connect_db(), QNLP.proc.DisCoCat.qdb_mixin.create_table_discocat(), and QNLP.io.qnlp_db.qnlp_db.drop_table().

Referenced by QNLP.proc.DisCoCat.qdb_mixin.create_table_discocat(), and QNLP.proc.DisCoCat.qdb_mixin.db_insert_discocat().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_insert()

def QNLP.io.qnlp_db.qnlp_db.db_insert	(		self,
		Dict	values,
			data_type = `"noun"`,
			table_name = `"qnlp"`
	)

inherited

Insert the tag to binary encoding mapping into the DB.

values      -- Dict mapping string to binary value, and binary value to string.
data_type   -- String to indicate the type of data to be stored
table_name  -- Name of table to store in DB

The DB insert operation below assumes the value field of a key in DB is a tuple,
containing (binary_id, weight of occurrence), where weight of occurrence cant be
determined by the proximity of the word to other words; essentially a count in the 
simplest case. The mapping checks to see if the index is convertible to a numeric
type. If so, this will imply the reverse mapping (ie qubit result to string val), 
and is indicated by -1. Otherwise, this will be a forward mapping, and given by 1.

Definition at line 94 of file qnlp_db.py.

     def db_insert(self, values: Dict, data_type="noun", table_name="qnlp"):
         """
         Insert the tag to binary encoding mapping into the DB.
 
         values      -- Dict mapping string to binary value, and binary value to string.
         data_type   -- String to indicate the type of data to be stored
         table_name  -- Name of table to store in DB
         """
 
         #Proposed modification; weight set to 0 currently
         '''
         The DB insert operation below assumes the value field of a key in DB is a tuple,
         containing (binary_id, weight of occurrence), where weight of occurrence cant be
         determined by the proximity of the word to other words; essentially a count in the 
         simplest case. The mapping checks to see if the index is convertible to a numeric
         type. If so, this will imply the reverse mapping (ie qubit result to string val), 
         and is indicated by -1. Otherwise, this will be a forward mapping, and given by 1.
         '''
         conn = self.connect_db()
         c = conn.cursor()
         self.create_table(table_name)
         
         for k,v in values.items():
             if not str(k).isnumeric():
                 c.execute('''INSERT INTO {} 
                     (type, name, bin_id, weight ) VALUES(?,?,?,?)'''.format(table_name), 
                     (data_type, k, int(v,2), 0 )
                 )
                 print (data_type, k, int(v,2), 0 )
         conn.commit()
 

References QNLP.io.qnlp_db.qnlp_db.connect_db(), and QNLP.io.qnlp_db.qnlp_db.create_table().

Here is the call graph for this function:

◆ db_insert_discocat()

def QNLP.proc.DisCoCat.qdb_mixin.db_insert_discocat	(	self,
		values,
		dataset = `"basis"`,
		data_type = `"noun"`,
		table_name = `"qnlp"`
	)

Insert the tag to binary encoding mapping into the DB.

values      -- Dict mapping string to binary value, and binary value to string.
data_type   -- String to indicate the type of data to be stored
table_name  -- Name of table to store in DB

The DB insert operation below assumes the value field of a key in DB is a tuple,
containing (binary_id, weight of occurrence), where weight of occurrence cant be
determined by the proximity of the word to other words; essentially a count in the 
simplest case. The mapping checks to see if the index is convertible to a numeric
type. If so, this will imply the reverse mapping (ie qubit result to string val), 
and is indicated by -1. Otherwise, this will be a forward mapping, and given by 1.

Definition at line 49 of file DisCoCat.py.

     def db_insert_discocat(self, values, dataset="basis", data_type="noun", table_name="qnlp"):
         """
         Insert the tag to binary encoding mapping into the DB.
 
         values      -- Dict mapping string to binary value, and binary value to string.
         data_type   -- String to indicate the type of data to be stored
         table_name  -- Name of table to store in DB
         """
 
         '''
         The DB insert operation below assumes the value field of a key in DB is a tuple,
         containing (binary_id, weight of occurrence), where weight of occurrence cant be
         determined by the proximity of the word to other words; essentially a count in the 
         simplest case. The mapping checks to see if the index is convertible to a numeric
         type. If so, this will imply the reverse mapping (ie qubit result to string val), 
         and is indicated by -1. Otherwise, this will be a forward mapping, and given by 1.
         '''
         conn = super(qdb_mixin, self).connect_db()
         c = conn.cursor()
         self.create_table_discocat(table_name)
         
         for corpus_token, superpos in values.items():
             l_superpos = len(superpos)
             for idx, (distance_measure, basis_state) in enumerate(superpos):
                 c.execute("""INSERT INTO {} ( 
                     dataset, 
                     data_type, 
                     token, 
                     mapping_idx, 
                     map_bin_id, 
                     map_coeff_r, 
                     map_coeff_i, 
                     mapping_dir ) VALUES(?,?,?,?,?,?,?,?)""".format(table_name), 
                     (dataset, 
                     data_type, 
                     corpus_token, 
                     idx, 
                     basis_state, 
                     distance_measure.real, 
                     distance_measure.imag, 
                     0)
                 )
         conn.commit()
 

References QNLP.io.qnlp_db.qnlp_db.connect_db(), and QNLP.proc.DisCoCat.qdb_mixin.create_table_discocat().

Here is the call graph for this function:

◆ db_load()

def QNLP.io.qnlp_db.qnlp_db.db_load	(	self,
		data_type = `"noun"`,
		table_name = `"qnlp"`,
		direction = `"forward"`
	)

inherited

Load the tag to binary encoded mapping into from DB.

data_type   -- Data type to load from the DB (noun, verb, etc)
table_name  -- Database table to load data
direction   -- Direction of the returned mapping (forward: tag -> int, reverse: int -> tag)

Definition at line 128 of file qnlp_db.py.

     def db_load(self, data_type="noun", table_name="qnlp", direction="forward"):
         """
         Load the tag to binary encoded mapping into from DB.
 
         data_type   -- Data type to load from the DB (noun, verb, etc)
         table_name  -- Database table to load data
         direction   -- Direction of the returned mapping (forward: tag -> int, reverse: int -> tag)
         """
 
         conn = self.connect_db()
         c = conn.cursor()
 
         c.execute('''SELECT name, bin_id FROM {} WHERE type=?'''.format(table_name), (data_type,) )
     
         all_rows = c.fetchall()
         dat = {}
 
         for r in all_rows:
             if( direction == "forward" ):
                 dat.update({r[0] : [r[1]]})
             elif( direction == "reverse" ):
                 #No need to carry second term as list for reverse mapping
                 dat.update({r[1] : r[0]})
             else:
                 print("Direction not understood. Please try again")
                 exit()
 
         return dat
 

References QNLP.io.qnlp_db.qnlp_db.connect_db().

Here is the call graph for this function:

◆ db_print()

def QNLP.io.qnlp_db.qnlp_db.db_print	(	self,
		table_name = `"qnlp"`
	)

inherited

Prints all the available data stored in the DB

Definition at line 159 of file qnlp_db.py.

     def db_print(self, table_name="qnlp"):
         """Prints all the available data stored in the DB"""
 
         conn = self.connect_db()
         c = conn.cursor()
 
         c.execute('''SELECT type, name, bin_id, weight FROM {}'''.format(table_name),
                     #        WHERE type=? AND bin_id=? AND mapping=?''', 
                     #    ()
         )
         print("################################################################")
         print("type\t\tbin_id\t\tweight\t\tmapping_dir")
         print("################################################################")
         all_rows = c.fetchall()
         for row in all_rows:
             print('{0}\t\t{1}\t\t{2}\t\t{3}'.format(row[0], row[1], row[2], row[3] ))
 

References QNLP.io.qnlp_db.qnlp_db.connect_db().

Here is the call graph for this function:

◆ drop_table()

def QNLP.io.qnlp_db.qnlp_db.drop_table	(	self,
		table_name = `"qnlp"`
	)

inherited

Drops the table if it exists.

Definition at line 57 of file qnlp_db.py.

     def drop_table(self, table_name="qnlp"):
         """Drops the table if it exists."""
         dr_tbl = """DROP TABLE if EXISTS {};""".format(table_name)
         try:
             conn = self.connect_db()
             c = conn.cursor()
             c.execute(dr_tbl)
             conn.commit()
 
         except Exception as e:
             print("DB access error: {0}".format(e))
 

References QNLP.io.qnlp_db.qnlp_db.connect_db().

Referenced by QNLP.io.qnlp_db.qnlp_db.create_table(), and QNLP.proc.DisCoCat.qdb_mixin.create_table_discocat().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ db_conn

QNLP.io.qnlp_db.qnlp_db.db_conn

inherited

Definition at line 18 of file qnlp_db.py.

Referenced by QNLP.io.qnlp_db.qnlp_db.close_db(), and QNLP.io.qnlp_db.qnlp_db.connect_db().

◆ db_full_path

QNLP.io.qnlp_db.qnlp_db.db_full_path

inherited

Definition at line 17 of file qnlp_db.py.

Referenced by QNLP.io.qnlp_db.qnlp_db.close_db(), and QNLP.io.qnlp_db.qnlp_db.connect_db().

◆ db_name

QNLP.io.qnlp_db.qnlp_db.db_name

inherited

Definition at line 15 of file qnlp_db.py.

◆ db_path

QNLP.io.qnlp_db.qnlp_db.db_path

inherited

Definition at line 16 of file qnlp_db.py.

The documentation for this class was generated from the following file:

/Users/mlxd/Desktop/intel-qnlp-rc2/modules/py/pkgs/QNLP/proc/DisCoCat.py

Public Member Functions

Data Fields

Detailed Description

Member Function Documentation

◆ close_db()

◆ connect_db()

◆ create_table()

◆ create_table_discocat()

◆ db_insert()

◆ db_insert_discocat()

◆ db_load()

◆ db_print()

◆ drop_table()

Field Documentation

◆ db_conn

◆ db_full_path

◆ db_name

◆ db_path