open my $some_filehandle, "<", "quotefile.txt";
my $set_size = 3;

my $set = random_set_of_n($some_filehandle, $set_size);


sub random_set_of_n {
  my ($fh, $size) = @_;
  my @set;

  local ($., $_);
  seek $fh, 0, 0;
  while (<$fh>) { chomp; push @set, $_; last if @set == $size; }
  # XXX: @set *should* be shuffled now if you care about ordering
  while (<$fh>) { chomp; $set[rand @set] = $_ if $size/$. > rand; }
  return \@set;
}
[download]

The fact that your sets are grouped is a great benefit. We can work with a set at a time.

The fact that your sets are of varying length is a great hindrance. Work needs to be done to locate the end of each set.

I made the following assumptions:

• m (and thus j) is rather small. Specifically, keeping m lines in memory is not a problem. ( Confirmed in "Update 2". )
• m is not the same for every set. ( Confirmed in "Update 2". )
• You don't want the same random j lines from every set. It's a minor change if you do.
• You don't care if the random j lines are in their original order. It's a minor change if you do.

My solution:

use strict;
use warnings;

use List::Util qw( shuffle );

my $j = 90;

sub extract_id {
   my ($line) = @_;
   ...
   return ...;
}

my @m;
my $id;
my $last_id;

for (;;) {
   my $line = <DATA>;

   $id = extract_id($line)
      if defined($line);

   if (@m) {
      if (!defined($line) || $id ne $last_id) {
         my $j = $j < @m ? $j : @m;
         print $m[$_] foreach (shuffle(0..$#m))[0..$j-1];
         @m = ();
      }
   }

   last if !defined($line);

   push(@m, $line);
   $last_id = $id;
}
[download]

Untested. (Update: Tested. Fixed. )

Memory can be saved by stored file positions in @m instead of the actual lines, but that's not needed based on your "Update 2".

Alternative:
print splice(@m, rand(@m), 1) while $j--;

Are the lines fixed length? Are there a fixed number of lines per "record"? Is any of this stuff indexed? Is this something that you need to do one off (or occasionally)? Does the "data base" change over time? If it changes can "records" be inserted? Why isn't this in a real database?

Without knowing the answers to any of the above here are a couple of approaches:

• do an indexing pass through the file to build a hash keyed by "person" containing the file position of the start of the record and positions of lines in the record. Seek through the file pulling out randomly selected j lines from each record as required.
• Scan through the file identifying record starts and create an array of lines within the current record. At the end of each record spit out j random lines as required from the array.

The first variant is more appropriate if you want to do this multiple times without the "data base" changing between times - keep the index. The second variant is more appropriate for one off use or if the contents of the "data base" is changing and maintaining an index is not fesable.

Update: s/lones/lines/

This reads $j lines, then skips until $m is reached, then starts reading again. Prints to STDOUT, not to a new file. But that isn't your main concern, is it? ;^).

Update: Oops, missed the "random" bit. Let's try this:

#!/usr/bin/perl

use warnings;
use strict;
use List::Util qw/shuffle/;

my $m = 3;
my $j = 2;

MAIN: while (1) {
        my @set;

        for (my $i = 0; $i < $m ; $i++) {
                last MAIN unless defined ($_ = <DATA>);
                push @set, $_;
        }
        for ((shuffle @set)[0..$j-1]) {
                print;
        }
}

__DATA__
foo 1 2 3
foo 2 3 4
foo 4 5 6
bar a b c
bar b c d
bar c d e
baz q w e
baz w e r
baz e r t
[download]

According to the OP's "Update 2", m is neither neither known nor constant. japhy made the same incorrect assumption above.

See the thread improving the efficiency of a script on taking random samples.

#!/usr/bin/perl

use strict;
use warnings;

my ($fh,$href,$aref,$group,$array);

open($fh,"</tmp/kinput");

$href = {};

while (<$fh>) {
   $aref = [split(/,/,$_)];
   push(@{$$href{$$aref[0]}},$aref);
}

while ( ($group,$array) = each(%$href) ) {
   $aref = $$array[rand($#$array)];
   print join(",",@$aref);
}
[download]