def __init__(self, provider=None, is_plot=True):
if provider is None:
self._provider = DataProvider()
self._provider.do()
else:
self._provider = provider
self._is_plot = is_plot
def trinaryReadsDF(csv_file=None, df_sample=None,
csv_dir=cn.SAMPLES_DIR, is_display_errors=True):
"""
Creates trinary values for read counts w.r.t. data provider.
(a) adjusting for gene length, (b) library size,
(c) log2, (d) ratio w.r.t. T0.
Data may come from an existing dataframe or a CSV file.
:param str csv_file: File in "samples" directory.
columns are: "GENE_ID", instance ids
:param pd.DataFrame df_sample: columns are genes,
index are instances, values are raw readcounts
:param str csv_dir: directory where csv file is found
:return pd.DataFrame: columns are genes,
indexes are instances, trinary values
At least one of df_sample and csv_file must be non-null
"""
provider = DataProvider(is_display_errors=is_display_errors)
provider.do()
if df_sample is None:
path = os.path.join(csv_dir, csv_file)
df_sample = pd.read_csv(path)
df_sample.index = df_sample['GENE_ID']
del df_sample['GENE_ID']
#
df_normalized = provider.normalizeReadsDF(df_sample)
# Compute trinary values relative to original reads
df_ref = sum(provider.dfs_adjusted_read_count) \
/ len(provider.dfs_adjusted_read_count) # Mean values
ser_ref = df_ref[cn.REF_TIME]
return calcTrinaryComparison(df_normalized, ser_ref=ser_ref)
def __init__(self, is_display_errors=True, is_averaged=True):
"""
:param bool is_display_errors: Shows errors encountered
:param bool is_averaged: Use averaged read counts
Public instance variables:
df_X are normalized read counts
states_dict - mapping of literal to numeric values of state
ser_y - numeric value of state corresponding to each row in df_X
"""
self._is_display_errors = is_display_errors
self.provider = DataProvider(is_display_errors=self._is_display_errors)
self.provider.do()
self.df_X = self.provider.df_normalized.T
self.df_X = self.df_X.drop(index="T0")
self.features = self.df_X.columns.tolist()
self.df_X.columns = range(len(self.features))
# Create class information
ser_y = self.provider.df_stage_matrix[cn.STAGE_NAME]
ser_y = ser_y.drop(index="T0")
ser_y = ser_y.copy()
ser_y[ser_y == 'Normoxia'] = 'Resuscitation'
# Create converter from state name to numeric index
states = ser_y.unique()
self.state_dict = {k: v for v, k in enumerate(states)}
self.ser_y = ser_y.apply(lambda k: self.state_dict[k])
def aggregateGenes(df=None, provider=None):
"""
Combines genes that are perfectly correlated in time for trinary
values.
:param DataFrame df: dataframe to transform
:param DataProvider provider: uses df_normalized
:return pd.DataFrame: names are combined for aggregated
genes; calculates trinary values
"""
if df is None:
if provider is None:
provider = DataProvider()
provider.do()
df = provider.df_normalized
df_trinary = makeTrinaryData(df, is_include_nan=False)
dfg = df_trinary.groupby(df_trinary.columns.tolist())
groups = dfg.groups
data = {}
for key, genes in groups.items():
label = "--".join(genes)
data[label] = list(key)
df = pd.DataFrame(data)
df_result = df.T
df_result.columns = df_trinary.columns
return df_result
def testTrinaryReadsDF2(self):
return
# Checks that trinary values computed directly from reads
# are the same as those of normalized samples.
# Get raw value of read counts
provider = DataProvider()
provider.do()
#
def calcTrinaryTimeSample(time_index):
"""
Calculates the trinary value of a time sample
:param str time_index: name of time value
"""
int_index = int(time_index[1:])
df0 = provider.dfs_read_count[0]
num = len(provider.dfs_read_count)
ser = pd.Series(np.repeat(0, len(df0.index)), index=df0.index)
for idx in range(num):
ser += provider.dfs_read_count[idx][int_index]
df = pd.DataFrame(ser/num)
df_result = transform_data.trinaryReadsDF(df_sample=df)
return df_result.T
#
data = TrinaryData()
data.df_X.columns = data.features
for time_index in data.df_X.index:
df_result = calcTrinaryTimeSample(time_index)
import pdb; pdb.set_trace()
def testAggregateGenes(self):
if IGNORE_TEST:
return
provider = DataProvider()
provider.do()
df = transform_data.aggregateGenes(provider=provider)
self.assertTrue(helpers.isValidDataFrame(df,
provider.df_normalized.columns))
def getProvider(provider):
"""
Returns a provider
"""
if provider is None:
provider = DataProvider()
provider.do()
return provider
def __init__(self, df_trinary=None):
"""
:param pd.DataFrame df: trinary valued DF (has values -1, 0, 1)
"""
if df_trinary is None:
provider = DataProvider()
provider.do()
df_trinary = transform_data.makeTrinaryData(is_include_nan=False)
self.df_trinary = df_trinary
self.df_group = None # Dataframe describing groups
self.df_gene_group = None # Genes by group
def __init__(self, term_column=cn.GO_TERM, is_plot=True, **kwargs):
"""
:param str term_column: column in go_terms to use for text
:param dict **kwargs: arguments to DataGrouper
"""
self._is_plot = is_plot
self.provider = DataProvider()
self.provider.do()
self.grouper = DataGrouper(**kwargs)
self.grouper.do(min_size=1)
self.df_matrix = self._makeMatrix(term_column)
self.df_gene_term = self._makeGeneTerm()
def _getData():
provider = DataProvider()
provider.do()
trinary = TrinaryData(is_averaged=False,
is_dropT1=False)
if IS_ONLY_TFS:
columns = set(trinary.df_X.columns).intersection(
provider.tfs)
else:
columns = trinary.df_X.columns
columns = list(columns)
return trinary.df_X[columns], trinary.ser_y
class CVPlotter():
def __init__(self, provider=None, is_plot=True):
if provider is None:
self._provider = DataProvider()
self._provider.do()
else:
self._provider = provider
self._is_plot = is_plot
def heatMap(self, min_cv=0):
"""
Plots a heatmap of the coefficient of variations.
:param pd.DataFrame df_cv: CVs
:param float min_cv: minimum CV to consider
"""
plt.figure(figsize=(16, 10))
df = self._provider.df_cv
# Rename columns to their hours
ax = plt.gca()
ax.set_xticks(np.arange(len(df.columns))+0.5)
ax.set_xticklabels(df.columns)
df = df.applymap(lambda v: v if v >= min_cv else np.nan)
heatmap = plt.pcolor(df, cmap='jet')
plt.colorbar(heatmap)
plt.xlabel("times")
plt.ylabel("gene")
plt.title("Coefficient of Variation > %d percent" % min_cv)
if self._is_plot:
plt.show()
def readsAndDO(self):
"""
Plots the following lines for the hours of the experiments:
Average CV of genes
CV of dissolved oxygen (DO)
Avg dissolved oxygen
"""
hours = self._provider.df_hypoxia[cn.HOURS]
means = self._provider.df_hypoxia[cn.MEAN]
error_bars = [2*s for s in self._provider.df_hypoxia[cn.STD]]
plt.errorbar(hours, means, yerr=error_bars, marker="o")
ax = plt.gca()
# Plot CVs of genes
ser = self._provider.df_cv.mean() # Average over geans
ax.plot(hours, ser.values, linestyle='dashed', marker="o",
color='r')
plt.xlabel("hours")
plt.ylabel("DO/CV")
plt.legend(["CV for read counts", "DO +/- 2 std"])
if self._is_plot:
plt.show()
def __init__(self, is_averaged=True, is_regulator=False, **kwargs):
"""
:param bool is_averaged: Use averaged read counts
:param bool is_regulator: use regulators for TRN
:param dict kwargs: options passed to DataProvider
Public instance variables:
df_X are normalized read counts
instances are either times (begin with T) for stage (S)
ser_y - numeric value of state corresponding to each row in df_X
self.state_dct:
key: state name
value: state index
self.features: list of names of gene
"""
self.provider = DataProvider(**kwargs)
self.provider.do()
if is_averaged:
self.df_X = self.provider.df_normalized.T
else:
# Use the adjusted values for each replication
dfs = [
df.copy()
for df in self.provider.dfs_adjusted_read_count_wrtT0_log2
]
self.df_X = pd.concat([df.T for df in dfs])
drop_indices = self._getDropIndices(self.df_X.index)
self.df_X = self.df_X.drop(drop_indices)
if is_regulator:
subsetToRegulators(self.df_X)
self.features = self.df_X.columns.tolist()
# Create class information
ser_y = self.provider.df_stage_matrix[cn.STAGE_NAME]
if not is_averaged:
# Replica information has a specical time format
num_repl = len(self.provider.dfs_read_count)
sers = []
for idx in range(num_repl):
new_ser_y = ser_y.copy()
new_ser_y.index = self.provider.makeTimes(suffix=idx)
sers.append(new_ser_y)
ser_y = pd.concat(sers)
states = list(cn.STATE_NAMES)
ser_y = ser_y.drop(self._getDropIndices(ser_y.index))
if len(ser_y[ser_y == cn.STATE_NORMOXIA]) \
<= MIN_NUM_NORMOXIA:
ser_y[ser_y == cn.STATE_NORMOXIA] = cn.STATE_RESCUSCITATION
states.remove("Normoxia")
# Create converter from state name to numeric index
self.state_dct = {k: v for v, k in enumerate(states)}
self.ser_y = ser_y.apply(lambda k: self.state_dct[k])
class TestFunctions(unittest.TestCase):
def setUp(self):
self.trinary = TrinaryData()
self.provider = DataProvider()
self.provider.do()
def testCountTerms(self):
if IGNORE_TEST:
return
TERM = "DNA replication"
EXPECTED_COUNT = 2
def test(terms, expected_count, fset=None):
df_gene = self.provider.df_go_terms
if fset is None:
feature_set = FeatureSet(df_gene[xcn.GENE_ID][1:3])
fset = FeatureSet(df_gene[xcn.GENE_ID][1:3])
count = util_classifier.countTerms(fset, terms)
self.assertEqual(count, expected_count)
#
test([TERM], EXPECTED_COUNT)
test([TERM, TERM], 2 * EXPECTED_COUNT)
test(["DUMMY"], 0)
#
fset = FeatureSet(['Rv0981--Rv1332--Rv1828'])
test(["DUMMY"], 0, fset=fset)
def testCountTerms2(self):
if IGNORE_TEST:
return
TERMS = ["a"]
fset = FeatureSet(["Rv2009"])
count1 = util_classifier.countTerms(fset,
TERMS,
is_include_module=False)
count2 = util_classifier.countTerms(fset,
TERMS,
is_include_module=True)
self.assertGreater(count2, count1)
def testExtractAggregatedGene(self):
if IGNORE_TEST:
return
GENES = ['Rv0981', 'Rv1332', 'Rv1828']
AGGREGATED_GENE = xcn.GENE_SEPARATOR.join(GENES)
genes = util_classifier.extractAggregatedGene(AGGREGATED_GENE)
diff = set(GENES).symmetric_difference(genes)
self.assertEqual(len(diff), 0)
def testTrinaryReadsDF1(self):
if IGNORE_TEST:
return
provider = DataProvider()
provider.do()
df = provider.dfs_read_count[0]
df_result = transform_data.trinaryReadsDF(df_sample=df)
# See if number of "-1" is excessive
dff = df_result + df_result.applymap(lambda v: -np.abs(v))
frac_minus1 = -dff.sum().sum() \
/(2*len(df_result)*len(df_result.columns))
self.assertLess(frac_minus1, 0.25)
# Smoke tests for csv
df_result = transform_data.trinaryReadsDF(
csv_file="AM_MDM_Mtb_transcripts_DEseq.csv",
is_display_errors=False)
def _getData(state):
"""
Obtains data for a binary classifier for the class.
:param int state: state for which classification is done
:param pd.DataFrame, pd.Series:
"""
provider = DataProvider()
provider.do()
trinary = TrinaryData(is_averaged=False,
is_dropT1=False)
columns = set(trinary.df_X.columns).intersection(
provider.tfs)
columns = list(columns)
ser_y = trinary.ser_y.apply(lambda v:
1 if v == state else 0)
return trinary.df_X[columns], ser_y
def __init__(self, persister=PERSISTER):
if persister.isExist():
shared_data = persister.get()
for key in shared_data.__dict__.keys():
self.__setattr__(key, shared_data.__getattribute__(key))
else:
self.provider = DataProvider()
self.trinary = trinary_data.TrinaryData(is_averaged=False,
is_dropT1=False,
is_regulator=True)
self.df_X = self.trinary.df_X
self.ser_y = self.trinary.ser_y
self.states = self.ser_y.unique()
data_dir = os.path.join(cn.DATA_DIR, DIRECTORY)
data_path_pat = os.path.join(data_dir, "%d")
analyzer_dct = fa.deserialize(
{s: data_path_pat % s
for s in self.states})
analyzers = analyzer_dct.values()
self.collection_dct = {
s: fsc.FeatureSetCollection.deserialize(data_path_pat % s)
for s in self.states
}
_ = [c.df_fv for c in self.collection_dct.values()]
persister.set(self)
class TestTermAnalyzer(unittest.TestCase):
def setUp(self):
self.provider = DataProvider()
self.provider.do()
self.analyzer = term_analyzer.TermAnalyzer(
self.provider.df_ec_terms, is_plot=IS_PLOT)
def testConstructor(self):
if IGNORE_TEST:
return
self.assertTrue(helpers.isValidDataFrame(self.analyzer.df_term,
self.analyzer.df_term.columns))
def testPlotTermHeatmap(self):
if IGNORE_TEST:
return
self.analyzer.plotTermHeatmap(is_plot=IS_PLOT)
def makeTrinaryData(df=None, min_abs=1.0, is_include_nan=True):
"""
Thresholds data based on its absolute magnitude.
Values are assigned as -1, 0, 1
:param pd.DataFrame df: default is provider.df_normalized
values are in log2 units
:param float min_abs: minimal absolute value to threshold.
:param bool is_include_nan: Include nan values; else set to 0
:return pd.DataFrame: same index and columns as df
"""
if df is None:
provider = DataProvider()
provider.do()
df = provider.df_normalized
df_result = df.copy()
df_result = df_result.applymap(lambda v: 0 if np.abs(v) < min_abs else -1
if v < 0 else 1)
if is_include_nan:
df_result = df_result.applymap(lambda v: np.nan if v == 0 else v)
return df_result
def countTerms(fset, terms, is_include_module=True):
"""
Counts the occurrences of terms in the GO terms
of genes in the FeatureSet.
Parameters
----------
fset: FeatureSet
terms: list-str
is_include_module: bool
consider all genes in modules activated by a
gene in fset
Returns
-------
int
"""
provider = DataProvider()
provider.do()
# Extract the genes
genes = []
[genes.extend(extractAggregatedGene(c)) for c in fset.list]
if is_include_module:
new_genes = []
tfs = list(set(provider.df_trn_unsigned[xcn.TF].tolist()))
for gene in genes:
if gene in tfs:
sel = provider.df_trn_unsigned[xcn.TF] == gene
df = provider.df_trn_unsigned[sel]
new_genes.extend(df[xcn.GENE_ID].tolist())
genes.extend(new_genes)
genes = list(set(genes))
# Compile the string of go terms for the genes
df = provider.df_go_terms
indices = [df[df[xcn.GENE_ID] == g].index.tolist() for g in genes]
indices = [t for l in indices for t in l]
go_terms = df.loc[indices, xcn.GO_TERM].to_list()
go_str = "****".join(go_terms)
count = sum([go_str.count(t) for t in terms])
return count
def aufg06():
#
# Nun sollen die Daten des MNIST-Datensatzes mit den vorher erstellten
# Klassifikatoren klassifiziert werden. Trainieren Sie dazu jeweils mit den
# Trainigsdaten einen Klassifikator und berechnen Sie den sich ergebenden
# Klassifikationsfehler auf dem Testdatensatz. Variieren Sie die
# Parametrisierung der Klassifikatoren,
# um einen moeglichst geringen Klassifikationsfehler zu erreichen.
#
# Trainieren Sie einen Mischverteilungsklassifikator fuer verschiedene mit
# PCA dimensionsreduzierte Versionen des MNIST-Datensatzes und vergleichen
# Sie die erzielten Ergebnisse.
#
# Trainieren Sie einen k-NN-Klassifikator fuer verschiedene mit PCA
# dimensionsreduzierte Versionen des MNIST-Datensatzes und vergleichen Sie
# die erzielten Ergebnisse.
train_data_provider = DataProvider(DataProvider.MNIST_TRAIN_PCA)
test_data_provider = DataProvider(DataProvider.MNIST_TEST_PCA)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
raise NotImplementedError('Implement me')
class TermMatrix(object):
"""
The core dataframe is the term matrix, self.df_matrix. Its columns
are terms; the rows are groups of correlated genes. A group is
a tuple of trinary values indicating when that terms is expressed.
"""
def __init__(self, term_column=cn.GO_TERM, is_plot=True, **kwargs):
"""
:param str term_column: column in go_terms to use for text
:param dict **kwargs: arguments to DataGrouper
"""
self._is_plot = is_plot
self.provider = DataProvider()
self.provider.do()
self.grouper = DataGrouper(**kwargs)
self.grouper.do(min_size=1)
self.df_matrix = self._makeMatrix(term_column)
self.df_gene_term = self._makeGeneTerm()
import pdb
pdb.set_trace()
def _makeTermGroup(self, term_column=cn.GO_TERM):
"""
:param str term_column: column in go_terms to use for text
:return pd.DataFrame:
index - group (time intervals with trinary values)
column - Term
"""
df = self.grouper.df_gene_group.merge(self.provider.df_go_terms,
left_index=True,
right_index=True,
how='inner')
if term_column == cn.INDEX:
df_term = df[[cn.GROUP]].copy()
df_term[term_column] = df.index
else:
df_term = df[[cn.GROUP, term_column]].copy()
df_term = df_term.set_index(cn.GROUP)
return df_term
def _makeMatrix(self, term_column=cn.GO_TERM):
"""
:param str term_column: column in go_terms to use for text
:return pd.DataFrame: matrix with the terms
"""
df_term = self._makeTermGroup(term_column=term_column)
df_result = util_text.makeTermMatrix(df_term[term_column])
return df_result
def _makeGeneTerm(self):
"""
Finds the genes and terms that co-occur at the same times.
:return pd.DataFrame:
cn.GROUP - trinary values for genes at times
cn.TERM - list of GO terms
cn.GENE_D - list of genes
cn.CNT_TERM - count of GO terms
cn.CNT_GENE - count of genes
cn.CNT_REGULATED - count of times up- down-regulated
"""
def makeGroupedDF(df):
df = df.reset_index()
return df.groupby(cn.GROUP)
def extract(df, key, col):
sel = df.index == key
result = df[sel][col].values.tolist()
return result
#
df_term = self._makeTermGroup()
df_gene = self.grouper.df_gene_group
df_gene = df_gene.reset_index()
df_gene = df_gene.set_index(cn.GROUP)
dfg_term = makeGroupedDF(df_term)
dfg_gene = makeGroupedDF(self.grouper.df_gene_group)
# Find the keys in common
keys_term = [k for k in dfg_term.groups]
keys_gene = [k for k in dfg_gene.groups]
keys_common = set(keys_term).intersection(keys_gene)
dict_df = {cn.GROUP: [], cn.TERM: [], cn.GENE_ID: []}
for key in keys_common:
dict_df[cn.GROUP].append(key)
dict_df[cn.TERM].append(extract(df_term, key, cn.GO_TERM))
dict_df[cn.GENE_ID].append(extract(df_gene, key, cn.GENE_ID))
df_result = pd.DataFrame(dict_df)
df_result[cn.CNT_GENE] = [len(g) for g in df_result[cn.GENE_ID]]
df_result[cn.CNT_TERM] = [len(t) for t in df_result[cn.TERM]]
df_result[cn.CNT_REGULATED] = \
[sum([np.abs(x) for x in g]) for g in df_result[cn.GROUP]]
return df_result
def makeAggregationMatrix(self, predicates):
"""
Creates a matrix with columns the same as df_matrix
and row i that is the summation of the values in rows
that satisfy predicate i.
:param list-BooleanFunc predicates: predicate on group tuples
"""
columns = self.df_matrix.columns
column_values = {c.strip(): [] for c in columns}
for pos, predicate in enumerate(predicates):
row = np.repeat(0.0, len(columns))
row = row.reshape(1, len(columns))
# TODO: Fix predicates
if False:
for group in self.df_matrix.index:
if predicate(group):
values = np.array(self.df_matrix.loc[[group], :])
row += values
for group in self.df_matrix.index:
if group[pos] == 1:
values = np.array(self.df_matrix.loc[[group], :])
row += values
row = row.reshape(len(columns))
# Add the row for this predicate
for idx, col in enumerate(columns):
column_values[col].append(row[idx])
return pd.DataFrame(column_values)
# TODO: Fix use of predicates
def plotAggregation(self, predicates, min_val=0, is_include_ylabels=True):
df = self.makeAggregationMatrix(predicates)
df = df.applymap(lambda v: 0 if v < min_val else v)
df = df.applymap(lambda v: np.nan if np.isclose(v, 0) else v)
# Drop columns that are all nans
for col in df.columns:
if all([np.isnan(v) for v in df[col]]):
del df[col]
# Construct the plot
plt.subplot(1, 2, 2)
heatmap = plt.pcolor(df.transpose(), cmap='jet')
if is_include_ylabels:
ax = plt.gca()
ax.set_yticks(np.arange(len(df.columns)) + 0.5)
ax.set_yticklabels(df.columns, fontsize=8)
plt.title("Term Counts")
plt.colorbar(heatmap)
plt.show()
def makeTimeAggregationMatrix(self, is_up_regulated=True):
"""
Creates a matrix with columns the same as df_matrix
and row i that is the summation of the values in rows
that satisfy predicate i.
:param bool is_up_regulated:
"""
if is_up_regulated:
direction = 1
else:
direction = -1
columns = self.df_matrix.columns
column_values = {c.strip(): [] for c in columns}
for time in range(cn.NUM_TIMES):
row = np.repeat(0.0, len(columns))
row = row.reshape(1, len(columns))
for group in self.df_matrix.index:
if group[time] == direction:
values = np.array(self.df_matrix.loc[[group], :])
row += values
row = row.reshape(len(columns))
# Add the row for this predicate
for idx, col in enumerate(columns):
column_values[col].append(row[idx])
return pd.DataFrame(column_values)
def calcClusters(self, max_distance=1, is_up_regulated=True):
"""
Calculates log significance levels and clusters.
:param float max_distance: maximum distance between clusters,
otherwise merged
:return pd.DataFrame, ndarray, pd.Series:
df_log - log of significance level
row_linkage - linkage matrix
See https://stackoverflow.com/questions/9838861/scipy-linkage-format
ser_cluster - cn.GROUP (indexed by term)
"""
df = self.makeTimeAggregationMatrix(is_up_regulated=is_up_regulated)
# Remove rows with zero variance
df_filtered = util_statistics.filterZeroVarianceRows(df.T)
# Compute significance levels
df_log = util_statistics.calcLogSL(df_filtered, round_decimal=3)
df_log = df_log.applymap(lambda v: HIGH_SL if np.isnan(v) else v)
# Compute the clusters
log_arrays = np.asarray(df_log)
row_linkage = linkage(distance.pdist(log_arrays), method='average')
ser_cluster = pd.Series(
fcluster(row_linkage, 0.1, criterion="distance"))
ser_cluster.index = df_log.index
#
return df_log, row_linkage, ser_cluster
# Include state transitions
# Note how clusters relate to state observations
def plotTimeAggregation(self, is_up_regulated=True):
"""
Plots aggregation of groups over time.
:param bool is_include_ylabels:
:param bool is_up_regulated:
"""
df_log, row_linkage, ser_cluster = \
self.calcClusters(is_up_regulated=is_up_regulated)
# Heatmap
cg = sns.clustermap(df_log,
row_linkage=row_linkage,
col_cluster=False,
cbar_kws={"ticks": [0, 5]},
cmap="Blues")
# Construct a cluster map
#cg = sns.clustermap(df_log, col_cluster=False,
# cbar_kws={"ticks":[0,5]}, cmap="Blues")
# Set the labels
cg.ax_heatmap.set_xlabel("Time")
if is_up_regulated:
direction = "Up"
else:
direction = "Down"
title = "-log10 zscores of %s-regulated term counts" % (direction)
cg.ax_heatmap.set_title(title)
xticks = cg.ax_heatmap.get_xticks() - 0.5 # Correct tick position
cg.ax_heatmap.set_xticks(xticks)
cg.ax_heatmap.set_yticks([])
cg.ax_heatmap.set_yticklabels([])
# Add the state transitions
util_plots.plotStateTransitions(ymax=len(df_log),
ax=cg.ax_heatmap,
is_plot=False)
#
if self._is_plot:
plt.show()
def aufg02():
# In dieser Aufgabe soll ein Bayes'scher Normalverteilungs-Klassifikator
# mit drei Dichten realisiert werden.
#
# Zunaechst sollen Mittelwert und Kovarianzmatrix der drei Klassen geschaetzt
# und visualisiert werden:
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
#
# Extrahieren Sie die Klassen-Labels aus dem Trainingsdatensatz und speichern
# Sie sie in der lokalen Variablen labels
#
# Nuetzliche Funktionen:
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
labels = np.unique(train_labels)
# raise NotImplementedError('Implement me')
mean_list = []
cov_list = []
for label in labels:
#
# Berechnen Sie Mittelwert und Kovarianz der drei Klassen durch
# Matrixoperationen in NumPy.
# Speichern Sie fuer jeden Schleifendurchlauf den Mittelwert in der
# lokalen Variablen mean und die Kovarianzmatrix in der lokalen Variablen
# cov. Benutzen Sie zur Schaetzung die korrigierte Kovarianzmatrix:
# https://de.wikipedia.org/wiki/Stichprobenkovarianz#Korrigierte_Stichprobenkovarianz
class_data = train_data[train_labels == label]
mean = np.mean(class_data, axis=0)
cov = np.cov(class_data, rowvar=0)
# raise NotImplementedError('Implement me')
# -----------------------nachfragen---------------------------
np.testing.assert_almost_equal(actual=mean,
desired=np.mean(class_data, axis=0),
err_msg='Der Mittelwert ist falsch')
np.testing.assert_almost_equal(
actual=cov,
desired=np.cov(class_data, rowvar=0),
err_msg='Die Kovarianzmatrix ist falsch')
mean_list.append(mean)
cov_list.append(cov)
# Visualisieren Sie die Datenpunkte der drei Klassen, sowie die geschaetzen
# Mittelwerte und Kovarianzmatrizen durch eine Normalverteilung.
# Zur Visualisierung der Normalverteilungen: visualization.plot_norm_dist_ellipse
fig = plt.figure()
ax = fig.add_subplot(111)
colors = ['#FF0000', '#00FF00', '#0000FF']
for label, color in zip(labels, colors):
class_data = train_data[train_labels == label]
ax.scatter(class_data[:, 0],
class_data[:, 1],
c=color,
edgecolor=(0, 0, 0))
plot_norm_dist_ellipse(ax, mean_list, cov_list, colors)
plt.show()
# raise NotImplementedError('Implement me')
# Implementieren sie einen Bayes'schen Normalverteilungs-Klassifikator (ohne
# Rueckweisung), der die soeben berechneten Verteilungen als Modell
# verwendet. Vervollstaendigen Sie dazu die Klasse GaussianClassifier im Modul
# classification.
#
# Hinweise:
#
# Achten Sie darauf, dass Ihre Implementierung unabhaengig von den
# verwendeten Klassenlabels ist. Aus den Trainingsdaten lassen sich diese mit
# np.unique bestimmen.
# http://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
#
# Durch welche geeignete monotone Transformation lassen sich numerische
# Probleme bei der Auswertung von extrem kleinen Dichtewerten vermeiden?
# Beruecksichtigen Sie das in Ihrer Implementierung.
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
bayes = GaussianClassifier()
bayes.estimate(train_data, train_labels)
estimated_labels = bayes.classify(test_data)
# Fuehren Sie eine Evaluierung der Ergebnisse wie in Aufgabe 1 durch.
evaluator = ClassificationEvaluator(estimated_labels, test_labels_gt)
print("Error rate {}".format(evaluator.error_rate()))
print("Category error rate {}".format(evaluator.category_error_rates()))
crossvali = CrossValidation(train_data, train_labels, 5)
over_all_result, class_result = crossvali.validate(GaussianClassifier())
print(over_all_result)
def aufg01():
# Zur Einfuehrung werden auf einem Beispieldatensatz Klassifikatoren
# implementiert. Der Datensatz data2d enthaelt zweidimensionalen
# Trainingsmerkmale fuer drei Musterklassen. Fuer diese Daten soll eine
# Klassifikation ueber Naechster-Nachbar realisiert werden.
# Achtung: Gestalten Sie Ihre Implementierung so, dass Sie die Klassifikatoren
# fuer zukuenftige Aufgaben wiederverwenden koennen.
# Im Folgenden wird der Beispieldatensatz ueber die Klasse DataProvided
# geladen und anschliessend visualisiert. Machen Sie sich mit sowohl dem
# Laden als auch der Visualisierung vertraut, da Sie in den kommenden
# Aufgaben diese Aspekte wiederverwenden werden.
# http://matplotlib.org/users/pyplot_tutorial.html
#
# Nuetzliche Funktionen: plt.scatter
# http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.scatter
#
# Tipp: zu einer besseren Visualisierung sollten alle scatter plots in Matplotlib
# immer mit dem Argument "edgecolor=(0, 0, 0)" aufgerufen werden.
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
fig = plt.figure()
ax = fig.add_subplot(111)
# fig, (ax, ax2) = plt.subplots(1, 2)
data = train_data_provider.get_class_arr(0)
ax.scatter(data[:, 0], data[:, 1], c='#FF0000', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(1)
ax.scatter(data[:, 0], data[:, 1], c='#00FF00', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(2)
ax.scatter(data[:, 0], data[:, 1], c='#0000FF', edgecolor=(0, 0, 0))
# plt.show()
#
# Implementieren Sie einen Naechster-Nachbar-Klassifikator.
# Vervollstaendigen Sie dazu die Klasse KNNClassifier im Modul common.classifiers.
# Testen Sie verschiedene Abstandsmasse. Welche halten Sie insbesondere fuer sinnvoll?
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
test_labels_gt = test_labels_gt.astype('float64')
train_labels = train_labels.astype('float64')
knn_classifier = KNNClassifier(
k_neighbors=70, metric='cityblock') # euclidean, cityblock, chebyshev
knn_classifier.estimate(train_data, train_labels)
estimated_labels = knn_classifier.classify(test_data)
# print(len(estimated_labels==0))
# print(test_labels_gt.shape, estimated_labels.shape)
# print(test_labels_gt.dtype, estimated_labels.dtype)
#
#data_x = test_data[mask, 0]
#data_y = test_data[mask, 1]
#ax2.scatter(data_x, data_y, c='#FF0000', edgecolor=(0, 0, 0))
#data = test_data[estimated_labels == 1]
#ax2.scatter(data[:, 0], data[:, 1], c='#00FF00', edgecolor=(0, 0, 0))
#data = test_data[estimated_labels == 2]
#ax2.scatter(data[:, 0], data[:, 1], c='#0000FF', edgecolor=(0, 0, 0))
#fig.tight_layout()
#plt.show()
#
# Nutzen Sie zur Evaluation der Ergebnisse die Klasse ClassificationEvaluator
# im Modul common.classifiers.
evals = ClassificationEvaluator(estimated_labels, test_labels_gt)
error_rate, n_wrong, n_samples = evals.error_rate()
print(error_rate, n_wrong, n_samples)
# raise NotImplementedError('Implement me')
# Ein NN-Klassifikator alleine ist meist nicht ausreichend. Erweitern Sie
# den Klassifikator zum k-NN Klassifikator.
# Fuer den Mehrheitsentscheid ist das defaultdict nuetzlich (siehe intro).
# https://docs.python.org/3/library/collections.html#collections.defaultdict
# Trainingsparameter sollten immer per Kreuzvalidierung auf den Trainingsdaten
# optimiert werden. Mit den besten Parametern wird dann ein Klassifikator
# erstellt und auf den Testdaten evaluiert.
# Nutzen Sie die Klasse CrossValidation im Modul classification um den
# Parameter k zu optimieren.
# In den folgenden Aufgaben ist es Ihnen freigestellt, ob Sie Kreuzvalidierung
# nutzen oder direkt auf den Testdaten optimieren.
cross = CrossValidation(train_data, train_labels, 5)
for i in range(65, 76):
knn = KNNClassifier(i, 'cityblock')
crossval_overall_result, crossval_class_results = cross.validate(knn)
print('Anzahl der Nachbarn = ', i, ' : ', crossval_overall_result)
''' Optimum bei k_neighbours = 70 '''
def aufg03():
#
# Implementieren Sie einen Vektorquantisierer nach Lloyd.
# Fuer Ihre Implementierung finden Sie einen Klassenrumpf in dem Modul
# common.vector_quantization
#
# Ein anderer Vektorquantisierer ist der k-means-Algorithmus (nach McQueen,
# siehe z.B. Skript Spracherkennung, S. 53 ff.).
# Diskutieren Sie die Unterschiede zwischen Lloyd und k-means.
# Achtung: In der Literatur ist mit k-means in der Regel der Lloyd-Algorithmus
# gemeint.
# ----------------------Disskussion-----------------------------------------
# Der k-means algorhytmus beschreibt das problem der suche von
# Clusterzentren zu einer gegebenen Anzahl von Clusterzentren. Beim
# Lyod-Algorithmus geht es um die iterative suche der Clusterzentren.
# Welche Codebuchgroesse ist fuer die gegebene Verteilung von Daten geeignet?
# ----------------------Codebuchgroesse-------------------------------------
# Eine Codebuchgroesse von 5 scheint passend, da sich die 3 Klassen auf 5
# Ballungszentren aufteilen.
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
train_data = train_data_provider.get_dataset_arr()
# Waehlen Sie eine geeignete Codebuchgroesse und speichern Sie sie in der
# lokalen Variablen codebook_size.
codebook_size = 5
# raise NotImplementedError('Implement me')
# Im Nachfolgenden werden die Daten unabhaengig von der Klassenzugehoerigkeit
# geclustert.
lloyd_quantizer = Lloyd()
codebook = lloyd_quantizer.cluster(train_data, codebook_size)
# Quantisieren Sie die Trainingsdaten mit dem berechneten Codebuch.
# Speichern Sie die Clusterindices der jeweiligen Samples in der lokalen
# Variablen labels.
# Nuetzliche Funktionen:
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmin.html
dist = cdist(train_data[0], codebook)
labels = np.argmin(dist, axis=1)
# raise NotImplementedError('Implement me')
# Berechnen Sie nun eine Normalverteilung je Cluster und visualisieren Sie diese.
# Ueberlegen Sie, wie Normalverteilungen definiert sind und wie Sie die noetigen
# Paramter auf Grundlage der Quantisierung bestimmen koennen.
# Im Nachfolgenden ist bereits die Farbcodierung der Cluster implementiert.
# Sie koennen die Variable c als Farbwerte in der visualization.plot_norm_dist_ellipse
# Funktion verwenden.
#
# Nuetzliche Funktionen: np.cov
# http://docs.scipy.org/doc/numpy/reference/generated/numpy.cov.html
# Zur Visualisierung: visualization.plot_norm_dist_ellipse
cmap = cm.get_cmap('hsv')
c = cmap(np.linspace(0, 1, codebook_size))
cov = []
for label in np.unique(labels):
cov.append(np.cov(train_data[label==labels], rowvar=0))
#raise NotImplementedError('Implement me')
# Visualisieren Sie die Zugehoerigkeit der einzelnen Samples zu den
# Clustern. Im Nachfolgenden ist bereits die Farbcodierung der Daten
# implementiert.
# Sie koennen die Variable c als Farbwerte in der ax.scatter
# Funktion verwenden.
labels_norm = labels / float(codebook_size )
cmap = cm.get_cmap('hsv')
c = cmap(labels_norm)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(train_data[:,0], train_data[:,1], c=c, edgecolor=(0,0,0))
visualization.plot_norm_dist_ellipse(ax, codebook, cov, c)
plt.show()
def aufg04():
#
# Nutzen Sie den in Aufgabe 3 Vektorquantisierer fuer die Schaetzung eines
# Gaussian Mixture Models.
#
# Implementieren Sie dazu die Klasse MDClassifierClassIndep im Modul common.classifiers.
#
# Welche zusaetzlichen Parameter werden neben den Mischverteilungsparametern
# noch fuer die Klassifizierung benoetigt?
#
# Werten Sie Ihre Implementierung mit dem unten stehenden Code aus.
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
quant = Lloyd()
classifier = MDClassifierClassIndep(quant, 10)
classifier.estimate(train_data, train_labels)
estimated_labels = classifier.classify(test_data)
evaluator = ClassificationEvaluator(estimated_labels, test_labels_gt)
print('Klassenunabhaengig:')
print(
'Fehlerrate: %.1f; Anzahl falsch-klassifizierte Muster: %d; Anzahl Muster: %d'
% evaluator.error_rate())
print('Klassenspezifische Fehlerraten')
for res in evaluator.category_error_rates():
print(
'Klasse %s:\tFehlerrate: %.1f;\tAnzahl falsch-klassifizierte Muster: %d;\tAnzahl Muster: %d'
% res)
cmap = cm.get_cmap('hsv')
fig = plt.figure()
ax = fig.add_subplot(111)
mean = classifier.mean
cov = classifier.cov
c = cmap(np.linspace(0, 1, len(cov)))
visualization.plot_norm_dist_ellipse(ax, mean, cov, c)
ax.scatter(train_data[:, 0],
train_data[:, 1],
c='#FFFFFF',
edgecolor=(0, 0, 0))
# Realisieren Sie den Mischverteilungsklassifikator mit klassenabhaengigen
# Komponentendichten. Implementieren Sie dazu die Klasse MDClassifierClassDep
# im Modul common.classifiers.
classifier = MDClassifierClassDep(quant, (1, 3, 1))
classifier.estimate(train_data, train_labels)
estimated_labels = classifier.classify(test_data)
evaluator = ClassificationEvaluator(estimated_labels, test_labels_gt)
print('\n##################################################\n')
print('Klassenabhaengig')
print(
'Fehlerrate: %.1f; Anzahl falsch-klassifizierte Muster: %d; Anzahl Muster: %d'
% evaluator.error_rate())
print('Klassenspezifische Fehlerraten')
for res in evaluator.category_error_rates():
print(
'Klasse %s:\tFehlerrate: %.1f;\tAnzahl falsch-klassifizierte Muster: %d;\tAnzahl Muster: %d'
% res)
classes = classifier.classifier
fig = plt.figure()
ax = fig.add_subplot(111)
for index, c in enumerate(classes):
cov = c.cov
col = [cmap(index / float(len(classes)))] * len(cov)
visualization.plot_norm_dist_ellipse(ax, c.mean, cov, col)
data = train_data_provider.get_class_arr(index)
ax.scatter(data[:, 0], data[:, 1], c=col, edgecolor=(0, 0, 0))
plt.show()
def _init(self): self.provider = DataProvider() self.provider.do()
class TestFunctions(unittest.TestCase):
def setUp(self):
if IGNORE_TEST:
return
self._init()
def _init(self):
self.provider = DataProvider()
self.provider.do()
def testMakeTrinaryData(self):
if IGNORE_TEST:
return
df = transform_data.makeTrinaryData(
df=self.provider.df_normalized)
columns = self.provider.df_normalized.columns
self.assertTrue(helpers.isValidDataFrame(df, columns))
def testAggregateGenes(self):
if IGNORE_TEST:
return
provider = DataProvider()
provider.do()
df = transform_data.aggregateGenes(provider=provider)
self.assertTrue(helpers.isValidDataFrame(df,
provider.df_normalized.columns))
def testTrinaryReadsDF1(self):
if IGNORE_TEST:
return
provider = DataProvider()
provider.do()
df = provider.dfs_read_count[0]
df_result = transform_data.trinaryReadsDF(
df_sample=df)
# See if number of "-1" is excessive
dff = df_result + df_result.applymap(lambda v: -np.abs(v))
frac_minus1 = -dff.sum().sum() \
/(2*len(df_result)*len(df_result.columns))
self.assertLess(frac_minus1, 0.25)
# Smoke tests for csv
df_result = transform_data.trinaryReadsDF(
csv_file="AM_MDM_Mtb_transcripts_DEseq.csv",
is_time_columns=False)
# TODO: Fix so working with the same transformation of features,
# either all genes features or all gene-groups.
def testTrinaryReadsDF2(self):
return
# Checks that trinary values computed directly from reads
# are the same as those of normalized samples.
# Get raw value of read counts
provider = DataProvider()
provider.do()
#
def calcTrinaryTimeSample(time_index):
"""
Calculates the trinary value of a time sample
:param str time_index: name of time value
"""
int_index = int(time_index[1:])
df0 = provider.dfs_read_count[0]
num = len(provider.dfs_read_count)
ser = pd.Series(np.repeat(0, len(df0.index)), index=df0.index)
for idx in range(num):
ser += provider.dfs_read_count[idx][int_index]
df = pd.DataFrame(ser/num)
df_result = transform_data.trinaryReadsDF(df_sample=df)
return df_result.T
#
data = TrinaryData()
data.df_X.columns = data.features
for time_index in data.df_X.index:
df_result = calcTrinaryTimeSample(time_index)
import pdb; pdb.set_trace()
def testCalcTrinaryComparison(self):
if IGNORE_TEST:
return
df_in = pd.DataFrame({'a': [4, 0.20, 1]})
df_expected = pd.DataFrame({'a': [1, -1, 0]})
ser_ref = pd.Series(np.repeat(1, len(df_in)))
df_out = transform_data.calcTrinaryComparison(df_in, ser_ref,
is_convert_log2=True)
self.assertTrue(df_out.equals(df_expected))
def testStripReplicaString(self):
if IGNORE_TEST:
return
TIME = "TO"
SIZE = 3
names = ["%s.%d" % (TIME, n) for n in range(SIZE)]
result = transform_data.stripReplicaString(names)
self.assertEqual(result[0], TIME)
self.assertEqual(len(result), SIZE)
def testRemoveGenesWithExcessiveReplicationVariance(self):
if IGNORE_TEST:
return
trinary = TrinaryData(is_averaged=False, is_dropT1=False,
is_regulator=False)
df_base = transform_data.removeGenesWithExcessiveReplicationVariance(
trinary.df_X)
for max_var in [1, 2, 3]:
df = transform_data.removeGenesWithExcessiveReplicationVariance(
trinary.df_X, max_var=max_var)
self.assertGreaterEqual(len(df_base.columns), len(df.columns))
ser = util.convertToLog2(SER)
ser1 = util.unconvertFromLog2(ser)
ser1.loc[0] = 0
trues = [np.isclose(v1, v2) for v1, v2 in zip(ser1, SER)]
self.assertTrue(all(trues))
def testMakeBioreactorT0ReferenceData(self):
if IGNORE_TEST:
return
ser = transform_data.makeBioreactorT0ReferenceData()
self.assertTrue(isinstance(ser, pd.Series))
self.assertGreater(ser.min(), 0)
self.assertGreater(len(ser), 10)
def aufg02():
# In dieser Aufgabe soll ein Bayes'scher Normalverteilungs-Klassifikator
# mit drei Dichten realisiert werden.
#
# Zunaechst sollen Mittelwert und Kovarianzmatrix der drei Klassen geschaetzt
# und visualisiert werden:
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
train_labels = train_labels.astype('float64')
labels = np.unique(train_labels)
#
# Extrahieren Sie die Klassen-Labels aus dem Trainingsdatensatz und speichern
# Sie sie in der lokalen Variablen labels
#
# Nuetzliche Funktionen:
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
# raise NotImplementedError('Implement me')
mean_list = []
cov_list = []
for label in labels:
#
# Berechnen Sie Mittelwert und Kovarianz der drei Klassen durch
# Matrixoperationen in NumPy.
# Speichern Sie fuer jeden Schleifendurchlauf den Mittelwert in der
# lokalen Variablen mean und die Kovarianzmatrix in der lokalen Variablen
# cov. Benutzen Sie zur Schaetzung die korrigierte Kovarianzmatrix:
# https://de.wikipedia.org/wiki/Stichprobenkovarianz#Korrigierte_Stichprobenkovarianz
class_data = train_data[train_labels==label]
mean = sum(class_data)/len(class_data)
meanx = sum(class_data[:, 0])/len(class_data[:, 0])
meany = sum(class_data[:, 1])/len(class_data[:, 1])
sx = 1/(len(class_data[:, 0]) - 1) * sum((class_data[:, 0] - meanx)**2)
sy = 1/(len(class_data[:, 1]) - 1) * sum((class_data[:, 1] - meany)**2)
sxy = 1/(len(class_data[:,0]) - 1) * sum((class_data[:, 0] - meanx) * (class_data[:, 1] - meany))
cov = np.matrix([[sx, sxy], [sxy, sy]])
#raise NotImplementedError('Implement me')
np.testing.assert_almost_equal(actual=mean,
desired=np.mean(class_data, axis=0),
err_msg='Der Mittelwert ist falsch')
np.testing.assert_almost_equal(actual=cov,
desired=np.cov(class_data, rowvar=0),
err_msg='Die Kovarianzmatrix ist falsch')
mean_list.append(mean)
cov_list.append(cov)
#
# Visualisieren Sie die Datenpunkte der drei Klassen, sowie die geschaetzen
# Mittelwerte und Kovarianzmatrizen durch eine Normalverteilung.
# Zur Visualisierung der Normalverteilungen: visualization.plot_norm_dist_ellipse
fig = plt.figure()
ax = fig.add_subplot(111)
data = train_data_provider.get_class_arr(0)
ax.scatter(data[:, 0], data[:, 1], c='#FF0000', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(1)
ax.scatter(data[:, 0], data[:, 1], c='#00FF00', edgecolor=(0, 0, 0))
data = train_data_provider.get_class_arr(2)
ax.scatter(data[:, 0], data[:, 1], c='#0000FF', edgecolor=(0, 0, 0))
visualization.plot_norm_dist_ellipse(ax, mean_list, cov_list, color=['orange', 'darkgreen', 'cyan'])
plt.show()
# raise NotImplementedError('Implement me')
#
# Implementieren sie einen Bayes'schen Normalverteilungs-Klassifikator (ohne
# Rueckweisung), der die soeben berechneten Verteilungen als Modell
# verwendet. Vervollstaendigen Sie dazu die Klasse GaussianClassifier im Modul
# classification.
#
# Hinweise:
#
# Achten Sie darauf, dass Ihre Implementierung unabhaengig von den
# verwendeten Klassenlabels ist. Aus den Trainingsdaten lassen sich diese mit
# np.unique bestimmen.
# http://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
#
# Durch welche geeignete monotone Transformation lassen sich numerische
# Probleme bei der Auswertung von extrem kleinen Dichtewerten vermeiden?
# Beruecksichtigen Sie das in Ihrer Implementierung.
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
test_labels_gt = test_labels_gt.astype('float64')
bayes = GaussianClassifier()
bayes.estimate(train_data, train_labels)
estimated_labels = bayes.classify(test_data)
#
# Fuehren Sie eine Evaluierung der Ergebnisse wie in Aufgabe 1 durch.
evals = ClassificationEvaluator(estimated_labels, test_labels_gt)
error_rate, n_wrong, n_samples = evals.error_rate()
print('Bayes:', error_rate, n_wrong, n_samples)
def aufg07():
#
# Im Gegensatz zu den bisher verwendeten Klassifikatoren, die Klassengebiete
# explizit ueber (Mischungen von) Gaussverteilungen modellieren, sollen nun
# diskriminative Klassifikatoren untersucht werden. Als besonders leistungs-
# faehig haben sich die in der Vorlesung behandelten Support Vector Maschinen
# erwiesen.
# Anhand der beiden bisher benutzten aber auch unter Verwendung eigener
# Datensaetze soll nun die Mustererkennung mittels Support Vector Machines
# untersucht werden.
# Fuer Python stellt die Bibliothek 'sklearn' die Implementierung einer SVM
# bereit.
# http://scikit-learn.org/stable/modules/svm.html#svm
# Zur Visualisierung der SVM kann die Funktion visualization.plot_svm
# genutzt werden.
# Der zweidimensionale Datensatz data2d enthaelt 3 Klassen.
# Trainieren Sie zunaechst eine lineare Support Vector Maschine, die zur
# Trennung von Klasse 0 und 2 verwendet werden soll. Klasse 1 wird hier
# nicht betrachtet, da sie sich nicht linear von den Klassen 0 und 2 trennen
# laesst (Siehe unten).
# Wie hoch ist der Klassifikationsfehler im Vergleich zum Normalverteilungs-
# klassifikator? Visualisieren Sie die resultierende Trennfunktion. Im Modul
# visualization steht dafuer die Methode plot_svm bereit.
# Diskutieren Sie den Einfluss der Slack-Variablen (in Form des C-Parameters)
# auf die Trennfunktion und damit den entstehenden Klassifikationsfehler.
#
# Fuer die Evaluierung koennen Sie im Folgenden wieder den ClassificationEvaluator
# aus dem Modul common.classifiers verwenden.
train_data_provider = DataProvider(DataProvider.DATA2DROOT_TRAIN)
test_data_provider = DataProvider(DataProvider.DATA2DROOT_TEST)
train_data, train_labels = train_data_provider.get_dataset_and_labels()
test_data, test_labels_gt = test_data_provider.get_dataset_and_labels()
train_labels = train_labels.astype(dtype='float64')
test_labels_gt = test_labels_gt.astype(dtype='float64')
train_data_02 = np.concatenate((train_data_provider.get_class_arr(0),
train_data_provider.get_class_arr(2)))
train_labels_02 = np.concatenate(
(train_labels[train_labels == 0], train_labels[train_labels == 2]))
test_data_02 = np.concatenate((test_data_provider.get_class_arr(0),
test_data_provider.get_class_arr(2)))
test_labels_02 = np.concatenate((test_labels_gt[test_labels_gt == 0],
test_labels_gt[test_labels_gt == 2]))
clf = svm.LinearSVC()
clf.fit(train_data_02, train_labels_02)
estimated_labels = clf.predict(test_data_02)
evals = ClassificationEvaluator(estimated_labels, test_labels_02)
error_rate, n_wrong, n_samples = evals.error_rate()
print(error_rate, n_wrong, n_samples)
fig = plt.figure()
ax = fig.add_subplot(111)
visualization.plot_svm(ax,
test_data_02,
test_labels_02,
clf,
step_size=0.1)
#plt.show()
# raise NotImplementedError('Implement me')
# Trainieren Sie nun eine SVM fuer die Klassen 1 und 2.
# Evaluieren Sie, welcher Kernel geeignet ist, um das Problem zu loesen.
train_data_12 = np.concatenate((train_data_provider.get_class_arr(1),
train_data_provider.get_class_arr(2)))
train_labels_12 = np.concatenate(
(train_labels[train_labels == 1], train_labels[train_labels == 2]))
test_data_12 = np.concatenate((test_data_provider.get_class_arr(1),
test_data_provider.get_class_arr(2)))
test_labels_12 = np.concatenate((test_labels_gt[test_labels_gt == 1],
test_labels_gt[test_labels_gt == 2]))
kernels = ['linear', 'poly', 'rbf', 'sigmoid']
for kernel in kernels:
clf = svm.SVC(kernel=kernel)
clf.fit(train_data_12, train_labels_12)
estimated_labels = clf.predict(test_data_12)
evals = ClassificationEvaluator(estimated_labels, test_labels_12)
error_rate, n_wrong, n_samples = evals.error_rate()
print(kernel, error_rate, n_wrong, n_samples)
fig = plt.figure()
ax = fig.add_subplot(111)
visualization.plot_svm(ax,
test_data_12,
test_labels_12,
clf,
step_size=0.1)
#plt.show()
# raise NotImplementedError('Implement me')
# Trainieren Sie nun eine Multi-Class SVM zur Loesung des 3-Klassenproblems
# unter Verwendung eines geeigneten Kernels.
# Wie koennen die optimalen kernelspezifischen Parameter sinnvoll ermittelt
# werden?
# Hinweis: Starten Sie zunaechst mit den Grundeinstellungen der Bibliothek.
clf = svm.SVC()
clf.fit(train_data, train_labels)
estimated_labels = clf.predict(test_data)
evals = ClassificationEvaluator(estimated_labels, test_labels_gt)
error_rate, n_wrong, n_samples = evals.error_rate()
print('3 Klassen: bcf', error_rate, n_wrong, n_samples)
fig = plt.figure()
ax = fig.add_subplot(111)
visualization.plot_svm(ax, test_data, test_labels_gt, clf, step_size=0.1)
def aufg05():
#
# Realisieren Sie eine Hauptachsen-Transformation (PCA) in der Klasse PCA.
# Zunaechst schauen wir uns das Prinzip an einem Spielbeispiel an.
#
# Mit der Methode pca_example wird die PCA anhand eines
# 3D-Beispieldatensatzes visualisiert.
# Nuetzliche Funktionen: np.linalg.eig
# http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.eig.html
# Achten Sie darauf, dass die NumPy Methode np.linalg.eig komplexwertige Ergebnisse
# liefern kann. Dies kann an numerischen Ungenauigkeiten liegen. Verwenden Sie in
# diesem Fall nur den Realteil.
pca_example()
#
# Nachdem bisher mit artifiziellen Datensaetzen gearbeitet wurde, wenden wir
# uns jetzt realen Daten zu. Dazu verwenden wir den MNIST-Datensatz der
# Grauwert-Bilder handgeschriebener Ziffern enthaelt. Der MNIST-Datensatz
# besteht im Original aus 60000 Trainingsbildern und 10000 Testbildern. Um
# den Aufwand geringer zu halten, werden im Rahmen dieser Uebung
# lediglich 1000 zufaellig ausgewaehlte Trainingsbilder pro Klasse verwendet.
#
# Somit ergibt sich ein Trainingsdatensatz von 10000 sowie ein
# Testdatensatz von 10000 Bildern.
#
# Die 28 x 28 Pixel grossen Bilder koennen als 784-dimensionale Merkmalsvektoren
# aufgefasst werden.
#
# Laden Sie die Trainingsdaten des MNIST-Datensatz.
# Das Laden des Datensatzes kann einige Sekunden in Anspruch nehmen.
# Mit show_data(data, width) koennen Sie Bilder anzeigen lassen. Die Anzahl der
# Bilder muss ein Vielfaches des Parameters width sein.
train_data_provider = DataProvider(DataProvider.MNIST_TRAIN)
train_data = train_data_provider.get_dataset_arr()
show_data(train_data[2000:2100, :], width=10)
plt.show()
# raise NotImplementedError('Implement me')
# Transformieren Sie die 784-dimensionalen Daten des MNIST-Datensatzes in
# einen geeignet gewaehlten niedriger-dimensionalen Merkmalsraum. Begruenden
# Sie die gewaehlte Groesse.
# Hinweis: Die Unterraumdimension laesst sich mit der moeglichen
# Rekonstruktionsqualitaet verknuepfen.
# Es ist empfehlenswert, die dimensionsreduzierten Daten fuer die spaetere
# Nutzung zu speichern.
# Nuetzliche Funktion: DataProvider.write_data oder pickle
# Achten Sie darauf, dass DataProvider.write_data ein dictionary als
# Eingabe erwartet.
# Zu pickle finden Sie weitere Informationen hier:
# https://docs.python.org/3/library/pickle.html
# https://wiki.python.org/moin/UsingPickle
# Optional: Visualisieren Sie die MNIST-Daten in einem 2D Unterraum. Faerben Sie
# die Datenpunkte nach Klassenzugehoerigkeit.
target_dim = 70
pca = PCA(train_data)
transformed = pca.transform_samples(train_data, target_dim)