Spread / Space Out the Values of Perlin Noise - algorithm

Question

I am working to create procedurally generated terrain using Perlin Noise. I have gotten it to work fairly well so far. However, the landscape produced seems more like a swampland with many smaller lakes and very few real oceans.
I currently have the value noise scale value, but it only zooms the map in. Thinking about Perlin Noise like a sin wave, dividing by a value should spread it out more, like increasing the period of the sin wave. However, this is all that happens when I add this and increase that value (period is currently set at 1.25 in this picture):
This is what it looks like if I increase the sea level:
How can I make it so that there are more larger oceans and, or is this simply a bad way of looking at it? Here is my map generation code (as is):
public static float[,] GenerateNoiseMap(int mapWidth, int mapHeight, int seed, float scale, int octaves, float persistance, float lacunarity,
Vector2 offset, NormalizeMode normalizeMode, float normalizationEstimation) {
float[,] noiseMap = new float[mapWidth,mapHeight];
System.Random prng = new System.Random (seed);
Vector2[] octaveOffsets = new Vector2[octaves];
float maxPossibleHeight = 0;
float amplitude = 1;
float frequency = 1;
for (int i = 0; i < octaves; i++) {
float offsetX = prng.Next (-100000, 100000) + offset.x;
float offsetY = prng.Next (-100000, 100000) - offset.y;
octaveOffsets [i] = new Vector2 (offsetX, offsetY);
maxPossibleHeight += amplitude;
amplitude *= persistance;
}
if (scale <= 0) {
scale = 0.0001f;
}
float maxLocalNoiseHeight = float.MinValue;
float minLocalNoiseHeight = float.MaxValue;
float halfWidth = mapWidth / 2f;
float halfHeight = mapHeight / 2f;
for (int y = 0; y < mapHeight; y++) {
for (int x = 0; x < mapWidth; x++) {
amplitude = 1;
frequency = 1;
float noiseHeight = 0;
for (int i = 0; i < octaves; i++) {
float sampleX = (x - halfWidth + octaveOffsets[i].x) / scale * frequency;
float sampleY = (y - halfHeight + octaveOffsets[i].y) / scale * frequency;
float perlinValue = ((Mathf.PerlinNoise (sampleX, sampleY) / period) * 2 - 1);
noiseHeight += perlinValue * amplitude;
amplitude *= persistance;
frequency *= lacunarity;
}
if (noiseHeight > maxLocalNoiseHeight) {
maxLocalNoiseHeight = noiseHeight;
} else if (noiseHeight < minLocalNoiseHeight) {
minLocalNoiseHeight = noiseHeight;
}
noiseMap [x, y] = noiseHeight;
}
}
for (int y = 0; y < mapHeight; y++) {
for (int x = 0; x < mapWidth; x++) {
if (normalizeMode == NormalizeMode.Local) {
noiseMap [x, y] = Mathf.InverseLerp (minLocalNoiseHeight, maxLocalNoiseHeight, noiseMap [x, y]);
} else {
float normalizedHeight = (noiseMap [x, y] + 1) / (2f * maxPossibleHeight / normalizationEstimation);
noiseMap [x, y] = Mathf.Clamp(normalizedHeight, 0, int.MaxValue);
}
}
}
return noiseMap;
}