rabbits population simulation

Author: slanj

ml/FuelConsumption.csv

@@ -0,0 +1,55 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+import pylab as pl
+import numpy as np
+
+df = pd.read_csv("FuelConsumption.csv")
+
+# take a look at the dataset
+# print(df.head())
+
+# # summarize the data
+# print(df.describe())
+
+cdf = df[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_COMB','CO2EMISSIONS']]
+# cdf.head(9)
+
+viz = cdf[['CYLINDERS','ENGINESIZE','CO2EMISSIONS','FUELCONSUMPTION_COMB']]
+# viz.hist()
+# plt.show()
+
+# plt.scatter(cdf.CYLINDERS, cdf.CO2EMISSIONS, color='blue')
+# plt.xlabel("Cylinders")
+# plt.ylabel("Emission")
+# plt.show()
+
+msk = np.random.rand(len(df)) < 0.8
+train = cdf[msk]
+test = cdf[~msk]
+
+from sklearn import linear_model
+regr = linear_model.LinearRegression()
+train_x = np.asanyarray(train[['ENGINESIZE']])
+train_y = np.asanyarray(train[['CO2EMISSIONS']])
+regr.fit (train_x, train_y)
+# The coefficients
+print ('Coefficients: ', regr.coef_)
+print ('Intercept: ',regr.intercept_)
+
+# plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS,  color='blue')
+# plt.plot(train_x, regr.coef_[0][0]*train_x + regr.intercept_[0], '-r')
+# plt.xlabel("Engine size")
+# plt.ylabel("Emission")
+# plt.show()
+
+from sklearn.metrics import r2_score
+
+test_x = np.asanyarray(test[['ENGINESIZE']])
+test_y = np.asanyarray(test[['CO2EMISSIONS']])
+test_y_ = regr.predict(test_x)
+
+print("Mean absolute error: %.2f" % np.mean(np.absolute(test_y_ - test_y)))
+print("Residual sum of squares (MSE): %.2f" % np.mean((test_y_ - test_y) ** 2))
+print("R2-score: %.2f" % r2_score(test_y_ , test_y) )
+
+

ml/r2.py

@@ -0,0 +1,45 @@
+import numpy as np
+
+def find_combination(choices, total):
+    """
+    choices: a non-empty list of ints
+    total: a positive int
+
+    Returns result, a numpy.array of length len(choices)
+    such that
+        * each element of result is 0 or 1
+        * sum(result*choices) == total
+        * sum(result) is as small as possible
+    In case of ties, returns any result that works.
+    If there is no result that gives the exact total,
+    pick the one that gives sum(result*choices) closest
+    to total without going over.
+    """
+    numbered = {}
+    for i in range(len(choices)):
+        numbered[i] = [choices[i], 0]
+    choices = sorted(choices)
+    temp = 0
+    taken = []
+    for i in range(len(choices)-1, -1, -1):
+        if temp + choices[i] <= total:
+            temp += choices[i]
+            taken.append(choices[i])
+    positions = []
+    for t in taken:
+        for n in numbered.keys():
+            if numbered[n][0] == t and numbered[n][1] == 0:
+                positions.append(n)
+                numbered[n][1] = 1
+                break
+    result = []
+    for i in range(len(choices)):
+        if i in positions:
+            result.append(1)
+        else:
+            result.append(0)
+
+    return np.array(result)
+
+results = find_combination([10, 10, 11, 11, 11], 20)
+print(results)

optimization/find_combination.py

@@ -16,5 +16,22 @@ def noReplacementSimulation(numTrials):
             same_color += 1
     return same_color/numTrials
 
-print(noReplacementSimulation(11142))
+def drawing_without_replacement_sim(numTrials):
+    '''
+    Runs numTrials trials of a Monte Carlo simulation
+    of drawing 3 balls out of a bucket containing
+    4 red and 4 green balls. Balls are not replaced once
+    drawn. Returns a float - the fraction of times 3
+    balls of the same color were drawn in the first 3 draws.
+    '''
+    balls = [1, 0, 1, 0, 1, 0, 1, 0]
+    same_color = 0
+    for trial in range(numTrials):
+        choice = sum(random.sample(balls, 3))
+        if choice == 3 or choice == 0:
+            same_color += 1
+    return same_color/numTrials
+
+print("Fraction from 6 balls: ",  noReplacementSimulation(11142))
+print("Fraction from 8 balls: ",  drawing_without_replacement_sim(11142))
 

stats/balls.py

@@ -0,0 +1,11 @@
+import pylab as plt
+import numpy as np
+
+a = np.random.normal(10, 3, 1000)
+b = np.random.normal(10, 5, 1000)
+plt.figure('a')
+plt.hist(a, 10)
+
+plt.figure('b')
+plt.hist(b, 10)
+plt.show()

stats/d2.py

@@ -0,0 +1,17 @@
+import random, pylab
+xVals = []
+yVals = []
+wVals = []
+for i in range(1000):
+    xVals.append(random.random())
+    yVals.append(random.random())
+    wVals.append(random.random())
+xVals = pylab.array(xVals)
+yVals = pylab.array(yVals)
+wVals = pylab.array(wVals)
+xVals = xVals + xVals
+zVals = xVals + yVals
+tVals = xVals + yVals + wVals
+
+pylab.plot(sorted(xVals), sorted(yVals))
+pylab.show()

stats/d3.py

@@ -0,0 +1,85 @@
+import random, pylab
+import numpy as np
+
+# You are given this function
+def getMeanAndStd(X):
+    mean = sum(X)/float(len(X))
+    tot = 0.0
+    for x in X:
+        tot += (x - mean)**2
+    std = (tot/len(X))**0.5
+    return mean, std
+
+# You are given this class
+class Die(object):
+    def __init__(self, valList):
+        """ valList is not empty """
+        self.possibleVals = valList[:]
+    def roll(self):
+        return random.choice(self.possibleVals)
+
+# Implement this -- Coding Part 1 of 2
+def makeHistogram(values, numBins, xLabel, yLabel, title=None):
+    """
+      - values, a sequence of numbers
+      - numBins, a positive int
+      - xLabel, yLabel, title, are strings
+      - Produces a histogram of values with numBins bins and the indicated labels
+        for the x and y axis
+      - If title is provided by caller, puts that title on the figure and otherwise
+        does not title the figure
+    """
+    if title != None:
+        pylab.title(title)
+
+    pylab.xlabel(xLabel)
+    pylab.ylabel(yLabel)
+    pylab.hist(values, numBins)
+    pylab.show()
+
+
+# Implement this -- Coding Part 2 of 2
+def getAverage(die, numRolls, numTrials):
+    """
+      - die, a Die
+      - numRolls, numTrials, are positive ints
+      - Calculates the expected mean value of the longest run of a number
+        over numTrials runs of numRolls rolls.
+      - Calls makeHistogram to produce a histogram of the longest runs for all
+        the trials. There should be 10 bins in the histogram
+      - Choose appropriate labels for the x and y axes.
+      - Returns the mean calculated
+    """
+    values = []
+    longest = []
+    for trial in range(numTrials):
+        for roll in range(numRolls):
+            values.append(die.roll())
+        temp = values[0]
+        count = 1
+        maxCount = 1
+        for i in range(len(values)-1):
+            if temp == values[i+1]:
+                count += 1
+            else:
+                temp = values[i+1]
+                count = 1
+
+            if count > maxCount:
+                maxCount = count
+        longest.append(maxCount)
+        values = []
+
+    makeHistogram(longest, 10, "Mean of runs", "Longest runs")
+
+    return round(getMeanAndStd(longest)[0], 3)
+
+
+
+
+# a = np.random.normal(10, 5, 100)
+# makeHistogram(a, 10, "X", "Y", "Graphik")
+
+
+# One test case
+print(getAverage(Die([1,2,3,4,5,6,6,6,7]), 500, 10000))

stats/die.py

@@ -0,0 +1,93 @@
+import random
+import pylab
+
+# Global Variables
+MAXRABBITPOP = 1000
+CURRENTRABBITPOP = 50
+CURRENTFOXPOP = 300
+
+def rabbitGrowth():
+    """
+    rabbitGrowth is called once at the beginning of each time step.
+
+    It makes use of the global variables: CURRENTRABBITPOP and MAXRABBITPOP.
+
+    The global variable CURRENTRABBITPOP is modified by this procedure.
+
+    For each rabbit, based on the probabilities in the problem set write-up,
+      a new rabbit may be born.
+    Nothing is returned.
+    """
+    # you need this line for modifying global variables
+    global CURRENTRABBITPOP
+
+    if CURRENTRABBITPOP >= 10:
+        for rabbit in range(CURRENTRABBITPOP):
+            if (1.0 - (CURRENTRABBITPOP / MAXRABBITPOP)) > random.random():
+                CURRENTRABBITPOP += 1
+
+def foxGrowth():
+    """
+    foxGrowth is called once at the end of each time step.
+
+    It makes use of the global variables: CURRENTFOXPOP and CURRENTRABBITPOP,
+        and both may be modified by this procedure.
+
+    Each fox, based on the probabilities in the problem statement, may eat
+      one rabbit (but only if there are more than 10 rabbits).
+
+    If it eats a rabbit, then with a 1/3 prob it gives birth to a new fox.
+
+    If it does not eat a rabbit, then with a 1/10 prob it dies.
+
+    Nothing is returned.
+    """
+    # you need these lines for modifying global variables
+    global CURRENTRABBITPOP
+    global CURRENTFOXPOP
+
+    for fox in range(CURRENTFOXPOP):
+        if CURRENTRABBITPOP > 10:
+            if (CURRENTRABBITPOP / MAXRABBITPOP) > random.random():
+                CURRENTRABBITPOP -= 1
+                if (1/3.0) >= random.random():
+                    CURRENTFOXPOP += 1
+            else:
+                if 0.1 >= random.random() and CURRENTFOXPOP > 10:
+                    CURRENTFOXPOP -= 1
+
+def runSimulation(numSteps):
+    """
+    Runs the simulation for `numSteps` time steps.
+
+    Returns a tuple of two lists: (rabbit_populations, fox_populations)
+      where rabbit_populations is a record of the rabbit population at the
+      END of each time step, and fox_populations is a record of the fox population
+      at the END of each time step.
+
+    Both lists should be `numSteps` items long.
+    """
+    rabbit_populations = []
+    fox_populations = []
+
+    for step in range(numSteps):
+        rabbitGrowth()
+        foxGrowth()
+        rabbit_populations.append(CURRENTRABBITPOP)
+        fox_populations.append(CURRENTFOXPOP)
+
+    rabbit_coeff = pylab.polyfit(range(len(rabbit_populations)), rabbit_populations, 2)
+    fox_coeff = pylab.polyfit(range(len(fox_populations)), fox_populations, 2)
+
+    pylab.plot(pylab.polyval(rabbit_coeff, range(len(rabbit_populations))))
+    pylab.plot(pylab.polyval(fox_coeff, range(len(fox_populations))))
+
+    pylab.plot(rabbit_populations, 'g')
+    pylab.plot(fox_populations, 'r')
+    pylab.show()
+
+    return (rabbit_populations, fox_populations)
+
+
+
+runSimulation(200)