I don’t know if you’re able to achieve that with Clonable, in my code I just handle cloning myself using save / load, e.g.:
class IArchitecture : public torch::nn::Module
{
public:

	virtual torch::Tensor forward(torch::Tensor x) = 0;
	
	virtual void reset_parameters() = 0;

	virtual std::shared_ptr<IArchitecture> custom_clone() = 0;
};

typedef std::shared_ptr<IArchitecture> IArchitecturePtr;

template<class C>
struct IArchitectureClonable : public IArchitecture
{
	virtual std::shared_ptr<IArchitecture> custom_clone() override
	{
		auto retval = std::make_shared<C>();

		std::string data;

		{
			std::ostringstream oss;
			torch::serialize::OutputArchive archive;

			this->save(archive);
			archive.save_to(oss);
			data = oss.str();
		}

		{
			std::istringstream iss(data);
			torch::serialize::InputArchive archive;
			archive.load_from(iss);
			retval->load(archive);
		}
		
		return retval;
	}
};

class SimpleMLPImpl : public IArchitectureClonable<SimpleMLPImpl>
{
public:
	torch::nn::Linear fc1{ nullptr };
	torch::nn::Linear fc2{ nullptr };

	SimpleMLPImpl()
	{
		fc1 = register_module("fc1", torch::nn::Linear(32, 64));
		fc2 = register_module("fc2", torch::nn::Linear(64, 1));
	}

	virtual torch::Tensor forward(torch::Tensor x) override
	{
		x = torch::leaky_relu(fc1->forward(x));
		return fc2->forward(x);
	}
	
	void reset_parameters() override
	{
		fc1->reset_parameters();
		fc2->reset_parameters();
	}
};

void main(int argc, char** argv)
{
	try
	{
		IArchitecturePtr model = std::make_shared<SimpleMLPImpl>();
		IArchitecturePtr cloned = model->custom_clone();
				
		auto testInput = torch::randn({ 1, 32 });

		// same output of both clone and original
		std::cout << model->forward(testInput) << std::endl;
		std::cout << cloned->forward(testInput) << std::endl;

		// reset parameters of original model
		model->reset_parameters();

		// different output
		std::cout << model->forward(testInput) << std::endl;
		std::cout << cloned->forward(testInput) << std::endl;
	}
	catch (std::runtime_error& e)
	{
		std::cout << e.what() << std::endl;
	}
	catch (const c10::Error& e)
	{
		std::cout << e.msg() << std::endl;
	}

	system("PAUSE");
}