harveyslash

testing=5

harveyslash

1=a

harveyslash

import java.time.Instant;

public class WarpCLI {
  private static final long START_EPOCH = 885709023L;
  
  public WarpCLI() {}
  
  public static void main(String[] paramArrayOfString) { Instant localInstant1 = Instant.now();
    Instant localInstant2 = Instant.ofEpochSecond(885709023L);
    Instant localInstant3 = localInstant2.plus(1L, java.time.temporal.ChronoUnit.DAYS);

harveyslash

class SiameseNetwork(nn.Module):
    def __init__(self):
        super(SiameseNetwork, self).__init__()
        self.cnn1 = nn.Sequential(
            nn.ReflectionPad2d(1),
            nn.Conv2d(1, 4, kernel_size=3),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(4),
            nn.Dropout2d(p=.2),
            

harveyslash

class ContrastiveLoss(torch.nn.Module):
    """
    Contrastive loss function.
    Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
    """

    def __init__(self, margin=2.0):
        super(ContrastiveLoss, self).__init__()
        self.margin = margin

harveyslash

class SiameseNetworkDataset(Dataset):
    
    def __init__(self,imageFolderDataset,transform=None,should_invert=True):
        self.imageFolderDataset = imageFolderDataset    
        self.transform = transform
        self.should_invert = should_invert
        
    def __getitem__(self,index):
        img0_tuple = random.choice(self.imageFolderDataset.imgs)
        #we need to make sure approx 50% of images are in the same class

harveyslash

net = SiameseNetwork().cuda()
criterion = ContrastiveLoss()
optimizer = optim.Adam(net.parameters(),lr = 0.0005 )

counter = []
loss_history = [] 
iteration_number= 0

for epoch in range(0,Config.train_number_epochs):
    for i, data in enumerate(train_dataloader,0):

harveyslash

folder_dataset_test = dset.ImageFolder(root=Config.testing_dir)
siamese_dataset = SiameseNetworkDataset(imageFolderDataset=folder_dataset_test,
                                        transform=transforms.Compose([transforms.Scale((100,100)),
                                                                      transforms.ToTensor()
                                                                      ])
                                       ,should_invert=False)

test_dataloader = DataLoader(siamese_dataset,num_workers=6,batch_size=1,shuffle=True)
dataiter = iter(test_dataloader)
x0,_,_ = next(dataiter)

harveyslash

import React, {PropTypes, Component} from 'react';
import * as action from '../actions/action';
import $ from 'jquery';
import {connect} from 'react-redux';
import {bindActionCreators} from 'redux';
import UserPanel from './UserPanel';
import Navlink from './Navlink';
import Footer from './Footer';
import UserMenu from './UserMenu';

harveyslash

def get_highest_score(test_id):
    test_attempts = db.session.query(TestAttempt).filter_by(test_id=test_id)
    scores = []
    if test_attempts.count() < 1:
        return {'max_score': 0}
    for each in test_attempts:
        user_id = each.user_id
        test_id = each.test_id
        if each.is_complete:
            k = get_college_test_attempt_score(test_id, user_id)['score']