MATL, 7 characters

Btnwdz/

Try it online!

Explanation

B    % Convert to binary

t    % Duplicate

n    % Number of elements

w    % Swap

d    % Consecutive differences

z    % Number of nonzeros

/    % Divide

Jelly, 8 bytes, score 8

_{Maybe there is a terser way... edit: I don't think there is.}

BL÷BITLƲ

Infinity is given as inf.

Try it online!

...other 8's are possible too, for example BµITL÷@L or BL÷BnƝSƊ.

05AB1E, 8 bytes/characters

bgIbγg</

Try it online or verify all test cases.

Or alternatively:

b©g®¥ÄO/

Try it online or verify all test cases.

Outputs 0.0 for the INF cases.

With both bonuses score: 11.97 (18 bytes/characters * 0.95 * 0.7):

εbgybγg</3.ò}DÆ.±)

Outputs 1 if the first input is larger than the second; -1 if vice-versa; 0 if they are equal.

NOTE: Because I output 0.0 for the INF cases, they are considered lower than non-infinity test cases. Let me know if this has to be fixed..

Try it online.

Explanation:

ε       # Map both values of the (implicit) input-list:

 b      #  Get the binary-string of the current value

  g     #  And get the length of this string

 yb     #  Get the binary-string of the current value again

   γ    #  Split it into chunks of equal adjacent digits

    g<  #  Get the amount of chunks, and subtract 1

 /      #  Divide both numbers

 3.ò    #  Round the number to 3 decimal values

}D      # After the map: duplicate the resulting list

  Æ     # Reduce the duplicated list by subtraction

   .±   # And get the sign of that result

     )  # Then wrap it into a list with the mapped values

        # (and output the result implicitly)

Japt, 8 bytes

NULL for infinity

¤Ê/¢ä¦ x

Try it online!

JavaScript (ES6),  46 44  40 bytes / characters

Returns Infinity if there's no bit flip.

n=>(g=s=>n&&1+g(x=s-(n^(n>>=1))%2))``/~x

Try it online!

Commented

n => (                  // n = input integer

  g = s =>              // g = recursive function taking the number s of bit switches

    n &&                //   stop if n is equal to 0

    1 +                 //   otherwise, add 1 to the final returned value

    g(                  //   and do a recursive call to g:

      x =               //     update s and save the result in x:

        s -             //       subtract 1 from s if ...

        (n ^ (n >>= 1)) //       ... there is a bit switch; and shift n to the right

        % 2             //       NB: an extra bit switch is counted on the last bit

    )                   //   end of recursive call

)``                     // initial call to g with s = [''], which is coerced to 0

                        // as soon as something is subtracted from it

/ ~x                    // divide the result of g by -(x + 1), which compensates for

                        // the extra switch

Kotlin, 83 82 bytes

{s->s.toString(2).run{length.toFloat()/(0..length-2).count{this[it]!=this[it+1]}}}

Try it online!

1. Python 3, 123 bytes (146 with file header)

Hi. I know that my code is way longer than others, but I will try it ;)

Script takes sequence of numbers in aguments and prints "smoothness" for each argument on own line. If number of changes is 0, prints "inf".

$ ./script.py 12

4.0



$ ./script.py 12 5 6

4.0

1.5

3.0



$ ./script.py `seq 5`

None

2.0

None

3.0

1.5

file header

#!/usr/bin/env python3

code

for n in argv[1:]:

    b=bin(int(n))[2:];c=0;l=b[0]

    for o in b:

        if o!=l:c+=1

        l=o

    print(len(b)/c if c>0 else"inf")

R, 56 bytes

length(y<-(x=scan())%/%2^(0:log2(x))%%2)/sum(diff(y)!=0)

Try it online!

Charcoal, 24 characters

≔⍘Ｎ²θ≔⁺№θ10№θ01η¿ηＩ∕Ｌθη∞

Try it online! Link is to verbose version of code. Explanation:

≔⍘Ｎ²θ

Input the number and convert it to base 2 as a string.

≔⁺№θ10№θ01η

Calculate the number of of switches by counting the occurrences of 10 or 01 in the string.

¿ηＩ∕Ｌθη∞

If the total is nonzero then output the smoothness otherwise print Infinity.