10 examples of 'linear regression in machine learning' in Python

94
def Logistic_Regression(X,Y,alpha,theta,num_iters):
95
	m = len(Y)
96
	for x in xrange(num_iters):
97
		new_theta = Gradient_Descent(X,Y,theta,m,alpha)
98
		theta = new_theta
99
		if x % 100 == 0:
100
			Cost_Function(X,Y,theta,m)
101
			print 'theta ', theta	
102
			print 'cost is ', Cost_Function(X,Y,theta,m)
103
	Declare_Winner(theta)

80
def Linear_regression():
81
    # get train data
82
    data =np.loadtxt('data.csv',delimiter=',')
83
84
    #define hyperparamters
85
    #learning_rate is used for update gradient
86
    #defint the number that will iteration
87
    # define  y =mx+b
88
    learning_rate = 0.001
89
    initial_b =0.0
90
    initial_m = 0.0
91
    num_iter = 1000
92
93
    #train model
94
    #print b m error
95
    print 'initial variables:\n initial_b = {0}\n intial_m = {1}\n error of begin = {2} \n'\
96
        .format(initial_b,initial_m,compute_error(initial_b,initial_m,data))
97
98
    #optimizing b and m
99
    [b ,m] = optimizer(data,initial_b,initial_m,learning_rate,num_iter)
100
101
    #print final b m error
102
    print 'final formula parmaters:\n b = {1}\n m={2}\n error of end = {3} \n'.format(num_iter,b,m,compute_error(b,m,data))
103
104
    #plot result
105
    plot_data(data,b,m)

89
def logistic_regression(w, x):
90
    """Logistic regression classifier model.
91
92
    w: Weights w. (n_features,) NumPy array
93
    x: Data point x_i. (n_features,) NumPy array
94
    -> float in [0, 1]
95
    """
96
    return scipy.special.expit(numpy.dot(x, w.T))

64
def logistic_regression(opytimizer):
65
    # Instanciating the model
66
    model = torch.nn.Sequential()
67
68
    # Some model parameters
69
    n_features = 64
70
    n_classes = 10
71
72
    # Adding linear layer
73
    model.add_module("linear", torch.nn.Linear(
74
        n_features, n_classes, bias=False))
75
76
    # Input variables
77
    batch_size = 100
78
    epochs = 100
79
80
    # Gathering parameters from Opytimizer
81
    # Pay extremely attention to their order when declaring due to their bounds
82
    learning_rate = opytimizer[0][0]
83
    momentum = opytimizer[1][0]
84
85
    # Declaring the loss function
86
    loss = torch.nn.CrossEntropyLoss(reduction='mean')
87
88
    # Declaring the optimization algorithm
89
    opt = optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)
90
91
    # Performing training loop
92
    for _ in range(epochs):
93
        # Initial cost as 0.0
94
        cost = 0.0
95
96
        # Calculating the number of batches
97
        num_batches = len(X_train) // batch_size
98
99
        # For every batch
100
        for k in range(num_batches):
101
            # Declaring initial and ending for each batch
102
            start, end = k * batch_size, (k + 1) * batch_size
103
104
            # Cost will be the loss accumulated from model's fitting
105
            cost += fit(model, loss, opt,
106
                        X_train[start:end], Y_train[start:end])
107
108
    # Predicting samples from evaluating set
109
    preds = predict(model, X_val)
110
111
    # Calculating accuracy
112
    acc = np.mean(preds == Y_val)
113
114
    return 1 - acc

158
def logistic_regression_3(X, y, max_iter : int = 100, learning_rate : float = 0.1):
159
    W = np.zeros((np.size(X, 1), np.size(y, 1)))
160
    for _ in range(max_iter):
161
        N = len(y)
162
        index = np.random.permutation(N)
163
        X = X[index]
164
        y = y[index]
165
        W_prev = np.copy(W)
166
        y_pred = softmax(X[0:10][:] @ W)
167
        grad = X[0:10][:].T @ (y_pred - y[0:10])
168
        W -= learning_rate * grad
169
        if np.allclose(W, W_prev):
170
            break
171
    return W

99
def test (self) :
100
    for t in self.test_cases :
101
        h = self.__hypothesis ( t[0:-1] )
102
        print "H = %lf, ANS = %d" % ( h, t[self.__MAX_FEATURE_CNT])

8
def linear_regression(feat1, feat2):
9
    return random.gauss(2 * feat1 + feat2 + 5, 3)

205
def test_predict_2(self):
206
    X = np.array([[3.5]])
207
    m, n = X.shape
208
    intercept = np.ones((m, 1), dtype=np.int64)
209
    X = np.append(intercept, X, axis=1)
210
    theta = np.zeros((n + 1, 1), dtype=np.int64)
211
212
    assert_allclose([[0]],
213
                    predict(X, theta),
214
                    rtol=0, atol=0.001)

187
def linear_regression(x, y):
188
    """
189
    NOTE: Proceed linear regression
190
    Input
191
    - x: 1d timeseries (time)
192
    - y: time varying 2d field (time, lat, lon)
193
    Output
194
    - slope: 2d array, spatial map, linear regression slope on each grid
195
    - intercept: 2d array, spatial map, linear regression intercept on each grid
196
    """
197
    # get original global dimension
198
    lat = y.getLatitude()
199
    lon = y.getLongitude()
200
    # Convert 3d (time, lat, lon) to 2d (time, lat*lon) for polyfit applying
201
    im = y.shape[2]
202
    jm = y.shape[1]
203
    y_2d = y.reshape(y.shape[0], jm * im)
204
    # Linear regression
205
    slope_1d, intercept_1d = np.polyfit(x, y_2d, 1)
206
    # Retreive to cdms2 variabile from numpy array
207
    slope = MV2.array(slope_1d.reshape(jm, im))
208
    intercept = MV2.array(intercept_1d.reshape(jm, im))
209
    # Set lat/lon coordinates
210
    slope.setAxis(0, lat)
211
    slope.setAxis(1, lon)
212
    slope.mask = y.mask
213
    intercept.setAxis(0, lat)
214
    intercept.setAxis(1, lon)
215
    intercept.mask = y.mask
216
    # return result
217
    return slope, intercept

101
def run_logistic_regression(df):
102
    # Logistic regression
103
    X = df['pageviews_cumsum']
104
    X = sm.add_constant(X)
105
    y = df['is_conversion']
106
    logit = sm.Logit(y, X)
107
    logistic_regression_results = logit.fit()
108
    print(logistic_regression_results.summary())
109
    return logistic_regression_results