def liftAsProcessSample(self, coefficients): '''Function to lift a sample of coefficients into a collections of process samples and points. Parameters ---------- coefficients : ot.Sample sample of values, follwing a centered normal law in general Returns ------- processes : list ordered list of samples of scalars (ot.Sample) and field samples (ot.ProcessSample) ''' assert isinstance(coefficients, (ot.Sample, ot.SampleImplementation)) print('Lifting as process sample') jumpDim = 0 processes = [] for i in range(self.__field_distribution_count__): if self.__isProcess__[i] : if not self.__liftWithMean__: processes.append(self.__KL_lifting__[i](coefficients[:, jumpDim : jumpDim + self.__mode_count__[i]])) else : processSample = self.__KL_lifting__[i](coefficients[:, jumpDim : jumpDim + self.__mode_count__[i]]) addConstant2Iterable(processSample, self.__means__[i]) processes.append(processSample) else : if not self.__liftWithMean__: processSample = ot.ProcessSample(ot.Mesh(), 0, 1) val_sample = self.__KL_lifting__[i](coefficients[:, jumpDim : jumpDim + self.__mode_count__[i]]) for j, value in enumerate(val_sample): field = ot.Field(ot.Mesh(),1) field.setValueAtIndex(0,value) processSample.add(field) processes.append(processSample) else : processSample = ot.ProcessSample(ot.Mesh(), 0, 1) val_sample = self.__KL_lifting__[i](coefficients[:, jumpDim : jumpDim + self.__mode_count__[i]]) mean = self.__means__[i] for j, value in enumerate(val_sample): field = ot.Field(ot.Mesh(),1) field.setValueAtIndex(0,[value[0]+mean]) # adding mean processSample.add(field) processes.append(processSample) jumpDim += self.__mode_count__[i] return processes
def readProcessSample(fname): """ Return a ProcessSample from a text file. Assume the mesh is regular [0,1]. """ # Dataset data = np.loadtxt(fname) # Create the mesh n_nodes = data.shape[1] mesher = ot.IntervalMesher([n_nodes - 1]) Interval = ot.Interval([0.0], [1.0]) mesh = mesher.build(Interval) # Create the ProcessSample from the data n_fields = data.shape[0] dim_fields = 1 processSample = ot.ProcessSample(mesh, n_fields, dim_fields) for i in range(n_fields): trajectory = ot.Sample([[x] for x in data[i, :]]) processSample[i] = ot.Field(mesh, trajectory) return processSample
Y = Xs * ([2.0] * Xs.getDimension()) return Y def isActingPointwise(self): return True F = FUNC() print('in_dim=' + str(F.getInputDimension()) + ' out_dim=' + str(F.getOutputDimension()) + ' spatial_dim=' + str(F.getInputMesh().getDimension())) X = ot.Field(mesh, ot.Normal(2).getSample(11)) print(F(X.getValues())) Xsample = ot.ProcessSample(5, X) print(F(Xsample)) # Instance creation myFunc = ot.FieldFunction(F) # Copy constructor newFunc = ot.FieldFunction(myFunc) print(('myFunc input dimension= ' + str(myFunc.getInputDimension()))) print(('myFunc output dimension= ' + str(myFunc.getOutputDimension()))) print(myFunc(X.getValues())) print(myFunc(Xsample))
# size of timeGrid size = 6 dimension = 1 sample = ot.Sample(size, dimension) for i in range(size): for j in range(dimension): sample[i, j] = i + j + 1 # TimeGrid timeGrid = ot.RegularGrid(0.0, 1.0 / (size - 1), size) # TimeSeries timeSeries = ot.TimeSeries(timeGrid, sample) # We create an empty ProcessSample with default constructor psample0 = ot.ProcessSample() psample0.setName("PSample0") print("Default constructor") print("psample0=", psample0) # We create an empty ProcessSample with timeGrid, size and dimension # arguments psample1 = ot.ProcessSample(timeGrid, 4, dimension) psample1.setName("PSample1") print("Constructor based on size, dimension and timeGrid") print("psample1=", psample1) # change the first component using operator [] psample1[0] = timeSeries print("changing psample1[0] with []") print("psample1[0]=", (psample1[0]))
def test_ProcessHighDensityRegionAlgorithm(mock_show): ot.RandomGenerator.SetSeed(0) numberOfPointsForSampling = 500 ot.ResourceMap.Set('Distribution-MinimumVolumeLevelSetBySampling', 'true') ot.ResourceMap.Set('Distribution-MinimumVolumeLevelSetSamplingSize', str(numberOfPointsForSampling)) # Dataset fname = os.path.join(os.path.dirname(__file__), 'data', 'npfda-elnino.dat') data = np.loadtxt(fname) # Create the mesh n_nodes = data.shape[1] mesher = ot.IntervalMesher([n_nodes - 1]) Interval = ot.Interval([0.0], [1.0]) mesh = mesher.build(Interval) # Create the ProcessSample from the data n_fields = data.shape[0] dim_fields = 1 sample = ot.ProcessSample(mesh, n_fields, dim_fields) for i in range(n_fields): trajectory = ot.Sample(data[i, :], 1) sample[i] = ot.Field(mesh, trajectory) # Compute HDRPlot hdr = ProcessHighDensityRegionAlgorithm(sample) hdr.setContoursAlpha([0.8, 0.5]) hdr.setOutlierAlpha(0.8) hdr.run() hdr.summary() hdr.dimensionReductionSummary() # Plot ACP graph = hdr.drawDimensionReduction() View(graph) plt.show(graph) # Plot Density fig, axs, graphs = hdr.drawDensity() plt.show() # Plot outlier trajectories graph = hdr.drawOutlierTrajectories(drawInliers=True, discreteMean=True) View(graph) plt.show() graph = hdr.drawOutlierTrajectories(bounds=False) View(graph) plt.show() outlier_indices = hdr.computeOutlierIndices() expected_outlier_indices = [3, 7, 22, 32, 33, 41, 47] assert_equal(outlier_indices, expected_outlier_indices) # Check data assert_equal(hdr.getNumberOfTrajectories(), 54) assert_equal(hdr.getNumberOfVertices(), 12) assert_equal(hdr.getNumberOfComponents(), 2) assert_array_almost_equal(hdr.getPartOfExplainedVariance(), 0.86569783, 4) assert_array_almost_equal(hdr.getExplainedVarianceRatio(), [0.60759627, 0.25810156], 4) # Check higher dimension hdr = ProcessHighDensityRegionAlgorithm(sample, numberOfComponents=3) hdr.setOutlierAlpha(0.6) hdr.run() fig, axs, graphs = hdr.drawDensity() plt.show() fig, axs, graphs = hdr.drawDensity(drawData=True) plt.show()
def _convert_exec_sample_ot(self, output): """Converts the output of the batch function passed to the class into a basic openturns object, and makes some checks on the dimensions. Note ---- If the checks fail, the output can still be found under self.__output_backup__ """ print( '''Using the batch evaluation function. Assumes that the outputs are in the same order than for the single evaluation function. This one should only return ProcessSamples, Samples, Lists or numpy arrays.''') outputList = [] if len(output) != len(self._outputDescription): self.__nOutputs__ = len(output) self.setOutputDescription( ot.Description.BuildDefault(self.__nOutputs__, 'Y_')) for i, element in enumerate(output): if isinstance(element, (ot.Sample, ot.ProcessSample)): element.setName(self._outputDescription[i]) outputList.append(element) print( 'Element {} of the output tuple returns elements of type {} of dimension {}' .format(i, element.__class__.__name__, element.getDimension())) elif isinstance(element, (Sequence, Iterable)): print( 'Element is iterable, assumes that first dimension is size of sample' ) intermElem = CustomList(element) intermElem.recurse2list() shape = intermElem.shape dtype = intermElem.dtype print('Shape is {} and dtype is {}'.format(shape, dtype)) sampleSize = shape[0] subSample = [ CustomList(intermElem[j]) for j in range(sampleSize) ] assert dtype is not None, 'If None the list is not homogenous' if isinstance( dtype(), (Complex, Integral, Real, Rational, Number, str)): if len(shape) >= 2: print( 'Element {} of the output tuple returns process samples of dimension {}' .format(i, len(shape) - 1)) mesh = self._buildMesh(self._getGridShape(shape[1:])) subSample = [ subSample[j].flatten() for j in range(sampleSize) ] procsample = ot.ProcessSample(mesh, 0, len(shape) - 1) for j in range(sampleSize): procsample.add( ot.Field(mesh, [[elem] for elem in subSample[j].data])) procsample.setName(self._outputDescription[i]) outputList.append(procsample) elif len(shape) == 1: print( 'Element {} of the output tuple returns samples of dimension {}' .format(i, 1)) element = ot.Sample([[dat] for dat in intermElem.data]) element.setName(self._outputDescription[i]) outputList.append(element) else: print('Do not use non-numerical dtypes in your objects') print('Wrong dtype is: ', dtype.__name__) elif isinstance(element, ot.Point): print( 'Element {} of the output tuple returns samples of dimension 1' .format(i, type(element).__name__)) element = ot.Sample([[element[j]] for j in range(len(element))]) element.setName(self._outputDescription[i]) outputList.append(element) elif isinstance(element, ot.Field): print( 'ONLY _exec_sample FUNCTION MUST RETURN ot.Sample OR ot.ProcessSample OBJECTS!!' ) raise TypeError else: print('Element is {} of type {}'.format( element, element.__class__.__name__)) raise NotImplementedError return outputList
def draw(self, drawInliers=False, drawOutliers=True, discreteMean=False, bounds=True): """ Plot outlier trajectories based on HDR. Parameters ---------- drawInliers : bool If True, plots the inlier curves. drawOutliers : bool If True, draw the outliers curves. discreteMean : bool If False, the central curve is the curve in the process sample which has highest density. If True, the central curve is the mean of the process sample. bounds : bool If True, plots the bounds of the confidence interval. These bounds are made of the mininimum and maximum at each time. Returns ------- graph : ot.Graph The plot of outlier trajectories. """ outlierAlpha = self.getOutlierAlpha() graph = ot.Graph( r"Outliers at $\alpha$=%.2f" % (outlierAlpha), "", "", True, "topright", ) # Get the mesh mesh = self.processSample.getMesh() t = np.ravel(mesh.getVertices()) # Plot outlier trajectories outlier_indices = self.computeIndices() if len(outlier_indices) > 0: outlier_process_sample = ot.ProcessSample(mesh, len(outlier_indices), 1) index = 0 for i in outlier_indices: outlier_process_sample[index] = self.processSample[i] index += 1 if drawOutliers: outlier_graph = outlier_process_sample.drawMarginal(0) outlier_graph.setColors([self.outlier_color]) graph.add(outlier_graph) # Plot inlier trajectories inlier_indices = self.computeIndices(False) if len(inlier_indices): inlier_process_sample = ot.ProcessSample(mesh, len(inlier_indices), 1) index = 0 for i in inlier_indices: inlier_process_sample[index] = self.processSample[i] index += 1 if drawInliers: inlier_graph = inlier_process_sample.drawMarginal(0) inlier_graph.setColors([self.inlier_color]) graph.add(inlier_graph) # Plot inlier bounds def fill_between(lower, upper, legend, color): """Draw a shaded area between two curves.""" disc = len(lower) poly_data = [[lower[i], lower[i + 1], upper[i + 1], upper[i]] for i in range(disc - 1)] polygon = [ ot.Polygon(poly_data[i], color, color) for i in range(disc - 1) ] bounds_poly = ot.PolygonArray(polygon) bounds_poly.setLegend(legend) return bounds_poly if bounds: inlier_min = inlier_process_sample.computeQuantilePerComponent(0.0) inlier_max = inlier_process_sample.computeQuantilePerComponent(1.0) min_values = inlier_min.getValues() max_values = inlier_max.getValues() nbVertices = mesh.getVerticesNumber() lower_bound = [[t[i], min_values[i, 0]] for i in range(nbVertices)] upper_bound = [[t[i], max_values[i, 0]] for i in range(nbVertices)] outlierAlpha = np.max(self.alphaLevels) bounds = fill_between( lower_bound, upper_bound, r"Conf. interval at $\alpha$=%.2f" % (outlierAlpha), self.confidence_band_color, ) graph.add(bounds) # Plot central curve if discreteMean: central_field = self.processSample.computeMean() else: mode_index = self.getMode() central_field = self.processSample[mode_index] curve = ot.Curve(t[:, None], central_field, "Central curve") curve.setColor(self.central_color) graph.add(curve) return graph
mesh = ot.RegularGrid(0.0, 1.0, 4) values = ot.Sample([[0.5], [1.5], [1.0], [-0.5]]) field = ot.Field(mesh, values) evaluation = ot.P1LagrangeEvaluation(field) x = [2.3] y = evaluation(x) print(y) ott.assert_almost_equal(y, [0.55]) # Learning sample on meshD mesher = ot.IntervalMesher([7, 7]) lowerbound = [-1.0, -1.0] upperBound = [1, 1] interval = ot.Interval(lowerbound, upperBound) meshD = mesher.build(interval) sample = ot.ProcessSample(meshD, 10, 1) field = ot.Field(meshD, 1) for k in range(sample.getSize()): field.setValues(ot.Normal().getSample(64)) sample[k] = field lagrange = ot.P1LagrangeEvaluation(sample) # New mesh mesh = ot.Mesh( ot.MonteCarloExperiment(ot.ComposedDistribution([ot.Uniform(-1, 1)] * 2), 200).generate()) point = mesh.getVertices()[0] y = lagrange(point) print(y) index = lagrange.getEnclosingSimplexAlgorithm().query(point) print(index)
def test_ProcessHighDensityRegionAlgorithm(mock_show): ot.RandomGenerator.SetSeed(0) numberOfPointsForSampling = 500 ot.ResourceMap.Set('Distribution-MinimumVolumeLevelSetBySampling', 'true') ot.ResourceMap.Set('Distribution-MinimumVolumeLevelSetSamplingSize', str(numberOfPointsForSampling)) # fname = os.path.join(os.path.dirname(__file__), 'data', 'npfda-elnino.dat') dataR = np.loadtxt(fname) # Create the mesh numberOfNodes = dataR.shape[1] myMesher = ot.IntervalMesher([numberOfNodes - 1]) myInterval = ot.Interval([0.0], [1.0]) myMesh = myMesher.build(myInterval) # Create the ProcessSample from the data numberOfFields = dataR.shape[0] dimensionOfFields = 1 myps = ot.ProcessSample(myMesh, numberOfFields, dimensionOfFields) for i in range(numberOfFields): thisTrajectory = ot.Sample(dataR[i, :], 1) myps[i] = ot.Field(myMesh, thisTrajectory) # Compute HDRPlot myhdrplot = ProcessHighDensityRegionAlgorithm(myps) myhdrplot.setContoursAlpha([0.8, 0.5]) myhdrplot.setOutlierAlpha(0.8) myhdrplot.run() myhdrplot.summary() myhdrplot.dimensionReductionSummary() # Plot ACP myhdrplot.plotDimensionReduction() plt.show() # Plot Density plotData = True plotOutliers = True myhdrplot.plotDensity(plotData, plotOutliers) plt.show() # Plot trajectories myhdrplot.plotTrajectories() plt.show() # Plot outlier trajectories myhdrplot.plotOutlierTrajectories() plt.show() outlierIndices = myhdrplot.computeOutlierIndices() expected_outlierIndices = [3, 7, 22, 32, 33, 41, 47] assert_equal(outlierIndices, expected_outlierIndices) # Check data assert_equal(myhdrplot.getNumberOfTrajectories(), 54) assert_equal(myhdrplot.getNumberOfVertices(), 12) assert_equal(myhdrplot.getNumberOfComponents(), 2) assert_array_almost_equal(myhdrplot.getPartOfExplainedVariance(), 0.86569783, 4) assert_array_almost_equal(myhdrplot.getExplainedVarianceRatio(), [0.60759627, 0.25810156], 4)
# First, define a regular 2-d mesh discretization = [10, 5] mesher = ot.IntervalMesher(discretization) lowerBound = [0.0, 0.0] upperBound = [2.0, 1.0] interval = ot.Interval(lowerBound, upperBound) mesh = mesher.build(interval) mesh = ot.RegularGrid(0.0, 0.01, 100) graph = mesh.draw() view = viewer.View(graph) # %% # Allocate a process sample from a field field = ot.Field() sampleSize = 10 processSample = ot.ProcessSample(sampleSize, field) #field.draw() # %% # Create a process sample as realizations of a process amplitude = [1.0] scale = [0.2] * 1 myCovModel = ot.ExponentialModel(scale, amplitude) myProcess = ot.GaussianProcess(myCovModel, mesh) processSample = myProcess.getSample(10) #processSample # %% # draw the sample, without interpolation graph = processSample.drawMarginal(0, False) view = viewer.View(graph)