1import os.path
2import itertools
3import Tools
4import random
5import numpy as np
6from sklearn.naive_bayes import GaussianNB
7
8def printS(a):
9    print("Interpreter[\"Number\"][\"%.9g\"]" % a,end="")
10
11def printV(v):
12    start = False
13    print("{",end="")
14    for r in v:
15        if start:
16            print(",",end="")
17        start = True
18        printS(r)
19    print("}",end="")
20
21def printM(v):
22    start = False
23    print("{",end="")
24    for r in v:
25        if start:
26            print(",",end="")
27        start = True
28        printV(r)
29    print("}",end="")
30
31NBTESTSAMPLES = 10
32
33VECDIM = [12,14,20]
34BAYESCLASSES= [3,5,4]
35
36NBTRAININGSAMPLES = 30
37
38# Distance between the two centers (training vectors are gaussianly
39# distributed around the centers)
40CENTER_DISTANCE = 1
41
42TRAININGRATIO = 6.0
43PREDICTRATIO = 12.0
44
45# Generate random points distributed around one cluster.
46# Cluster are on each axis like (1,0,0,0), (0,1,0,0), (0,0,1,0) etc ...
47def newRandomVector(nbClasses,vecDim,ratio):
48        v = np.random.randn(vecDim)
49        v = v * CENTER_DISTANCE/2.0/ratio
50        c = np.random.choice(range(0,nbClasses))
51        c0 = np.zeros(vecDim)
52        c1 = np.copy(c0)
53        c1[c] = c0[0] + CENTER_DISTANCE
54        return((v + c1).tolist(),c)
55
56def trainGaussian(nbClasses,vecDim):
57        inputs=[]
58        outputs=[]
59
60        # Generate test patterns for this classifier
61        for i in range(0,NBTRAININGSAMPLES):
62            v,c=newRandomVector(nbClasses,vecDim,TRAININGRATIO)
63
64            inputs.append(v)
65            outputs.append(c)
66
67        gnb = GaussianNB()
68        gnb.fit(inputs, outputs)
69        return(gnb)
70
71def generateNewTest(config,nb):
72    dims=[]
73    inputs=[]
74    referenceproba=[]
75    referencepredict=[]
76    params=[]
77    dims.append(NBTESTSAMPLES)
78    classNb = BAYESCLASSES[nb % len(BAYESCLASSES)]
79    vecDim = VECDIM[nb % len(VECDIM)]
80    dims.append(classNb)
81    dims.append(vecDim)
82    # Train a classifier for a given vector dimension and
83    # given number of classes
84    gb = trainGaussian(classNb,vecDim)
85    params += list(np.reshape(gb.theta_,np.size(gb.theta_)))
86    params += list(np.reshape(gb.sigma_,np.size(gb.sigma_)))
87    params += list(np.reshape(gb.class_prior_,np.size(gb.class_prior_)))
88    params.append(gb.epsilon_)
89
90    #print("theta=",end="")
91    #printM(gb.theta_)
92    #print(";",end="")
93    #
94    #print("sigma=",end="")
95    #printM(gb.sigma_)
96    #print(";",end="")
97    #
98    #print("prior=",end="")
99    #printV(gb.class_prior_)
100    #print(";",end="")
101    #
102    #print("epsilon=",end="")
103    #printS(gb.epsilon_)
104    #print(";",end="")
105
106    #print(classNb,vecDim)
107    for _ in range(0,NBTESTSAMPLES):
108        # Generate a test pattern for this classifier
109        v,c=newRandomVector(classNb,vecDim,PREDICTRATIO)
110        inputs += v
111        #print("inputs=",end="")
112        #printV(v)
113        #print(";",end="")
114
115        y_pred = gb.predict([v])
116        referencepredict.append(y_pred[0])
117
118        probas = gb._joint_log_likelihood([v])
119        probas = probas[0]
120        referenceproba += list(probas)
121
122
123    inputs = np.array(inputs)
124    params = np.array(params)
125    referenceproba = np.array(referenceproba)
126    referencepredict = np.array(referencepredict)
127    dims = np.array(dims)
128
129    config.writeInput(nb, inputs,"Inputs")
130    config.writeInputS16(nb, dims,"Dims")
131    config.writeReference(nb, referenceproba,"Probas")
132    config.writeReferenceS16(nb, referencepredict,"Predicts")
133    config.writeReference(nb, params,"Params")
134
135    #print(inputs)
136    #print(dims)
137    #print(referencepredict)
138    #print(referenceproba)
139    #print(params)
140
141
142def writeTests(config):
143    generateNewTest(config,1)
144
145def writeBenchmark(config):
146    someLists=[VECDIM,BAYESCLASSES]
147
148    r=np.array([element for element in itertools.product(*someLists)])
149    nbtests=len(VECDIM)*len(BAYESCLASSES)*2
150    config.writeParam(2, r.reshape(nbtests))
151
152    params=[]
153    inputs=[]
154    referencepredict=[]
155    dims=[]
156    nbin=0
157    nbparam=0;
158
159    for vecDim, classNb in r:
160        gb = trainGaussian(classNb,vecDim)
161        p = []
162        p += list(np.reshape(gb.theta_,np.size(gb.theta_)))
163        p += list(np.reshape(gb.sigma_,np.size(gb.sigma_)))
164        p += list(np.reshape(gb.class_prior_,np.size(gb.class_prior_)))
165        p.append(gb.epsilon_)
166
167        params += p
168        dims += [nbin,nbparam]
169        nbparam = nbparam + len(p)
170
171        v,c=newRandomVector(classNb,vecDim,PREDICTRATIO)
172        inputs += v
173
174        nbin = nbin + len(v)
175
176        y_pred = gb.predict([v])
177        referencepredict.append(y_pred[0])
178
179
180    inputs = np.array(inputs)
181    params = np.array(params)
182    referencepredict = np.array(referencepredict)
183    dims = np.array(dims)
184
185    config.writeInput(2, inputs,"Inputs")
186    config.writeReferenceS16(2, referencepredict,"Predicts")
187    config.writeReference(2, params,"Params")
188    config.writeInputS16(2, dims,"DimsBench")
189
190
191def generatePatterns():
192    PATTERNDIR = os.path.join("Patterns","DSP","Bayes","Bayes")
193    PARAMDIR = os.path.join("Parameters","DSP","Bayes","Bayes")
194
195    configf32=Tools.Config(PATTERNDIR,PARAMDIR,"f32")
196    configf16=Tools.Config(PATTERNDIR,PARAMDIR,"f16")
197
198    writeTests(configf32)
199    writeTests(configf16)
200
201    writeBenchmark(configf32)
202    writeBenchmark(configf16)
203
204if __name__ == '__main__':
205  generatePatterns()