├── assets
    ├── model.gif
    ├── result_0.png
    ├── result_1.png
    ├── weights.png
    ├── result_0_custom.png
    └── energy.svg
├── LICENSE
├── network.py
├── train.py
├── train_custom.py
└── README.md


/assets/model.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crypto-code/Hopfield-Network/HEAD/assets/model.gif


--------------------------------------------------------------------------------
/assets/result_0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crypto-code/Hopfield-Network/HEAD/assets/result_0.png


--------------------------------------------------------------------------------
/assets/result_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crypto-code/Hopfield-Network/HEAD/assets/result_1.png


--------------------------------------------------------------------------------
/assets/weights.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crypto-code/Hopfield-Network/HEAD/assets/weights.png


--------------------------------------------------------------------------------
/assets/result_0_custom.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crypto-code/Hopfield-Network/HEAD/assets/result_0_custom.png


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Atin Sakkeer Hussain
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/network.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | from matplotlib import pyplot as plt
  3 | import matplotlib.cm as cm
  4 | from tqdm import tqdm
  5 | 
  6 | class HopfieldNetwork(object):      
  7 |     def train_weights(self, train_data):
  8 |         print("Start to train weights...")
  9 |         num_data =  len(train_data)
 10 |         self.num_neuron = train_data[0].shape[0]
 11 |         
 12 |         # initialize weights
 13 |         W = np.zeros((self.num_neuron, self.num_neuron))
 14 |         rho = np.sum([np.sum(t) for t in train_data]) / (num_data*self.num_neuron)
 15 |         
 16 |         # Hebb rule
 17 |         for i in tqdm(range(num_data)):
 18 |             t = train_data[i] - rho
 19 |             W += np.outer(t, t)
 20 |         
 21 |         # Make diagonal element of W into 0
 22 |         diagW = np.diag(np.diag(W))
 23 |         W = W - diagW
 24 |         W /= num_data
 25 |         
 26 |         self.W = W 
 27 |     
 28 |     def predict(self, data, num_iter=20, threshold=0, asyn=False):
 29 |         print("Start to predict...")
 30 |         self.num_iter = num_iter
 31 |         self.threshold = threshold
 32 |         self.asyn = asyn
 33 |         
 34 |         # Copy to avoid call by reference 
 35 |         copied_data = np.copy(data)
 36 |         
 37 |         # Define predict list
 38 |         predicted = []
 39 |         for i in tqdm(range(len(data))):
 40 |             predicted.append(self._run(copied_data[i]))
 41 |         return predicted
 42 |     
 43 |     def _run(self, init_s):
 44 |         if self.asyn==False:
 45 |             """
 46 |             Synchronous update
 47 |             """
 48 |             # Compute initial state energy
 49 |             s = init_s
 50 | 
 51 |             e = self.energy(s)
 52 |             
 53 |             # Iteration
 54 |             for i in range(self.num_iter):
 55 |                 # Update s
 56 |                 s = np.sign(self.W @ s - self.threshold)
 57 |                 # Compute new state energy
 58 |                 e_new = self.energy(s)
 59 |                 
 60 |                 # s is converged
 61 |                 if e == e_new:
 62 |                     return s
 63 |                 # Update energy
 64 |                 e = e_new
 65 |             return s
 66 |         else:
 67 |             """
 68 |             Asynchronous update
 69 |             """
 70 |             # Compute initial state energy
 71 |             s = init_s
 72 |             e = self.energy(s)
 73 |             
 74 |             # Iteration
 75 |             for i in range(self.num_iter):
 76 |                 for j in range(100):
 77 |                     # Select random neuron
 78 |                     idx = np.random.randint(0, self.num_neuron) 
 79 |                     # Update s
 80 |                     s[idx] = np.sign(self.W[idx].T @ s - self.threshold)
 81 |                 
 82 |                 # Compute new state energy
 83 |                 e_new = self.energy(s)
 84 |                 
 85 |                 # s is converged
 86 |                 if e == e_new:
 87 |                     return s
 88 |                 # Update energy
 89 |                 e = e_new
 90 |             return s
 91 |     
 92 |     
 93 |     def energy(self, s):
 94 |         return -0.5 * s @ self.W @ s + np.sum(s * self.threshold)
 95 | 
 96 |     def plot_weights(self, path):
 97 |         plt.figure(figsize=(6, 5))
 98 |         w_mat = plt.imshow(self.W, cmap=cm.coolwarm)
 99 |         plt.colorbar(w_mat)
100 |         plt.title("Network Weights")
101 |         plt.tight_layout()
102 |         plt.savefig(path+"/weights.png")
103 |         plt.show()  
104 | 


--------------------------------------------------------------------------------
/train.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | np.random.seed(1)
  3 | from matplotlib import pyplot as plt
  4 | import skimage.data
  5 | from skimage.color import rgb2gray
  6 | from skimage.filters import threshold_mean
  7 | from skimage.transform import resize
  8 | import network
  9 | import os
 10 | 
 11 | # Helper Functions
 12 | def get_corrupted_input(input, corruption_level):
 13 |     corrupted = np.copy(input)
 14 |     inv = np.random.binomial(n=1, p=corruption_level, size=len(input))
 15 |     for i, v in enumerate(input):
 16 |         if inv[i]:
 17 |             corrupted[i] = -1 * v
 18 |     return corrupted
 19 | 
 20 | def reshape(data):
 21 |     dim = int(np.sqrt(len(data)))
 22 |     data = np.reshape(data, (dim, dim))
 23 |     return data
 24 | def split(l, n):
 25 |     for i in range(0,len(l), n):
 26 |         yield l[i:i+n]
 27 |     
 28 | def plot(data, test, predicted, figsize=(5, 6)):
 29 |     data = [reshape(d) for d in data]
 30 |     test = [reshape(d) for d in test]
 31 |     predicted = [reshape(d) for d in predicted]
 32 |     if not os.path.exists('results'):
 33 |         os.mkdir('results')
 34 |     count=0
 35 |     file_count=0
 36 |     for d in split(data, 4):
 37 |         if not len(d)is 1: 
 38 |             fig, axarr = plt.subplots(len(d), 3)
 39 |             for i in range(len(d)):
 40 |                 if i==0:
 41 |                     axarr[i, 0].set_title('Train data')
 42 |                     axarr[i, 1].set_title("Input data")
 43 |                     axarr[i, 2].set_title('Output data')
 44 | 
 45 |                 axarr[i, 0].imshow(data[count])
 46 |                 axarr[i, 0].axis('off')
 47 |                 axarr[i, 1].imshow(test[count])
 48 |                 axarr[i, 1].axis('off')
 49 |                 axarr[i, 2].imshow(predicted[count])
 50 |                 axarr[i, 2].axis('off')
 51 |                 count = count+1
 52 | 
 53 |             plt.tight_layout()
 54 |             plt.savefig("results/result_"+str(file_count)+".png")
 55 |             file_count=file_count+1
 56 |             plt.show()
 57 |         else:
 58 |             fig, axarr = plt.subplots(1, 3)
 59 |             axarr[0].set_title('Train data')
 60 |             axarr[1].set_title("Input data")
 61 |             axarr[2].set_title('Output data')
 62 | 
 63 |             axarr[0].imshow(data[count])
 64 |             axarr[0].axis('off')
 65 |             axarr[1].imshow(test[count])
 66 |             axarr[1].axis('off')
 67 |             axarr[2].imshow(predicted[count])
 68 |             axarr[2].axis('off')
 69 |             count = count+1
 70 |             plt.tight_layout()
 71 |             plt.savefig("results/result_"+str(file_count)+".png")
 72 |             file_count=file_count+1
 73 |             plt.show()
 74 | 
 75 | def preprocessing(img, w=128, h=128):
 76 |     # Resize image
 77 |     img = resize(img, (w,h), mode='reflect')
 78 | 
 79 |     # Thresholding
 80 |     thresh = threshold_mean(img)
 81 |     binary = img > thresh
 82 |     shift = 2*(binary*1)-1 # Boolian to int
 83 | 
 84 |     # Reshape
 85 |     flatten = np.reshape(shift, (w*h))
 86 |     return flatten
 87 | 
 88 | def main():
 89 |     # Load data
 90 | 
 91 |     import cv2
 92 |     import glob
 93 |     img_dir = "train/" # Enter Directory of all images 
 94 |     data_path = os.path.join(img_dir,'*g')
 95 |     files = glob.glob(data_path)
 96 |     data = []
 97 |     for f1 in files:
 98 |         img = rgb2gray(cv2.imread(f1))
 99 |         data.append(img)
100 |         
101 |     # Preprocessing
102 |     print("Start to data preprocessing...")
103 |     data = [preprocessing(d) for d in data]
104 | 
105 |     # Create Hopfield Network Model
106 |     model = network.HopfieldNetwork()
107 |     model.train_weights(data)
108 | 
109 |     # Generate testset
110 |     test = [get_corrupted_input(d, 0.3) for d in data]
111 | 
112 |     predicted = model.predict(test, threshold=0, asyn=False)
113 |     print("Show prediction results...")
114 |     plot(data, test, predicted)
115 |     #print("Show network weights matrix...")
116 |     #model.plot_weights("results/")
117 | 
118 | if __name__ == '__main__':
119 |     main()
120 | 


--------------------------------------------------------------------------------
/train_custom.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | np.random.seed(1)
  3 | from matplotlib import pyplot as plt
  4 | import skimage.data
  5 | from skimage.color import rgb2gray
  6 | from skimage.filters import threshold_mean
  7 | from skimage.transform import resize
  8 | import network
  9 | import os
 10 | 
 11 | # Helper Functions
 12 | def get_corrupted_input(input, corruption_level):
 13 |     corrupted = np.copy(input)
 14 |     inv = np.random.binomial(n=1, p=corruption_level, size=len(input))
 15 |     for i, v in enumerate(input):
 16 |         if inv[i]:
 17 |             corrupted[i] = -1 * v
 18 |     return corrupted
 19 | 
 20 | def reshape(data):
 21 |     dim = int(np.sqrt(len(data)))
 22 |     data = np.reshape(data, (dim, dim))
 23 |     return data
 24 | def split(l, n):
 25 |     for i in range(0,len(l), n):
 26 |         yield l[i:i+n]
 27 |     
 28 | def plot(data, test, predicted):
 29 |     data = [reshape(d) for d in data]
 30 |     test = [reshape(d) for d in test]
 31 |     predicted = [reshape(d) for d in predicted]
 32 |     if not os.path.exists('results_custom'):
 33 |         os.mkdir('results_custom')
 34 |     count=0
 35 |     file_count=0
 36 |     for d in split(data, 4):
 37 |         if not len(d)is 1: 
 38 |             fig, axarr = plt.subplots(len(d), 3)
 39 |             for i in range(len(d)):
 40 |                 if i==0:
 41 |                     axarr[i, 0].set_title('Train data')
 42 |                     axarr[i, 1].set_title("Input data")
 43 |                     axarr[i, 2].set_title('Output data')
 44 | 
 45 |                 axarr[i, 0].imshow(data[count])
 46 |                 axarr[i, 0].axis('off')
 47 |                 axarr[i, 1].imshow(test[count])
 48 |                 axarr[i, 1].axis('off')
 49 |                 axarr[i, 2].imshow(predicted[count])
 50 |                 axarr[i, 2].axis('off')
 51 |                 count = count+1
 52 | 
 53 |             plt.tight_layout()
 54 |             plt.savefig("results_custom/result_"+str(file_count)+".png")
 55 |             file_count=file_count+1
 56 |             plt.show()
 57 |         else:
 58 |             fig, axarr = plt.subplots(1, 3)
 59 |             axarr[0].set_title('Train data')
 60 |             axarr[1].set_title("Input data")
 61 |             axarr[2].set_title('Output data')
 62 | 
 63 |             axarr[0].imshow(data[count])
 64 |             axarr[0].axis('off')
 65 |             axarr[1].imshow(test[count])
 66 |             axarr[1].axis('off')
 67 |             axarr[2].imshow(predicted[count])
 68 |             axarr[2].axis('off')
 69 |             count = count+1
 70 |             plt.tight_layout()
 71 |             plt.savefig("results_custom/result_"+str(file_count)+".png")
 72 |             file_count=file_count+1
 73 |             plt.show()
 74 | 
 75 | def preprocessing(img, w=128, h=128):
 76 |     # Resize image
 77 |     img = resize(img, (w,h), mode='reflect')
 78 | 
 79 |     # Thresholding
 80 |     thresh = threshold_mean(img)
 81 |     binary = img > thresh
 82 |     shift = 2*(binary*1)-1 # Boolian to int
 83 | 
 84 |     # Reshape
 85 |     flatten = np.reshape(shift, (w*h))
 86 |     return flatten
 87 | 
 88 | def main():
 89 |     # Load data
 90 | 
 91 |     import cv2
 92 |     import glob
 93 |     img_dir = "train_custom/" # Enter Directory of all images 
 94 |     data_path = os.path.join(img_dir,'*g')
 95 |     files = glob.glob(data_path)
 96 |     data = []
 97 |     for f1 in files:
 98 |         img = rgb2gray(cv2.imread(f1))
 99 |         data.append(img)
100 |         
101 |     # Preprocessing
102 |     print("Start to data preprocessing...")
103 |     data = [preprocessing(d) for d in data]
104 | 
105 |     # Create Hopfield Network Model
106 |     model = network.HopfieldNetwork()
107 |     model.train_weights(data)
108 | 
109 |     # Generate testset
110 |     img_dir = "test_custom/" # Enter Directory of all images 
111 |     data_path = os.path.join(img_dir,'*g')
112 |     files = glob.glob(data_path)
113 |     test = []
114 |     # Since same name order will be the same
115 |     for f1 in files:
116 |         img = rgb2gray(cv2.imread(f1))
117 |         test.append(img)
118 |     test = [preprocessing(d) for d in test]
119 | 
120 |     predicted = model.predict(test, threshold=0, asyn=False)
121 |     print("Show prediction results...")
122 |     plot(data, test, predicted)
123 |     #print("Show network weights matrix...")
124 |     #model.plot_weights("results_custom/")
125 | 
126 | if __name__ == '__main__':
127 |     main()
128 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Hopfield-Network
 2 | Create a Hopfield Network for Image Reconstruction
 3 | 
 4 | ## What is a Hopefield Network ?
 5 | 
 6 | At its core a Hopfield Network is a model that can reconstruct data after being fed with corrupt versions of the same data. This neural network proposed by Hopfield in 1982 can be seen as a network with associative memory.
 7 | 
 8 | Lets say you hear a melody of a song and suddenly remember when you where on a concert hearing your favorite band playing just that song. That is associative memory. You get an input, which is a fragment of a memory you have stored in your brain, and get an output of the entire memory you have stored in your brain.
 9 | 
10 | <p align="center">
11 | <img src="https://github.com/crypto-code/Hopfield-Network/blob/master/assets/model.gif" align="middle" />   </p>
12 | 
13 | The Hopfield network here works in the same way. When the network is presented with an input, i.e. put in a state, the networks nodes will start to update and converge to a state which is a previously stored pattern. The learning algorithm “stores” a given pattern in the network by adjusting the weights. There is off course a limit to how many “memories” you can store correctly in the network, and empirical results show that for every pattern to be stored correctly, the number of patterns has to between 10-20% compared to the number of nodes.
14 | 
15 | ## How it Works ?
16 | 
17 | The units in Hopfield nets are binary threshold units, i.e. the units only take on two different values for their states and the value is determined by whether or not the units' input exceeds their threshold. Hopfield nets normally have units that take on values of 1 or -1. 
18 | 
19 | Hopfield nets have a scalar value associated with each state of the network, referred to as the "energy", E, of the network, where:
20 | 
21 | <p align="center">
22 |   <img src="https://github.com/crypto-code/Hopfield-Network/blob/master/assets/energy.svg" align="middle"/> </p>
23 | 
24 | This quantity is called "energy" because it either decreases or stays the same upon network units being updated. Furthermore, under repeated updating the network will eventually converge to a state which is a local minimum in the energy function.
25 | 
26 | Training a Hopfield net involves lowering the energy of states that the net should "remember". This allows the net to serve as a content addressable memory system, that is to say, the network will converge to a "remembered" state if it is given only part of the state. The net can be used to recover from a distorted input to the trained state that is most similar to that input. This is called associative memory because it recovers memories on the basis of similarity. For example, if we train a Hopfield net with five units so that the state (1, -1, 1, -1, 1) is an energy minimum, and we give the network the state (1, -1, -1, -1, 1) it will converge to (1, -1, 1, -1, 1). Thus, the network is properly trained when the energy of states which the network should remember are local minima.
27 | 
28 | ## Usage
29 | 
30 | - To train a Hopfield Network on a dataset of images, first place the images in the /train folder (A few images are already provided). Then run train.py script.
31 | 
32 | ### Result:
33 | <p align="center">
34 |   <img src="https://github.com/crypto-code/Hopfield-Network/blob/master/assets/result_0.png" height=400 align="middle"/> </p>
35 |   
36 |  <p align="center">
37 |   <img src="https://github.com/crypto-code/Hopfield-Network/blob/master/assets/result_1.png" height=400 align="middle"/> </p>
38 | 
39 | This script trains the network on the provided images and tests image recounstruction by using the "images+random noise" as input. As seen above the images are reconstructed almost perfectly.
40 | 
41 | 
42 | - To train a Hopfield Network to reconstruct images from custom noisy images, first place the train images in the /train_custom folder and the noisy images in /test_custom folder (A few images are already provided). Then run train_custom.py script.
43 | 
44 | **Note: The noisy images should have same name as its corresponding train image**
45 | 
46 | ### Result
47 | 
48 | <p align="center">
49 |   <img src="https://github.com/crypto-code/Hopfield-Network/blob/master/assets/result_0_custom.png" height=400 align="middle"/> </p>
50 |   
51 | As you can see above the unwanted parts of the images are removed. In the first image the **&** is removed and in the second the man's glasses is removed almost perfectly.
52 | 
53 | 
54 | ### Model Weights:
55 | **Note: If you want to plot the weights of the network, just uncomment line:116 in train.py and line:124 in train_custom.py**
56 | <p align="center">
57 |   <img src="https://github.com/crypto-code/Hopfield-Network/blob/master/assets/weights.png" align="middle"/> </p>
58 |   
59 | # G00D LUCK
60 | 
61 | For doubts email me at:
62 | atinsaki@gmail.com
63 | 


--------------------------------------------------------------------------------
/assets/energy.svg:
--------------------------------------------------------------------------------
 1 | <svg xmlns:xlink="http://www.w3.org/1999/xlink" width="30.204ex" height="6.676ex" style="vertical-align: -3.338ex;" viewBox="0 -1437.2 13004.6 2874.4" role="img" focusable="false" xmlns="http://www.w3.org/2000/svg" aria-labelledby="MathJax-SVG-1-Title">
 2 | <title id="MathJax-SVG-1-Title">{\displaystyle E=-{\frac {1}{2}}\sum _{i,j}{w_{ij}{s_{i}}{s_{j}}}+\sum _{i}{\theta _{i}}{s_{i}}}</title>
 3 | <defs aria-hidden="true">
 4 | <path stroke-width="1" id="E1-MJMATHI-45" d="M492 213Q472 213 472 226Q472 230 477 250T482 285Q482 316 461 323T364 330H312Q311 328 277 192T243 52Q243 48 254 48T334 46Q428 46 458 48T518 61Q567 77 599 117T670 248Q680 270 683 272Q690 274 698 274Q718 274 718 261Q613 7 608 2Q605 0 322 0H133Q31 0 31 11Q31 13 34 25Q38 41 42 43T65 46Q92 46 125 49Q139 52 144 61Q146 66 215 342T285 622Q285 629 281 629Q273 632 228 634H197Q191 640 191 642T193 659Q197 676 203 680H757Q764 676 764 669Q764 664 751 557T737 447Q735 440 717 440H705Q698 445 698 453L701 476Q704 500 704 528Q704 558 697 578T678 609T643 625T596 632T532 634H485Q397 633 392 631Q388 629 386 622Q385 619 355 499T324 377Q347 376 372 376H398Q464 376 489 391T534 472Q538 488 540 490T557 493Q562 493 565 493T570 492T572 491T574 487T577 483L544 351Q511 218 508 216Q505 213 492 213Z"></path>
 5 | <path stroke-width="1" id="E1-MJMAIN-3D" d="M56 347Q56 360 70 367H707Q722 359 722 347Q722 336 708 328L390 327H72Q56 332 56 347ZM56 153Q56 168 72 173H708Q722 163 722 153Q722 140 707 133H70Q56 140 56 153Z"></path>
 6 | <path stroke-width="1" id="E1-MJMAIN-2212" d="M84 237T84 250T98 270H679Q694 262 694 250T679 230H98Q84 237 84 250Z"></path>
 7 | <path stroke-width="1" id="E1-MJMAIN-31" d="M213 578L200 573Q186 568 160 563T102 556H83V602H102Q149 604 189 617T245 641T273 663Q275 666 285 666Q294 666 302 660V361L303 61Q310 54 315 52T339 48T401 46H427V0H416Q395 3 257 3Q121 3 100 0H88V46H114Q136 46 152 46T177 47T193 50T201 52T207 57T213 61V578Z"></path>
 8 | <path stroke-width="1" id="E1-MJMAIN-32" d="M109 429Q82 429 66 447T50 491Q50 562 103 614T235 666Q326 666 387 610T449 465Q449 422 429 383T381 315T301 241Q265 210 201 149L142 93L218 92Q375 92 385 97Q392 99 409 186V189H449V186Q448 183 436 95T421 3V0H50V19V31Q50 38 56 46T86 81Q115 113 136 137Q145 147 170 174T204 211T233 244T261 278T284 308T305 340T320 369T333 401T340 431T343 464Q343 527 309 573T212 619Q179 619 154 602T119 569T109 550Q109 549 114 549Q132 549 151 535T170 489Q170 464 154 447T109 429Z"></path>
 9 | <path stroke-width="1" id="E1-MJSZ2-2211" d="M60 948Q63 950 665 950H1267L1325 815Q1384 677 1388 669H1348L1341 683Q1320 724 1285 761Q1235 809 1174 838T1033 881T882 898T699 902H574H543H251L259 891Q722 258 724 252Q725 250 724 246Q721 243 460 -56L196 -356Q196 -357 407 -357Q459 -357 548 -357T676 -358Q812 -358 896 -353T1063 -332T1204 -283T1307 -196Q1328 -170 1348 -124H1388Q1388 -125 1381 -145T1356 -210T1325 -294L1267 -449L666 -450Q64 -450 61 -448Q55 -446 55 -439Q55 -437 57 -433L590 177Q590 178 557 222T452 366T322 544L56 909L55 924Q55 945 60 948Z"></path>
10 | <path stroke-width="1" id="E1-MJMATHI-69" d="M184 600Q184 624 203 642T247 661Q265 661 277 649T290 619Q290 596 270 577T226 557Q211 557 198 567T184 600ZM21 287Q21 295 30 318T54 369T98 420T158 442Q197 442 223 419T250 357Q250 340 236 301T196 196T154 83Q149 61 149 51Q149 26 166 26Q175 26 185 29T208 43T235 78T260 137Q263 149 265 151T282 153Q302 153 302 143Q302 135 293 112T268 61T223 11T161 -11Q129 -11 102 10T74 74Q74 91 79 106T122 220Q160 321 166 341T173 380Q173 404 156 404H154Q124 404 99 371T61 287Q60 286 59 284T58 281T56 279T53 278T49 278T41 278H27Q21 284 21 287Z"></path>
11 | <path stroke-width="1" id="E1-MJMAIN-2C" d="M78 35T78 60T94 103T137 121Q165 121 187 96T210 8Q210 -27 201 -60T180 -117T154 -158T130 -185T117 -194Q113 -194 104 -185T95 -172Q95 -168 106 -156T131 -126T157 -76T173 -3V9L172 8Q170 7 167 6T161 3T152 1T140 0Q113 0 96 17Z"></path>
12 | <path stroke-width="1" id="E1-MJMATHI-6A" d="M297 596Q297 627 318 644T361 661Q378 661 389 651T403 623Q403 595 384 576T340 557Q322 557 310 567T297 596ZM288 376Q288 405 262 405Q240 405 220 393T185 362T161 325T144 293L137 279Q135 278 121 278H107Q101 284 101 286T105 299Q126 348 164 391T252 441Q253 441 260 441T272 442Q296 441 316 432Q341 418 354 401T367 348V332L318 133Q267 -67 264 -75Q246 -125 194 -164T75 -204Q25 -204 7 -183T-12 -137Q-12 -110 7 -91T53 -71Q70 -71 82 -81T95 -112Q95 -148 63 -167Q69 -168 77 -168Q111 -168 139 -140T182 -74L193 -32Q204 11 219 72T251 197T278 308T289 365Q289 372 288 376Z"></path>
13 | <path stroke-width="1" id="E1-MJMATHI-77" d="M580 385Q580 406 599 424T641 443Q659 443 674 425T690 368Q690 339 671 253Q656 197 644 161T609 80T554 12T482 -11Q438 -11 404 5T355 48Q354 47 352 44Q311 -11 252 -11Q226 -11 202 -5T155 14T118 53T104 116Q104 170 138 262T173 379Q173 380 173 381Q173 390 173 393T169 400T158 404H154Q131 404 112 385T82 344T65 302T57 280Q55 278 41 278H27Q21 284 21 287Q21 293 29 315T52 366T96 418T161 441Q204 441 227 416T250 358Q250 340 217 250T184 111Q184 65 205 46T258 26Q301 26 334 87L339 96V119Q339 122 339 128T340 136T341 143T342 152T345 165T348 182T354 206T362 238T373 281Q402 395 406 404Q419 431 449 431Q468 431 475 421T483 402Q483 389 454 274T422 142Q420 131 420 107V100Q420 85 423 71T442 42T487 26Q558 26 600 148Q609 171 620 213T632 273Q632 306 619 325T593 357T580 385Z"></path>
14 | <path stroke-width="1" id="E1-MJMATHI-73" d="M131 289Q131 321 147 354T203 415T300 442Q362 442 390 415T419 355Q419 323 402 308T364 292Q351 292 340 300T328 326Q328 342 337 354T354 372T367 378Q368 378 368 379Q368 382 361 388T336 399T297 405Q249 405 227 379T204 326Q204 301 223 291T278 274T330 259Q396 230 396 163Q396 135 385 107T352 51T289 7T195 -10Q118 -10 86 19T53 87Q53 126 74 143T118 160Q133 160 146 151T160 120Q160 94 142 76T111 58Q109 57 108 57T107 55Q108 52 115 47T146 34T201 27Q237 27 263 38T301 66T318 97T323 122Q323 150 302 164T254 181T195 196T148 231Q131 256 131 289Z"></path>
15 | <path stroke-width="1" id="E1-MJMAIN-2B" d="M56 237T56 250T70 270H369V420L370 570Q380 583 389 583Q402 583 409 568V270H707Q722 262 722 250T707 230H409V-68Q401 -82 391 -82H389H387Q375 -82 369 -68V230H70Q56 237 56 250Z"></path>
16 | <path stroke-width="1" id="E1-MJMATHI-3B8" d="M35 200Q35 302 74 415T180 610T319 704Q320 704 327 704T339 705Q393 701 423 656Q462 596 462 495Q462 380 417 261T302 66T168 -10H161Q125 -10 99 10T60 63T41 130T35 200ZM383 566Q383 668 330 668Q294 668 260 623T204 521T170 421T157 371Q206 370 254 370L351 371Q352 372 359 404T375 484T383 566ZM113 132Q113 26 166 26Q181 26 198 36T239 74T287 161T335 307L340 324H145Q145 321 136 286T120 208T113 132Z"></path>
17 | </defs>
18 | <g stroke="currentColor" fill="currentColor" stroke-width="0" transform="matrix(1 0 0 -1 0 0)" aria-hidden="true">
19 |  <use xlink:href="#E1-MJMATHI-45" x="0" y="0"></use>
20 |  <use xlink:href="#E1-MJMAIN-3D" x="1042" y="0"></use>
21 |  <use xlink:href="#E1-MJMAIN-2212" x="2098" y="0"></use>
22 | <g transform="translate(2877,0)">
23 | <g transform="translate(120,0)">
24 | <rect stroke="none" width="620" height="60" x="0" y="220"></rect>
25 |  <use xlink:href="#E1-MJMAIN-31" x="60" y="676"></use>
26 |  <use xlink:href="#E1-MJMAIN-32" x="60" y="-687"></use>
27 | </g>
28 | </g>
29 | <g transform="translate(3904,0)">
30 |  <use xlink:href="#E1-MJSZ2-2211" x="0" y="0"></use>
31 | <g transform="translate(355,-1086)">
32 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-69" x="0" y="0"></use>
33 |  <use transform="scale(0.707)" xlink:href="#E1-MJMAIN-2C" x="345" y="0"></use>
34 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-6A" x="624" y="0"></use>
35 | </g>
36 | </g>
37 | <g transform="translate(5515,0)">
38 |  <use xlink:href="#E1-MJMATHI-77" x="0" y="0"></use>
39 | <g transform="translate(716,-150)">
40 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-69" x="0" y="0"></use>
41 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-6A" x="345" y="0"></use>
42 | </g>
43 | <g transform="translate(1352,0)">
44 |  <use xlink:href="#E1-MJMATHI-73" x="0" y="0"></use>
45 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-69" x="663" y="-213"></use>
46 | </g>
47 | <g transform="translate(2166,0)">
48 |  <use xlink:href="#E1-MJMATHI-73" x="0" y="0"></use>
49 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-6A" x="663" y="-213"></use>
50 | </g>
51 | </g>
52 |  <use xlink:href="#E1-MJMAIN-2B" x="8765" y="0"></use>
53 | <g transform="translate(9765,0)">
54 |  <use xlink:href="#E1-MJSZ2-2211" x="0" y="0"></use>
55 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-69" x="848" y="-1536"></use>
56 | </g>
57 | <g transform="translate(11376,0)">
58 |  <use xlink:href="#E1-MJMATHI-3B8" x="0" y="0"></use>
59 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-69" x="663" y="-213"></use>
60 | </g>
61 | <g transform="translate(12190,0)">
62 |  <use xlink:href="#E1-MJMATHI-73" x="0" y="0"></use>
63 |  <use transform="scale(0.707)" xlink:href="#E1-MJMATHI-69" x="663" y="-213"></use>
64 | </g>
65 | </g>
66 | </svg>


--------------------------------------------------------------------------------