https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Functions
TestStandardizer.C File Reference

Go to the source code of this file.

Functions

 TEST (StochasticTools, getMean)
 
 TEST (StochasticTools, getStandardized)
 
 TEST (StochasticTools, getDestandardized)
 
 TEST (StochasticTools, getDescaled)
 
 TEST (StochasticTools, getScaled)
 
 TEST (StochasticTools, tensorDataStoreLoad)
 
 TEST (StochasticTools, tensorScalarDataStoreLoad)
 
 TEST (StochasticTools, tensorVectorDataStoreLoad)
 
 TEST (StochasticTools, tensorDataStoreLoadNonContiguous)
 
 TEST (StochasticTools, standardizerDataStoreLoad)
 
 TEST (StochasticTools, standardizerEmptyDataStoreLoad)
 

Function Documentation

◆ TEST() [1/11]

TEST ( StochasticTools  ,
getDescaled   
)

Definition at line 73 of file TestStandardizer.C.

74{
75 torch::Tensor input_tensor = torch::tensor({{1.0, -1.0}, {1.0, 1.0}}, {torch::kFloat64});
76 const auto gold = torch::tensor({{0.0, -1.0}, {0.0, 1.0}}, {torch::kFloat64});
77
78 StochasticTools::Standardizer standardizer;
79 standardizer.computeSet(input_tensor);
80 standardizer.getDescaled(input_tensor);
81
82 EXPECT_TRUE(torch::allclose(input_tensor, gold));
83}
StochasticTools::Standardizer
Class for standardizing data (centering and scaling)
Definition Standardizer.h:25
StochasticTools::Standardizer::computeSet
void computeSet(const torch::Tensor &input)
Methods for computing and setting mean and standard deviation.
Definition Standardizer.C:80

◆ TEST() [2/11]

TEST ( StochasticTools  ,
getDestandardized   
)

Definition at line 60 of file TestStandardizer.C.

61{
62 torch::Tensor input_tensor = torch::tensor({{1.0, -1.0}, {-1.0, 1.0}}, {torch::kFloat64});
63 const auto gold = torch::tensor({{1.0, -1.0}, {-1.0, 1.0}}, {torch::kFloat64});
64
65 StochasticTools::Standardizer standardizer;
66 standardizer.computeSet(input_tensor);
67 standardizer.getStandardized(input_tensor);
68 standardizer.getDestandardized(input_tensor);
69
70 EXPECT_TRUE(torch::allclose(input_tensor, gold));
71}

◆ TEST() [3/11]

TEST ( StochasticTools  ,
getMean   
)

Definition at line 20 of file TestStandardizer.C.

21{
22 const std::vector<double> mean_gold = {0.0, -1.0};
23 const std::vector<double> stddev_gold = {1.0, 0.0};
24
25 torch::Tensor input_tensor = torch::tensor(
26 {{1.0, -1.0}, {-1.0, -1.0}, {1.0, -1.0}, {-1.0, -1.0}, {1.0, -1.0}, {-1.0, -1.0}},
27 {torch::kFloat64});
28
29 StochasticTools::Standardizer standardizer;
30 standardizer.computeSet(input_tensor);
31
32 const auto mean = standardizer.getMean();
33 const auto stddev = standardizer.getStdDev();
34
35 ASSERT_EQ(mean.dim(), 1);
36 ASSERT_EQ(stddev.dim(), 1);
37 ASSERT_EQ(static_cast<std::size_t>(mean.size(0)), mean_gold.size());
38 ASSERT_EQ(static_cast<std::size_t>(stddev.size(0)), stddev_gold.size());
39
40 const auto mean_accessor = mean.accessor<Real, 1>();
41 const auto stddev_accessor = stddev.accessor<Real, 1>();
42 for (std::size_t i = 0; i < mean_gold.size(); ++i)
43 EXPECT_EQ(mean_accessor[i], mean_gold[i]);
44 for (std::size_t i = 0; i < stddev_gold.size(); ++i)
45 EXPECT_EQ(stddev_accessor[i], stddev_gold[i]);
46}
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ TEST() [4/11]

TEST ( StochasticTools  ,
getScaled   
)

Definition at line 85 of file TestStandardizer.C.

86{
87 torch::Tensor input_tensor = torch::tensor({{4.0, -8.0}, {-4.0, 8.0}}, {torch::kFloat64});
88 const auto reference = torch::tensor({{2.0, -4.0}, {-2.0, 4.0}}, {torch::kFloat64});
89 const auto gold = torch::tensor({{2.0, -2.0}, {-2.0, 2.0}}, {torch::kFloat64});
90
91 StochasticTools::Standardizer standardizer;
92 standardizer.computeSet(reference);
93 standardizer.getScaled(input_tensor);
94
95 EXPECT_TRUE(torch::allclose(input_tensor, gold));
96}

◆ TEST() [5/11]

TEST ( StochasticTools  ,
getStandardized   
)

Definition at line 48 of file TestStandardizer.C.

49{
50 torch::Tensor input_tensor = torch::tensor({{1.0, -1.0}, {-1.0, 1.0}}, {torch::kFloat64});
51 const auto gold = torch::tensor({{1.0, -1.0}, {-1.0, 1.0}}, {torch::kFloat64});
52
53 StochasticTools::Standardizer standardizer;
54 standardizer.computeSet(input_tensor);
55 standardizer.getStandardized(input_tensor);
56
57 EXPECT_TRUE(torch::allclose(input_tensor, gold));
58}

◆ TEST() [6/11]

TEST ( StochasticTools  ,
standardizerDataStoreLoad   
)

Definition at line 165 of file TestStandardizer.C.

166{
167 torch::Tensor input_tensor =
168 torch::tensor({{3.0, 1.0}, {5.0, -1.0}, {7.0, 3.0}}, {torch::kFloat64});
169
170 StochasticTools::Standardizer stored;
171 stored.computeSet(input_tensor);
172
173 std::stringbuf buffer;
174 std::iostream stream(&buffer);
175 dataStore(stream, stored, nullptr);
176
177 StochasticTools::Standardizer loaded;
178 dataLoad(stream, loaded, nullptr);
179
180 EXPECT_TRUE(torch::allclose(loaded.getMean(), stored.getMean()));
181 EXPECT_TRUE(torch::allclose(loaded.getStdDev(), stored.getStdDev()));
182}
dataLoad
void dataLoad(std::istream &stream, LineSegment &l, void *context)
dataStore
void dataStore(std::ostream &stream, LineSegment &l, void *context)
StochasticTools::Standardizer::getStdDev
const torch::Tensor & getStdDev() const
Get the standard deviation vector.
Definition Standardizer.h:42
StochasticTools::Standardizer::getMean
const torch::Tensor & getMean() const
Get the mean vector.
Definition Standardizer.h:40

◆ TEST() [7/11]

TEST ( StochasticTools  ,
standardizerEmptyDataStoreLoad   
)

Definition at line 184 of file TestStandardizer.C.

185{
186 StochasticTools::Standardizer stored;
187 std::stringbuf buffer;
188 std::iostream stream(&buffer);
189 dataStore(stream, stored, nullptr);
190 StochasticTools::Standardizer loaded;
191 dataLoad(stream, loaded, nullptr);
192}

◆ TEST() [8/11]

TEST ( StochasticTools  ,
tensorDataStoreLoad   
)

Definition at line 98 of file TestStandardizer.C.

99{
100 torch::Tensor stored = torch::tensor({{1.0, 2.0, 3.0}, {-4.0, -5.0, -6.0}}, {torch::kFloat64});
101
102 std::stringbuf buffer;
103 std::iostream stream(&buffer);
104 dataStore(stream, stored, nullptr);
105
106 torch::Tensor loaded;
107 dataLoad(stream, loaded, nullptr);
108
109 ASSERT_EQ(loaded.size(0), stored.size(0));
110 ASSERT_EQ(loaded.size(1), stored.size(1));
111 EXPECT_TRUE(torch::allclose(loaded, stored));
112}

◆ TEST() [9/11]

TEST ( StochasticTools  ,
tensorDataStoreLoadNonContiguous   
)

Definition at line 145 of file TestStandardizer.C.

146{
147 const torch::Tensor base =
148 torch::tensor({{1.0, 2.0, 3.0}, {-4.0, -5.0, -6.0}}, {torch::kFloat64});
149 torch::Tensor stored = torch::transpose(base, 0, 1);
150
151 ASSERT_FALSE(stored.is_contiguous());
152
153 std::stringbuf buffer;
154 std::iostream stream(&buffer);
155 dataStore(stream, stored, nullptr);
156
157 torch::Tensor loaded;
158 dataLoad(stream, loaded, nullptr);
159
160 ASSERT_EQ(loaded.size(0), stored.size(0));
161 ASSERT_EQ(loaded.size(1), stored.size(1));
162 EXPECT_TRUE(torch::allclose(loaded, stored));
163}

◆ TEST() [10/11]

TEST ( StochasticTools  ,
tensorScalarDataStoreLoad   
)

Definition at line 114 of file TestStandardizer.C.

115{
116 torch::Tensor stored = torch::tensor(3.25, {torch::kFloat64});
117
118 std::stringbuf buffer;
119 std::iostream stream(&buffer);
120 dataStore(stream, stored, nullptr);
121
122 torch::Tensor loaded;
123 dataLoad(stream, loaded, nullptr);
124
125 ASSERT_EQ(loaded.dim(), stored.dim());
126 EXPECT_TRUE(torch::allclose(loaded, stored));
127}

◆ TEST() [11/11]

TEST ( StochasticTools  ,
tensorVectorDataStoreLoad   
)

Definition at line 129 of file TestStandardizer.C.

130{
131 torch::Tensor stored = torch::tensor({1.0, -2.0, 3.5, 7.0}, {torch::kFloat64});
132
133 std::stringbuf buffer;
134 std::iostream stream(&buffer);
135 dataStore(stream, stored, nullptr);
136
137 torch::Tensor loaded;
138 dataLoad(stream, loaded, nullptr);
139
140 ASSERT_EQ(loaded.dim(), stored.dim());
141 ASSERT_EQ(loaded.size(0), stored.size(0));
142 EXPECT_TRUE(torch::allclose(loaded, stored));
143}
Generated on Fri Oct 23 2026 20:35:46 for https://mooseframework.inl.gov by doxygen 1.9.8