FWIW, I've experimented with XML::Simple for a couple of hours now, and, as far as I can see, SuppressEmpty doesn't work in this situation. I get the same results with or without it.

#!/usr/bin/perl -l

use strict;
use warnings;
use Data::Dumper::Concise;
use Data::Serializer::Raw;
use XML::Simple qw(:strict);

my $file = '/root/Desktop/xml2.xml';
    
open my $xml, '<', $file or die $!;
binmode $xml, ":encoding(UTF-8)";

my $ref = XMLin(
    $xml,
    SuppressEmpty => undef,
    KeyAttr    => { set => 'name' },
    ForceArray => [ 'set' ],
    ContentKey => 'content',
);
    
my $xml_raw_serializer = Data::Serializer::Raw->new(
    serializer => 'XML::Dumper'
);
my $xml_data = $xml_raw_serializer->serialize($ref);
print Dumper($xml_raw_serializer->deserialize($xml_data));
close $xml;
[download]

XML::Simple can't do what you want there. The SuppressEmpty option is almost what you want except it won't apply in your case because the element will contain name => 'set' and won't be considered empty. Later on, the array folding will cause that attribute to be deleted but by that stage it's too late for the SuppressEmpty check.

The issue is that as soon as you start supporting multiple options, the order in which those options are applied begins to matter.

I'd just use XML::LibXML.

Is this what you want ?

                     {
                       'class' => 'myclass',
                       'set' => {
                                'key2' => 'b',
                                'key1' => 'a'
                              }
                     }
[download]

XML::Rules is simpler than XML::Simple, you start with xml2XMLRules, and you tweak it a little

#!/usr/bin/perl --
#~ 2012-05-02-20:44:05 by Anonymous Monk
#~ perltidy -csc -otr -opr -ce -nibc -i=4     
use strict; use warnings;
use XML::Rules;
use Data::Dump qw/ dd /;

Main( @ARGV );
exit( 0 );

sub Main {
    my $t = XML::Rules->new(
        qw/ stripspaces 8 /,
        rules => [
            'obj'   => 'as array no content',
            'stuff' => 'no content',
            
#~             'set'   => 'as array', # original from xml2XMLRules
            'set' => sub {
                
#~ $rule->( $tag_name, \%attrs, \@context, \@parent_data, $parser)
#~ my ($tagname, $attrHash, $contexArray, $parentDataArray, $parser) =
+ @_;
                '%set', { $_[1]->{name} => $_[1]->{_content} };
            },
        ],
    );

    my $res = $t->parse( MyXml() );
    dd $res;
} ## end sub Main

sub MyXml {
    q{<stuff name="me">
    <obj class="myclass">
        <set name="key1">a</set>
        <set name="key2"></set>
    </obj>
    <obj class="myclass">
        <set name="key1">a</set>
        <set name="key2">b</set>
    </obj>
</stuff>
};
} ## end sub MyXml
__END__
{
  stuff => {
    name => "me",
    obj  => [
              { class => "myclass", set => { key1 => "a", key2 => unde
+f } },
              { class => "myclass", set => { key1 => "a", key2 => "b" 
+} },
            ],
  },
}
[download]

All of the comments have either been: "that option doesn't do it", or "use a different module". Nobody managed to suggest either a fix/change for XML::Simple, or a set of options I can use that causes XML::Simple to become 'self-consistent' when dealing with partial content.

So in the end, I wrote a small post-processing routine to normalize the output from XMLin(). I.e recurse through the structure and a) promote leafs that are empty hashes to empty values.

 { } to  ''

and b) hashes that contain only the single 'content' entry into simply the value:

 { content => 'xxx' } to  'xxx'

Now I consistently get what I expected regardless of data content.

$VAR1 = \{
            'obj' => [
                     {
                       'class' => 'myclass',
                       'set' => {
                                'key2' => '',
                                'key1' => 'a'
                              }
                     },
                     {
                       'class' => 'myclass',
                       'set' => {
                                'key2' => 'b',
                                'key1' => 'a'
                              }
                     }
                   ],
            'name' => 'me'
          };
[download]

sub reduce {
  my ($ref) = @_;

  if (ref($ref) eq 'REF') {       # recurse into references...
    $$ref = reduce($$ref);
  } elsif (UNIVERSAL::isa($ref, 'HASH')) {
    my @keys = keys %$ref;
    if (scalar (@keys) == 0) {    # empty hash becomes an empty string
      return '';
    } elsif (scalar (@keys) == 1 && $keys[0] eq 'content') {
      $ref = $ref->{$keys[0]};    # 'content'-only becomes the value
    } else {
      foreach (keys %$ref) {      # recurse into multi-element hashes
        $ref->{$_} = reduce($ref->{$_});
      }
    }
  } elsif (UNIVERSAL::isa($ref, 'ARRAY')) {
    foreach (@$ref) {             # recurse into arrays
      reduce($_);
    }
  }
  return $ref;
}
[download]

So in the end, I wrote a small post-processing routine to normalize the output from XMLin().

Eeeew :) The worst of all options, why so anchored to XML::Simple? Don't you like steriods? XML::Rules is XML::Simple on steriods :)