def stress_vs_estimate(N=128,dim=2): noise2signal = 10**np.arange(-2.5,0.5,0.5); num1=len(noise2signal) average_neighbors = [2,8,32,128,512]; num2=len(average_neighbors) its = 10 X = misc.disk(N,dim=dim) D = distance_matrix(X,X) signal_std = np.std(X) noise = np.sqrt(noise2signal)*signal_std vis = mds.MDS(D,dim=dim) for i in range(num1): X_noisy = X+np.random.randn(N,dim)*noise2signal[i] true_stress = mds.stress_function(X_noisy,D,estimate=False) print(f'exact stress : {true_stress:0.2e}') for j in range(num2): print(f' average neighbors : {average_neighbors[j]}') stress = 0 stresses = [] for k in range(its): stresses.append(mds.stress_function( X_noisy,D,estimate=average_neighbors[j])) print(f' average stress : {np.average(stresses):0.2e} '+\ f'[{abs(np.average(stresses)-true_stress)/true_stress:0.2e}]') print(f' standard deviation : {np.std(stresses):0.2e} '+\ f'[{np.std(stresses)/true_stress:0.2e}]') print(f' minimum stress : {min(stresses):0.2e} '+\ f'[{abs(min(stresses)-true_stress)/true_stress:0.2e}]') print(f' maximum stress : {max(stresses):0.2e} '+\ f'[{abs(max(stresses)-true_stress)/true_stress:0.2e}]')
def mds_comparison(): max_iters = 100 save_frequency = 10 import misc, distances, mds print('\n*** gd.mds_comparison() ***\n') Y = misc.disk(30,2) plt.figure() plt.plot(Y[:,0],Y[:,1],'o') plt.title('Original data') plt.draw() plt.pause(0.1) D = distances.compute(Y) vis = mds.MDS(D,dim=2,verbose=1) vis.initialize_Y() vis.optimize(algorithm='gd',max_iters=max_iters,save_cost=True, learning_rate=0.01,from_scratch=True, save_frequency=save_frequency,label='mds, lr=0.01',verbose=2) vis.optimize(algorithm='gd',max_iters=max_iters,save_cost=True, learning_rate=0.1,from_scratch=True, save_frequency=save_frequency,label='mds, lr=0.05',verbose=2) vis.optimize(algorithm='agd',max_iters=max_iters,save_cost=True, from_scratch=True,save_frequency=save_frequency,verbose=2) plt.show()
def smart_initialize(self,max_iter=[50,30],lr=[1,0.1], batch_size=10,**kwargs): """\ Computes an mds embedding (dimension embedding_dimension) of the combined distances. Only works when self.Q_is_fixed is False (as this is unnecessary otherwhise). Parameters : X0 : None or array Optional initial embedding (used to compute mds embedding) Q0 : None or list of arrays Optional initial projection parameters. """ assert self.fixed_embedding is False assert self.fixed_projections is False if self.verbose > 0: print(self.indent+' MPSE.smart_initialize():') distances = np.sum(self.distances,axis=0)/self.n_perspectives if self.weights is not None and self.weights[0] is not None: weights = np.product(self.weights,axis=0) else: weights = None vis = mds.MDS(distances,dim=self.embedding_dimension,min_grad=1e-4, indent=self.indent+' ', initial_embedding=self.embedding, weights = weights, verbose=self.verbose) vis.gd(batch_size=batch_size, max_iter=max_iter[0],lr=lr[0],**kwargs) self.embedding = vis.X H = vis.computation_history[0] H['fixed_embedding'] = False H['fixed_projections'] = True self.computation_history.append(H) def Xi(): indices = np.arange(self.n_samples) np.random.shuffle(indices) xi = { 'indices' : indices } return xi F = lambda Q, indices : self.gradient(self.embedding,Q, batch_size=batch_size, return_embedding=False) Q0 = np.array(self.projections) self.projections, H = gd.single(Q0,F,Xi=Xi,p=self.proj.restrict, max_iter=max_iter[1],lr=lr[1], verbose=self.verbose,indent=self.indent+' ', **kwargs) H['fixed_embedding'] = True H['fixed_projections'] = False self.computation_history.append(H) return
def stress_vs_noise(N=128, dim=2): X = misc.disk(N, dim=dim) D = distance_matrix(X, X) vis = mds.MDS(D, dim=dim) noise = 10**np.arange(-2, 3, 0.5) its = len(noise) stress = np.empty(its) for i in range(its): X_noisy = X + np.random.randn(N, dim) * noise[i] stress[i] = mds.stress_function(X_noisy, D, estimate=False) vis.initialize(X0=X_noisy) vis.figureX(title=f'noise: {noise[i]:0.2e}, stress: {stress[i]:0.2e}') plt.show() return
def algorithmRequest(self, request): if 'parameters' in request.keys(): params = request['parameters'][0] params = json.loads(params) print 'parameters:', params, ' type:', params['type'] if 'type' in params and 'name' in params: if params['type'] == 'layout': layoutName = params['name'].encode("utf-8") g = None if layoutName == 'MDS': print "calling mds layout" g = self.getGraphMan(request).substrate descP = g.getStringProperty("descriptors") #res = mds.MDS(g, descP).points() res = mds.MDS(g, descP).sklearn_mds() print res else: g = self.getGraphMan(request).callLayoutAlgorithm( layoutName, params['target'].encode("utf-8")) if g: graphJSON = self.getGraphMan(request).graphToJSON( g, {'nodes': [{ 'type': 'string', 'name': 'label' }]}) self.sendJSON(graphJSON) if params['type'] == 'float': g = self.getGraphMan(request).callDoubleAlgorithm( params['name'].encode("utf-8"), params['target'].encode("utf-8")) graphJSON = self.getGraphMan(request).graphToJSON( g, { 'nodes': [{ 'type': 'float', 'name': 'viewMetric' }, { 'type': 'string', 'name': 'label' }] }) self.sendJSON(graphJSON) if params['type'] == 'synchronize layouts': print "calling layout sync" graphJSON = self.getGraphMan(request).synchronizeLayouts() self.sendJSON(graphJSON)
def compute_mds(num=2): if num==2: attributes = attributes2 families = families2 elif num==3: attributes = attributes3 families = families3 S = setup.connections(attributes_list=attributes,families_list=families) D = distances.dmatrices(S,input_type='similarities', connect_components=True,connect_factor=1.5) K = len(S); N = len(S[0]) fig, axs = plt.subplots(1,K,sharey=True,sharex=True) for i in range(K): vis = mds.MDS(D[i],labels=families) vis.initialize() vis.optimize(algorithm='agd') vis.graph(title=attributes[i]) axs[i].title.set_text(attributes[i]) if i ==0 : for n in range(N): axs[i].scatter(vis.X[n,0],vis.X[n,1],label=families[n]) else: for n in range(N): axs[i].scatter(vis.X[n,0],vis.X[n,1]) fig.legend(loc=7) fig.tight_layout() fig.subplots_adjust(right=0.85) plt.show(block=False) fig = vis.figure(); plt.show(block=False) #proj = perspective.Persp() #proj.fix_Q(number=K, special='standard') #mv = multiview.Multiview(D,persp=proj,labels=families) #mv.setup_visualization() #mv.initialize_X() #mv.optimize_X(rate=0.002,max_iters=200) #mv.figureX(); mv.figureY(); #mv.figure(); #mv.graphY(k=0); mv.graphY(k=1) plt.show()
def reliability0(N=100, trials=3, repeats=5, **kwargs): """\ Check number of times the mds algorithm is able to reach the optimal solution for different random embeddings. """ print('\n***mds.reliability()***') cost = np.empty((repeats, trials)) success = np.zeros(repeats) for i in range(repeats): X = misc.disk(N, 2) D = multigraph.graph_from_coordinates(X, **kwargs) for j in range(trials): vis = mds.MDS(D, dim=2, **kwargs) vis.gd(min_step=1e-3, **kwargs) cost[i, j] = vis.cost if vis.cost < 1e-3: success[i] += 1 print(cost) print(success)
def reliability(N=[100], edge_probability=[None], trials=10, **kwargs): """\ Check number of times the mds algorithm is able to reach the optimal solution for different random embeddings. """ print('\n***mds.reliability()***') lenN = len(N) lenE = len(edge_probability) success_count = np.zeros((lenN, lenE)) time_ave = np.zeros((lenN, lenE)) for i in range(lenN): n = N[i] for j in range(lenE): p = edge_probability[j] for k in range(trials): X = misc.disk(n, 2) D = multigraph.graph_from_coordinates(X, **kwargs) vis = mds.MDS(D, dim=2, **kwargs) vis.gd(min_step=1e-4, edge_probability=p, max_iters=1e6, **kwargs) if vis.cost < 1e-2: success_count[i, j] += 1 time_ave[i, j] += vis.H['time'] if success_count[i, j] != 0: time_ave[i, j] /= success_count[i, j] print('N, prob :', n, p) print(' success ratio :', success_count[i, j] / trials) print(' average time :', time_ave[i, j]) success_ratio = success_count / trials plt.figure() df = pd.DataFrame(success_ratio.T, E, N) sn.set(font_scale=1.4) sn.heatmap(df, annot=time_ave.T, cbar_kws={'label': 'success ratio'}) plt.xlabel('number of nodes') plt.ylabel('edge probabilities') plt.title('computation time') plt.show()
def stress_vs_miss(N=128,dim=2): num = 8 misses = [1,2,4,8,16,32,64,128] fig, ax = plt.subplots(2,4,figsize=(12,6)) axs = ax.flatten() fig.suptitle('normalized-stress / number-of-misplaced-nodes') fig.tight_layout(pad=2.5) fig.subplots_adjust(top=0.88) X = misc.disk(N,dim=dim) D = distance_matrix(X,X) vis = mds.MDS(D,dim=dim) stress = np.empty(num) for i in range(num): X_misplaced = X.copy() X_misplaced[-misses[i]::] = misc.disk(misses[i],dim=dim) stress[i] = mds.stress_function(X_misplaced,D,estimate=False) vis.initialize(X0=X_misplaced) vis.figureX(title=f'{stress[i]:0.2e} / {misses[i]}', ax=axs[i]) plt.show()
def initialize_X(self, X0=None, method='mds',max_iters=50,**kwargs): """\ Set initial embedding using misc.initial function. Parameters: Y0 : numpy array Initial embedding (optional) number : int > 0 Number of initial embeddings to be generated and saved. When looking for a minimizer of the stress function, the optimization algorithm is run using the different initial embeddings and the best solution is retained. """ if self.verbose > 0: print('- Multiview.initialize_X():') if X0 is not None: if self.verbose > 0: print(' method : X0 given') assert isinstance(X0,np.ndarray) assert X0.shape == (self.N,self.persp.dimX) self.X = X0 else: if self.verbose > 0: print(' method : ',method) if method == 'random': self.X = misc.initial_embedding(self.N,dim=self.persp.dimX, radius=self.D_rms,**kwargs) elif method == 'mds': D = np.average(self.D,axis=0) vis = mds.MDS(D,dim=self.persp.dimX) vis.initialize() vis.optimize(max_iters=max_iters,**kwargs) self.X = vis.X self.update() self.X0 = self.X.copy()
def agd_mds_standard(N=100,dim=2,trials=3,runs=5): """\ test convergence of adaptive gradient descent for MDS problem, by solving the MDS problems with multiple initial parameters. """ print('*** test.agd_mds_standard() ***') print(f' N : {N}') print(f' dim : {dim}') print() for i in range(trials): print(f' Trial # {i}') print(' Normalized cost :') Y = misc.disk(N,dim) D = distances.compute(Y) vis = mds.MDS(D,dim=dim) stress = [] for run in range(runs): vis.initialize_Y() vis.optimize(algorithm='agd') stress.append(vis.ncost) print(f' {vis.ncost:0.2e}') print()
def all(D, persp, method='mds', separate=True, fixed=True, varying=True, verbose=0, title='', names=None, labels=None, edges=None, **kwargs): """ Runs all algorithms on specified data and returns all instances. """ K = len(D) N = len(D[0]) # Separate visualization if separate is True: svis = [] for k in range(K): svis.append(mds.MDS(D[k])) svis[k].initialize() svis[k].optimize(verbose=verbose, **kwargs) if fixed is True: fvis = multiview.Multiview(D, persp, verbose=verbose, labels=labels) fvis.setup_visualization() fvis.initialize_X() fvis.optimize_X() if varying is True: vvis = multiview.Multiview(D, persp, verbose=verbose, labels=labels) vvis.setup_visualization() vvis.initialize_X() vvis.initialize_Q() vvis.optimize_all(batch_number=10, max_iters=300) return svis, fvis, vvis
def stress_vs_noise(N=128,dim=2): num = 6 noise2signal = 10**np.arange(-2.5,0.5,0.5) fig, ax = plt.subplots(2,3,figsize=(9,6)) axs = ax.flatten() fig.suptitle('noise-to-signal-ratio / normalized-stress') fig.tight_layout(pad=2.5) fig.subplots_adjust(top=0.88) X = misc.disk(N,dim=dim) signal_std = np.std(X) noise = np.sqrt(noise2signal)*signal_std D = distance_matrix(X,X) vis = mds.MDS(D,dim=dim) stress = np.empty(num) for i in range(num): X_noisy = X+np.random.randn(N,dim)*noise2signal[i] stress[i] = mds.stress_function(X_noisy,D,estimate=False) vis.initialize(X0=X_noisy) vis.figureX(title=f'{noise2signal[i]:0.2e} / {stress[i]:0.2e}', ax=axs[i]) plt.show() return
def __init__(self, data, weights=None, data_args=None, fixed_embedding=None, fixed_projections=None, initial_embedding=None, initial_projections=None, visualization_method='mds', visualization_args={}, total_cost_function='rms', embedding_dimension=3, image_dimension=2, projection_family='linear',projection_constraint='orthogonal', hidden_samples=None, sample_labels=None, perspective_labels=None, sample_colors=None, image_colors=None, verbose=0, indent='', **kwargs): """\ Initializes MPSE object. Parameters ---------- data : list, length (n_perspectives) List containing distance/dissimilarity/feature data for each perspective. Each array can be of the following forms: 1) A 1D condensed distance array 2) A square distance matrix 3) An array containing features ***4) A dictionary describing a graph weights : None or string or array or list If visualization allows for it, weights to be used in computation of cost/gradiant of each perspective. IF a list is given, then the list must have length equal to the number of perspectives. Otherwise, it is assumed that the given weights are the same for all perspectives. The possible weights are described in setup.setup_weights. These are: 1) None : no weights are used 2) string : method to compute weights based on distances 3) function : function to compute weights based on distances 4) array : array containing pairwise weights or node weights, depending on size (must be of length of distances or of samples). data_args : dictionary (optional) or list Optional arguments to pass to distances.setup(). If a list is passed, then the length must be the number of perspectives and each element must be a dictionary. Then, each set of distances will be set up using a different set of arguments. fixed_embedding : array If an array is given, this is assumed to be the true embedding and by default optimization is done w.r.t. the projections only. fixed_projections : list If a list is given, this is assumed to be the true projections and by default optimization is done w.r.t. the embedding coordinates only. initial_embedding : array If given, this is the initial embedding used. initial_projections : list If given, this is the initial projections used. visualization_method : str Visualization method. Current options are 'mds' and 'tsne'. The visualization method can be different for different perspectives, by passing a list of visualization methods instead. visualization_args : dict Dictionary with arguments to pass to each visualization method. Different arguments can be passed to different visualization methods by passing a list of dictionaries instead. embedding_dimension : int Dimension of embedding. image_dimension : int Dimension of image (after projection). Each perspective can have a different image dimension, by specifying a list instead. projection_family : str Projection family. Options are 'linear'. projection_constraint : str Constraints on projection family. Options are None, 'orthogonal', 'similar'. embedding_dimension : int > 0 Dimension of the embedding. Alternative name: embedding_dimension projection_dimension : int or array Dimension of projections. Can be different for each perspective. persp : Object instance of projections.Persp class or int > 0. Describes set of allowed projection functions and stores list of projection parameters. See perspective.py. If instead of a Persp object a positive integer int is given, then it is assumed that embedding_dimension=image_dimension=int and that all projections are the identity. sample_labels : list (optional) List containing labels of samples (used in plots). sample_colors : array (optional) Array containing color value of samples (used in plots). image_colors : array-like, shape (n_perspectives, n_samples) Colors for each image. """ self.verbose, self.indent = verbose, indent if verbose > 0: print(indent+'mview.MPSE():') ##set up sets of distances from data self.distances = setup.setup_distances_from_multiple_perspectives( data, data_args) self.n_perspectives = len(self.distances) self.n_samples = scipy.spatial.distance.num_obs_y(self.distances[0]) ##set up weights from data if isinstance(weights,list) or isinstance(weights, np.ndarray): assert len(weights) == self.n_perspectives self.weights = weights else: self.weights = [weights]*self.n_perspectives for i in range(self.n_perspectives): self.weights[i] = setup.setup_weights(self.distances[i], \ self.weights[i], min_weight = 0) ##set up parameters self.embedding_dimension = embedding_dimension self.image_dimension = image_dimension self.projection_family = projection_family self.projection_constraint = projection_constraint proj = projections.PROJ(embedding_dimension,image_dimension, projection_family,projection_constraint) self.proj = proj ##set up hidden samples if hidden_samples is not None: assert isinstance(hidden_samples, list) assert len(hidden_samples) == self.n_perspectives self.hidden_samples = hidden_samples if verbose > 0: print(indent+' data details:') print(indent+f' number of perspectives : {self.n_perspectives}') print(indent+f' number of samples : {self.n_samples}') print(indent+' visualization details:') print(indent+' embedding dimension :',self.embedding_dimension) print(indent+f' image dimension : {self.image_dimension}') print(indent+f' visualization type : {visualization_method}') #setup sample labels: if sample_labels is not None: assert len(sample_labels) == self.n_samples self.sample_labels = sample_labels #setup perspective labels: if perspective_labels is None: perspective_labels = range(1,self.n_perspectives+1) else: assert len(perspective_labels) == self.n_perspectives self.perspective_labels = perspective_labels #setup colors: self.sample_colors = sample_colors self.image_colors = image_colors #setup visualization instances: self.visualization_instances = [] self.visualization_method = visualization_method if isinstance(visualization_method,str): visualization_method = [visualization_method]*self.n_perspectives if isinstance(visualization_args,dict): visualization_args = [visualization_args]*self.n_perspectives for i in range(self.n_perspectives): assert visualization_method[i] in ['mds','tsne'] if self.verbose > 0: print(' setup visualization instance for perspective', self.perspective_labels[i],':') if visualization_method[i] == 'mds': vis = mds.MDS(self.distances[i], weights = self.weights[i], embedding_dimension=self.image_dimension, verbose=self.verbose, indent=self.indent+' ', **visualization_args[i]) elif visualization_method[i] == 'tsne': vis = tsne.TSNE(self.distances[i], embedding_dimension=self.image_dimension, verbose=self.verbose, indent=self.indent+' ', **visualization_args[i]) self.visualization_instances.append(vis) self.visualization = self.visualization_instances #setup objectives: if total_cost_function == 'rms': self.total_cost_function = lambda individual_costs : \ np.sqrt(np.sum(individual_costs**2)/self.n_perspectives) else: assert callable(total_cost_function) self.total_cost_function = total_cost_function def cost_function(X,Q,Y=None,**kwargs): if Y is None: Y = self.proj.project(Q,X) individual_costs = np.zeros(self.n_perspectives) for k in range(self.n_perspectives): individual_costs[k] = \ self.visualization[k].objective(Y[k],**kwargs) cost = self.total_cost_function(individual_costs) return cost, individual_costs self.cost_function = cost_function #setup gradient function: if self.projection_family == 'linear': def gradient(embedding,projections,batch_size=None,indices=None, return_embedding=True,return_projections=True, return_cost=True, return_individual_costs=False): """\ Returns MPSE gradient(s), along with cost and individual costs (optional). Parameters ---------- embedding : numpy array Current embedding. projections : numpy array Current projections (as a single array). return_embedding : boolean If True, returns MPSE gradient w.r.t. embedding. return_projections : boolean If True, returns MPSE gradient w.r.t. projections. return_cost : boolean If True, returns MPSE cost. return_individual_costs : boolean If True, returns individual embedding costs. """ if return_embedding: dX = np.zeros(embedding.shape) if return_projections: dQ = [] individual_costs = np.empty(self.n_perspectives) Y = self.proj.project(projections,embedding) for k in range(self.n_perspectives): dY_k, cost_k = self.visualization[k].gradient( Y[k],batch_size=batch_size,indices=indices) individual_costs[k] = cost_k if return_embedding: dX += dY_k @ projections[k][:2, :3] if return_projections: dQ.append(dY_k.T @ embedding) if return_embedding: dX /= self.n_perspectives cost = self.total_cost_function(individual_costs) if return_embedding is False: grad = np.array(dQ) elif return_projections is False: grad = dX else: grad = [dX,np.array(dQ)] if return_individual_costs: return grad, cost, individual_costs else: return grad, cost self.gradient = gradient else: def gradient_X(X,Q,Y=None): pgradient = self.proj.compute_gradient(X[0],params_list=Q) if Y is None: Y = self.proj.project(X,params_list=Q) gradient = np.zeros((self.n_samples,self.embedding_dimension)) for k in range(self.n_perspectives): gradient += self.visualization[k].gradient(Y[k]) \ @ pgradient[k] return gradient self.gradient_X = gradient_X #set up initial embedding and projections (fixed optional): if verbose > 0: print(indent+' initialize:') #set fixed and initial embedding: if fixed_embedding is not None: if verbose > 0: print(indent+' fixed embedding : True') self.embedding = fixed_embedding self.initial_embedding = fixed_embedding self.fixed_embedding = True else: if verbose > 0: print(indent+' fixed embedding : False') if initial_embedding is None: if verbose > 0: print(indent+' initial embedding : random') self.initial_embedding = misc.initial_embedding( self.n_samples,dim=self.embedding_dimension, radius=1) else: assert isinstance(initial_embedding,np.ndarray) assert initial_embedding.shape == ( self.n_samples, self.embedding_dimension) if verbose > 0: print(indent+' initial embedding : given') self.initial_embedding = initial_embedding self.embedding = self.initial_embedding self.fixed_embedding = False #set fixed and initial projections: if fixed_projections is not None: if isinstance(fixed_projections,str): fixed_projections = self.proj.generate(number= \ self.n_perspectives,method=fixed_projections) assert(all([isinstance(fp,np.ndarray) for fp in fixed_projections])) fixed_projections = [f[:2, :3] for f in fixed_projections] self.projections = fixed_projections self.initial_projections = fixed_projections self.fixed_projections = True if verbose > 0: print(indent+' fixed projections : True') else: if verbose > 0: print(indent+' fixed projections : False') if initial_projections is None: if verbose > 0: print(indent+' initial projections : random') self.initial_projections = self.proj.generate( number=self.n_perspectives, **kwargs) else: if verbose > 0: print(indent+' initial projections : given') if isinstance(initial_projections,str): initial_projections = self.proj.generate(number= \ self.n_perspectives,method=initial_projections) self.initial_projections = initial_projections self.projections = self.initial_projections self.fixed_projections = False print(indent+' Projection is:') print(self.projections) self.initial_cost = None self.initial_individual_cost = None self.computation_history = [] self.time = 0 self.update(**kwargs)
def main(D, persp, method='mds', separate=True, fixed=True, varying=True, verbose=0, title='', names=None, labels=None, edges=None, **kwargs): """ Runs all algorithms on specified data. """ K = len(D) if names is None: names = list(range(1, K + 1)) fig, axes = plt.subplots(3, K) [ax.set_axis_off() for ax in axes.ravel()] plt.tight_layout() # Separate visualization if separate is True: for k in range(K): vis = mds.MDS(D[k], labels=labels) vis.initialize() vis.optimize(verbose=verbose, **kwargs) vis.figureX(ax=axes[0, k], edges=edges[k]) axes[0, k].title.set_text(names[k] + f'\n {vis.ncost:0.2e}') vis.figure(plot=False) if fixed is True: vis = multiview.Multiview(D, persp, verbose=verbose, labels=labels) vis.setup_visualization() vis.initialize_X() vis.optimize_X() vis.figureY(axes=axes[1], edges=edges) for k in range(K): axes[1, k].title.set_text(f'{vis.individual_ncost[k]:0.2e}') vis.figure(plot=False) vis.figureX(edges=edges[0]) if varying is True: vis = multiview.Multiview(D, persp, verbose=verbose, labels=labels) vis.setup_visualization() vis.initialize_X() vis.initialize_Q() vis.optimize_all() print(vis.ncost) vis.figureY(axes=axes[2], edges=edges) for k in range(K): axes[2, k].title.set_text(f'{vis.individual_ncost[k]:0.2e}') vis.figure() vis.figureX(edges=edges[0]) axes[0, 0].set_ylabel('individual') axes[1, 0].set_ylabel('fixed perspectives') for ax in axes.flat: ax.set(xlabel='x-label', ylabel='y-label') plt.show()
''' Created on Nov 22, 2011 @author: Zephyre ''' import mds if __name__ == '__main__': dev = mds.MDS('COM3') dev.setDriverMode(0) dev.setLine(2) dev.switch(True) dev.setPowerdBm(22.5) print(dev.getStatus())